test(eth): eip712 more tests

Author: Unique-Divine

eth/crypto/hd/algorithm_test.go

@@ -13,9 +13,9 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 
+	"github.com/NibiruChain/nibiru/eth"
 	cryptocodec "github.com/NibiruChain/nibiru/eth/crypto/codec"
 	enccodec "github.com/NibiruChain/nibiru/eth/encoding/codec"
-	ethtypes "github.com/NibiruChain/nibiru/eth"
 )
 
 var TestCodec amino.Codec
@@ -52,7 +52,7 @@ func TestKeyring(t *testing.T) {
 	require.Nil(t, info)
 
 	mockIn.Reset("password\npassword\n")
-	info, mnemonic, err := kr.NewMnemonic("foo", keyring.English, ethtypes.BIP44HDPath, keyring.DefaultBIP39Passphrase, EthSecp256k1)
+	info, mnemonic, err := kr.NewMnemonic("foo", keyring.English, eth.BIP44HDPath, keyring.DefaultBIP39Passphrase, EthSecp256k1)
 	require.NoError(t, err)
 	require.NotEmpty(t, mnemonic)
 	require.Equal(t, "foo", info.Name)
@@ -61,7 +61,7 @@ func TestKeyring(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, string(EthSecp256k1Type), pubKey.Type())
 
-	hdPath := ethtypes.BIP44HDPath
+	hdPath := eth.BIP44HDPath
 
 	bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, hdPath)
 	require.NoError(t, err)
@@ -87,7 +87,7 @@ func TestKeyring(t *testing.T) {
 }
 
 func TestDerivation(t *testing.T) {
-	bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, ethtypes.BIP44HDPath)
+	bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, eth.BIP44HDPath)
 	require.NoError(t, err)
 	require.NotEmpty(t, bz)
 
@@ -105,7 +105,7 @@ func TestDerivation(t *testing.T) {
 	wallet, err := NewFromMnemonic(mnemonic)
 	require.NoError(t, err)
 
-	path := MustParseDerivationPath(ethtypes.BIP44HDPath)
+	path := MustParseDerivationPath(eth.BIP44HDPath)
 	account, err := wallet.Derive(path, false)
 	require.NoError(t, err)
 

eth/eip712/eip712_fuzzer_test.go

@@ -54,102 +54,102 @@ var params = EIP712FuzzTestParams{
 // variable input sizes, types, and fields. While it may be possible to translate a single input into
 // a JSON object, it would require difficult parsing, and ultimately approximates our randomized unit
 // tests as they are.
-func (suite *EIP712TestSuite) TestRandomPayloadFlattening() {
+func (s *EIP712TestSuite) TestRandomPayloadFlattening() {
 	// Re-seed rand generator
 	rand.Seed(rand.Int64())
 
 	for i := 0; i < params.numTestObjects; i++ {
-		suite.Run(fmt.Sprintf("%v%d", fuzzTestName, i), func() {
-			payload := suite.generateRandomPayload(i)
+		s.Run(fmt.Sprintf("%v%d", fuzzTestName, i), func() {
+			payload := s.generateRandomPayload(i)
 
 			flattened, numMessages, err := eip712.FlattenPayloadMessages(payload)
 
-			suite.Require().NoError(err)
-			suite.Require().Equal(numMessages, i)
+			s.Require().NoError(err)
+			s.Require().Equal(numMessages, i)
 
-			suite.verifyPayloadAgainstFlattened(payload, flattened)
+			s.verifyPayloadAgainstFlattened(payload, flattened)
 		})
 	}
 }
 
 // generateRandomPayload creates a random payload of the desired format, with random sub-objects.
-func (suite *EIP712TestSuite) generateRandomPayload(numMessages int) gjson.Result {
-	payload := suite.createRandomJSONObject().Raw
+func (s *EIP712TestSuite) generateRandomPayload(numMessages int) gjson.Result {
+	payload := s.createRandomJSONObject().Raw
 	msgs := make([]gjson.Result, numMessages)
 
 	for i := 0; i < numMessages; i++ {
-		msgs[i] = suite.createRandomJSONObject()
+		msgs[i] = s.createRandomJSONObject()
 	}
 
 	payload, err := sjson.Set(payload, msgsFieldName, msgs)
-	suite.Require().NoError(err)
+	s.Require().NoError(err)
 
 	return gjson.Parse(payload)
 }
 
 // createRandomJSONObject creates a JSON object with random fields.
-func (suite *EIP712TestSuite) createRandomJSONObject() gjson.Result {
+func (s *EIP712TestSuite) createRandomJSONObject() gjson.Result {
 	var err error
 	payloadRaw := ""
 
-	numFields := suite.createRandomIntInRange(0, params.maxNumFieldsPerObject)
+	numFields := s.createRandomIntInRange(0, params.maxNumFieldsPerObject)
 	for i := 0; i < numFields; i++ {
-		key := suite.createRandomString()
+		key := s.createRandomString()
 
-		randField := suite.createRandomJSONField(i, 0)
+		randField := s.createRandomJSONField(i, 0)
 		payloadRaw, err = sjson.Set(payloadRaw, key, randField)
-		suite.Require().NoError(err)
+		s.Require().NoError(err)
 	}
 
 	return gjson.Parse(payloadRaw)
 }
 
 // createRandomJSONField creates a random field with a random JSON type, with the possibility of
 // nested fields up to depth objects.
-func (suite *EIP712TestSuite) createRandomJSONField(t int, depth int) interface{} {
+func (s *EIP712TestSuite) createRandomJSONField(t int, depth int) interface{} {
 	switch t % numJSONTypes {
 	case jsonBoolType:
-		return suite.createRandomBoolean()
+		return s.createRandomBoolean()
 	case jsonStringType:
-		return suite.createRandomString()
+		return s.createRandomString()
 	case jsonFloatType:
-		return suite.createRandomFloat()
+		return s.createRandomFloat()
 	case jsonArrayType:
-		return suite.createRandomJSONNestedArray(depth)
+		return s.createRandomJSONNestedArray(depth)
 	case jsonObjectType:
-		return suite.createRandomJSONNestedObject(depth)
+		return s.createRandomJSONNestedObject(depth)
 	default:
 		return nil
 	}
 }
 
 // createRandomJSONNestedArray creates an array of random nested JSON fields.
-func (suite *EIP712TestSuite) createRandomJSONNestedArray(depth int) []interface{} {
+func (s *EIP712TestSuite) createRandomJSONNestedArray(depth int) []interface{} {
 	arr := make([]interface{}, rand.Intn(params.maxArrayLength))
 	for i := range arr {
-		arr[i] = suite.createRandomJSONNestedField(depth)
+		arr[i] = s.createRandomJSONNestedField(depth)
 	}
 
 	return arr
 }
 
 // createRandomJSONNestedObject creates a key-value set of objects with random nested JSON fields.
-func (suite *EIP712TestSuite) createRandomJSONNestedObject(depth int) interface{} {
+func (s *EIP712TestSuite) createRandomJSONNestedObject(depth int) interface{} {
 	numFields := rand.Intn(params.maxNumFieldsPerObject)
 	obj := make(map[string]interface{})
 
 	for i := 0; i < numFields; i++ {
-		subField := suite.createRandomJSONNestedField(depth)
+		subField := s.createRandomJSONNestedField(depth)
 
-		obj[suite.createRandomString()] = subField
+		obj[s.createRandomString()] = subField
 	}
 
 	return obj
 }
 
 // createRandomJSONNestedField serves as a helper for createRandomJSONField and returns a random
 // subfield to populate an array or object type.
-func (suite *EIP712TestSuite) createRandomJSONNestedField(depth int) interface{} {
+func (s *EIP712TestSuite) createRandomJSONNestedField(depth int) interface{} {
 	var newFieldType int
 
 	if depth == params.maxObjectDepth {
@@ -158,23 +158,23 @@ func (suite *EIP712TestSuite) createRandomJSONNestedField(depth int) interface{}
 		newFieldType = rand.Intn(numJSONTypes)
 	}
 
-	return suite.createRandomJSONField(newFieldType, depth+1)
+	return s.createRandomJSONField(newFieldType, depth+1)
 }
 
-func (suite *EIP712TestSuite) createRandomBoolean() bool {
+func (s *EIP712TestSuite) createRandomBoolean() bool {
 	return rand.Intn(2) == 0
 }
 
-func (suite *EIP712TestSuite) createRandomFloat() float64 {
+func (s *EIP712TestSuite) createRandomFloat() float64 {
 	return (rand.Float64() - 0.5) * params.randomFloatRange
 }
 
-func (suite *EIP712TestSuite) createRandomString() string {
-	bzLen := suite.createRandomIntInRange(params.minStringLength, params.maxStringLength)
+func (s *EIP712TestSuite) createRandomString() string {
+	bzLen := s.createRandomIntInRange(params.minStringLength, params.maxStringLength)
 	bz := make([]byte, bzLen)
 
 	for i := 0; i < bzLen; i++ {
-		bz[i] = byte(suite.createRandomIntInRange(asciiRangeStart, asciiRangeEnd))
+		bz[i] = byte(s.createRandomIntInRange(asciiRangeStart, asciiRangeEnd))
 	}
 
 	str := string(bz)
@@ -189,6 +189,6 @@ func (suite *EIP712TestSuite) createRandomString() string {
 }
 
 // createRandomIntInRange provides a random integer between [min, max)
-func (suite *EIP712TestSuite) createRandomIntInRange(min int, max int) int {
+func (s *EIP712TestSuite) createRandomIntInRange(min int, max int) int {
 	return rand.Intn(max-min) + min
 }