fix: bigint support (#27)

This PR fixes support for big ints. Instead of leaning on a custom big
int type (`go-state-types/big`), we use native `math/big`.

It also adds support for big ints when marshaling to/from JSON.

JSON encoded numbers do not have a fixed size, so it's impossible to
distingish between `int64` and `big.Int` when decoding, without
inventing a custom representation of these different types. The decision
here is to decode a number to `int64` when the value fits, but otherwise
use a `big.Int`. The trade off is that when encoding "small" big ints,
you'll get back an `int64` when you decode i.e. they won't round trip.

If you need the round trip to work you should use `dag-json-gen` to
generate encoders/decoders. Alternatively use your own custom type, or
`string` or `[]bytes` to represent the value.

Related alanshaw/dag-json-gen#1 for negative
bigint support.

Author: alanshaw

go.mod

@@ -2,11 +2,8 @@ module github.com/fil-forge/ucantone
 
 go 1.25.0
 
-// replace "github.com/alanshaw/dag-json-gen" => ../dag-json-gen
-
 require (
 	github.com/alanshaw/dag-json-gen v0.0.4
-	github.com/filecoin-project/go-state-types v0.18.0
 	github.com/gobwas/glob v0.2.3
 	github.com/ipfs/go-cid v0.6.0
 	github.com/multiformats/go-multibase v0.2.0
@@ -32,6 +29,7 @@ require (
 	gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect
 	golang.org/x/crypto v0.49.0 // indirect
 	golang.org/x/sys v0.42.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	lukechampine.com/blake3 v1.4.1 // indirect
 	pitr.ca/jsontokenizer v0.3.0 // indirect

go.sum

@@ -3,16 +3,17 @@ github.com/alanshaw/dag-json-gen v0.0.4/go.mod h1:rXxWw0SItP9QjxpRMpkju66h0KumF7
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/filecoin-project/go-state-types v0.18.0 h1:oDcjihXRlf2cM176atZzllp79Zc+kcbiuQM9DPL/1a4=
-github.com/filecoin-project/go-state-types v0.18.0/go.mod h1:CcyG4ZQRDWW+QUY2WDf1KtVDRN7W4twjsfgnGbQfJVI=
 github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
 github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 github.com/ipfs/go-cid v0.6.0 h1:DlOReBV1xhHBhhfy/gBNNTSyfOM6rLiIx9J7A4DGf30=
 github.com/ipfs/go-cid v0.6.0/go.mod h1:NC4kS1LZjzfhK40UGmpXv5/qD2kcMzACYJNntCUiDhQ=
 github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
 github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=

ipld/datamodel/any.go

@@ -7,12 +7,12 @@ import (
 	"fmt"
 	"io"
 	"maps"
+	"math/big"
 	"reflect"
 	"slices"
 
 	jsg "github.com/alanshaw/dag-json-gen"
 	"github.com/fil-forge/ucantone/ipld"
-	"github.com/filecoin-project/go-state-types/big"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
@@ -23,9 +23,8 @@ import (
 //   - Null (nil)
 //   - Boolean (bool)
 //   - Integer (int64, int)
-//   - BigInteger (go-state-types/big.Int) — encoded as a CBOR bignum: tag 2
+//   - BigInteger (math/big) — encoded as a CBOR bignum: tag 2
 //     for non-negative values and tag 3 for negative values (RFC 8949).
-//     CBOR only; big integers are not supported in DAG-JSON.
 //   - String (string)
 //   - Bytes ([]byte)
 //   - List ([]Any)
@@ -44,7 +43,7 @@ type Any struct {
 //   - bool
 //   - int
 //   - int64
-//   - big.Int (go-state-types/big; CBOR only)
+//   - math/big.Int
 //   - string
 //   - []byte
 //   - slice
@@ -72,13 +71,9 @@ func (a *Any) MarshalCBOR(w io.Writer) error {
 	case int:
 		return cbg.CborInt(v).MarshalCBOR(w)
 	case big.Int:
-		return marshalCborBigInt(w, v)
+		return marshalCborBigInt(w, &v)
 	case *big.Int:
-		if v == nil {
-			_, err := w.Write(cbg.CborNull)
-			return err
-		}
-		return marshalCborBigInt(w, *v)
+		return marshalCborBigInt(w, v)
 	case bool:
 		return cbg.CborBool(v).MarshalCBOR(w)
 	case cid.Cid:
@@ -171,14 +166,14 @@ func (a *Any) UnmarshalCBOR(r io.Reader) (err error) {
 			if err != nil {
 				return err
 			}
-			a.Value = big.PositiveFromUnsignedBytes(b)
+			a.Value = big.NewInt(0).SetBytes(b)
 			return nil
 		case 3: // CBOR negative bignum (tag 3 + byte string): value = -1 - n
 			b, err := readBignumBytes(pr)
 			if err != nil {
 				return err
 			}
-			a.Value = big.Sub(big.NewInt(-1), big.PositiveFromUnsignedBytes(b))
+			a.Value = big.NewInt(0).Sub(big.NewInt(-1), big.NewInt(0).SetBytes(b))
 			return nil
 		case 42:
 			cbc := cbg.CborCid{}
@@ -273,8 +268,13 @@ func (a *Any) MarshalDagJSON(w io.Writer) error {
 		return jw.WriteInt64(v)
 	case int:
 		return jw.WriteInt64(int64(v))
-	case big.Int, *big.Int:
-		return fmt.Errorf("big integers are not supported in DAG-JSON")
+	case big.Int:
+		return jw.WriteBigInt(&v)
+	case *big.Int:
+		if v == nil {
+			return jw.WriteNull()
+		}
+		return jw.WriteBigInt(v)
 	case bool:
 		return jw.WriteBool(v)
 	case cid.Cid:
@@ -344,11 +344,21 @@ func (a *Any) UnmarshalDagJSON(r io.Reader) (err error) {
 		}
 		a.Value = v
 	case "number":
-		v, err := jr.ReadNumberAsInt64()
+		v, err := jr.ReadNumberAsBigInt(jsg.MaxLength)
 		if err != nil {
 			return err
 		}
-		a.Value = v
+		// There's no distinction in JSON between int64 and big.Int, there is just
+		// number. If the value fits in an int64, return it as an int64. It means
+		// we can't round trip a big.Int that fits in an int64, but there is not
+		// really a good alternative here without inventing our own encoding for
+		// big.Int in JSON. If you need to round trip, use dag-json-gen to generate
+		// your encoders/decoders or use string or bytes or your own type instead.
+		if v.IsInt64() {
+			a.Value = v.Int64()
+		} else {
+			a.Value = v
+		}
 	case "array":
 		if err := jr.ReadArrayOpen(); err != nil {
 			return err
@@ -448,26 +458,26 @@ func (a *Any) UnmarshalDagJSON(r io.Reader) (err error) {
 	return nil
 }
 
-// marshalCborBigInt writes a big.Int as a CBOR bignum (RFC 8949): tag 2 for
+// marshalCborBigInt writes a [big.Int] as a CBOR bignum (RFC 8949): tag 2 for
 // non-negative values and tag 3 for negative values, each followed by a byte
 // string holding the big-endian magnitude. A negative value v is encoded as
 // the magnitude of n = -1 - v, so it round-trips via value = -1 - n on decode.
-func marshalCborBigInt(w io.Writer, v big.Int) error {
-	if v.Nil() {
+func marshalCborBigInt(w io.Writer, v *big.Int) error {
+	if v == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
 	tag := uint64(2)
 	mag := v // non-negative: encode the magnitude directly
 	if v.Sign() < 0 {
 		tag = 3
-		mag = big.Sub(big.NewInt(-1), v) // n = -1 - v
+		mag = big.NewInt(0).Sub(big.NewInt(-1), v) // n = -1 - v
 	}
 	cw := cbg.NewCborWriter(w)
 	if err := cw.WriteMajorTypeHeader(cbg.MajTag, tag); err != nil {
 		return err
 	}
-	b := mag.Int.Bytes() // raw big-endian magnitude (no sign prefix)
+	b := mag.Bytes() // raw big-endian magnitude (no sign prefix)
 	if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(b))); err != nil {
 		return err
 	}

ipld/datamodel/any_test.go

@@ -3,16 +3,23 @@ package datamodel_test
 import (
 	"bytes"
 	"fmt"
+	"math/big"
+	"slices"
 	"testing"
 
 	"github.com/fil-forge/ucantone/ipld"
 	"github.com/fil-forge/ucantone/ipld/datamodel"
 	"github.com/fil-forge/ucantone/testutil"
-	"github.com/filecoin-project/go-state-types/big"
 	"github.com/stretchr/testify/require"
 )
 
 func TestAny(t *testing.T) {
+	gtMaxUint64, ok := big.NewInt(0).SetString("340282366920938463463374607431768211457", 10) // > maxUint64, positive
+	require.True(t, ok)
+
+	ltMinInt64, ok := big.NewInt(0).SetString("-340282366920938463463374607431768211457", 10) // < minInt64, negative
+	require.True(t, ok)
+
 	values := []any{
 		int64(138),
 		true,
@@ -27,12 +34,23 @@ func TestAny(t *testing.T) {
 			"str":   "X",
 			"bytes": []byte{2},
 		},
+		gtMaxUint64,
+		ltMinInt64,
 		// map[string]cid.Cid{
 		// 	"await/ok": testutil.RandomCID(t),
 		// },
 	}
 
-	for _, v := range values {
+	// These values will only round trip as CBOR since JSON encoding does not
+	// allow us to distinguish fixed size integers and arbitrary size bignums.
+	cborValues := append(
+		slices.Clone(values),
+		big.NewInt(0),
+		big.NewInt(138),
+		big.NewInt(-138),
+	)
+
+	for _, v := range cborValues {
 		t.Run(fmt.Sprintf("dag-cbor %T", v), func(t *testing.T) {
 			initial := datamodel.NewAny(v)
 
@@ -45,7 +63,9 @@ func TestAny(t *testing.T) {
 			require.NoError(t, err)
 			require.Equal(t, v, decodedCBOR.Value)
 		})
+	}
 
+	for _, v := range values {
 		t.Run(fmt.Sprintf("dag-json %T", v), func(t *testing.T) {
 			initial := datamodel.NewAny(v)
 
@@ -62,36 +82,3 @@ func TestAny(t *testing.T) {
 		})
 	}
 }
-
-// big.Int is CBOR only (not supported in DAG-JSON), so it round-trips through
-// its own test rather than the shared list above.
-func TestAnyBigInt(t *testing.T) {
-	values := []big.Int{
-		big.NewInt(0),
-		big.NewInt(138),
-		big.NewInt(-138),
-		big.MustFromString("340282366920938463463374607431768211457"),  // > maxUint64, positive
-		big.MustFromString("-340282366920938463463374607431768211457"), // < minInt64, negative
-	}
-
-	for _, v := range values {
-		t.Run(fmt.Sprintf("dag-cbor %s", v), func(t *testing.T) {
-			initial := datamodel.NewAny(v)
-
-			var buf bytes.Buffer
-			err := initial.MarshalCBOR(&buf)
-			require.NoError(t, err)
-
-			var decoded datamodel.Any
-			err = decoded.UnmarshalCBOR(&buf)
-			require.NoError(t, err)
-			require.Equal(t, v, decoded.Value)
-		})
-
-		t.Run(fmt.Sprintf("dag-json unsupported %s", v), func(t *testing.T) {
-			var buf bytes.Buffer
-			err := datamodel.NewAny(v).MarshalDagJSON(&buf)
-			require.Error(t, err)
-		})
-	}
-}