feat: add more ctors for felt-like types (and remove unnecessary utilities) (#3142)

Author: rodrigo-pino

adapters/consensus2p2p/testutils/consensus_p2p_adapters_test_utils.go

@@ -14,7 +14,6 @@ import (
 	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/common"
 	p2pconsensus "github.com/starknet-io/starknet-p2pspecs/p2p/proto/consensus/consensus"
 	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/transaction"
-	"github.com/stretchr/testify/require"
 )
 
 var TransactionBuilder = transactiontestutils.TransactionBuilder[consensus.Transaction, *p2pconsensus.ConsensusTransaction]{
@@ -60,12 +59,11 @@ var TransactionBuilder = transactiontestutils.TransactionBuilder[consensus.Trans
 }
 
 func getRandomFelt(t *testing.T) (felt.Felt, []byte) {
-	felt := felt.Felt{}
-	_, err := felt.SetRandom()
-	require.NoError(t, err)
+	t.Helper()
 
-	feltBytes := felt.Bytes()
-	return felt, feltBytes[:]
+	f := felt.Random[felt.Felt]()
+	feltBytes := f.Bytes()
+	return f, feltBytes[:]
 }
 
 func getRandomUint128() (*felt.Felt, *common.Uint128) {

adapters/p2p2core/felt_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/NethermindEth/juno/core/felt"
-	"github.com/NethermindEth/juno/utils"
 	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/common"
 	"github.com/stretchr/testify/assert"
 )
@@ -25,7 +24,7 @@ func TestAdaptUint128(t *testing.T) {
 			Low, High uint64
 			Expect    *felt.Felt
 		}{
-			{32, 64, utils.HexToFelt(t, "0x400000000000000020")},
+			{32, 64, felt.NewUnsafeFromString[felt.Felt]("0x400000000000000020")},
 		}
 
 		for _, c := range cases {

adapters/p2p2core/receipt_test.go

@@ -4,14 +4,14 @@ import (
 	"testing"
 
 	"github.com/NethermindEth/juno/adapters/p2p2core"
-	"github.com/NethermindEth/juno/utils"
+	"github.com/NethermindEth/juno/core/felt"
 	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/sync/receipt"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestAdaptReceipt(t *testing.T) {
 	t.Run("successful", func(t *testing.T) {
-		hash := utils.HexToFelt(t, "0xCAFEBABE")
+		hash := felt.NewUnsafeFromString[felt.Felt]("0xCAFEBABE")
 		receipt := &receipt.Receipt{
 			Type: &receipt.Receipt_L1Handler_{
 				L1Handler: &receipt.Receipt_L1Handler{
@@ -29,7 +29,7 @@ func TestAdaptReceipt(t *testing.T) {
 		reasons := []string{"reason", ""}
 
 		for _, reason := range reasons {
-			hash := utils.HexToFelt(t, "0xCAFEDEAD")
+			hash := felt.NewUnsafeFromString[felt.Felt]("0xCAFEDEAD")
 			receipt := &receipt.Receipt{
 				Type: &receipt.Receipt_L1Handler_{
 					L1Handler: &receipt.Receipt_L1Handler{

adapters/sn2core/sn2core_test.go

@@ -46,16 +46,15 @@ func GetTestTransactions[C, P any](t *testing.T, network *utils.Network, factori
 
 func getRandomFelt(t *testing.T) (felt.Felt, []byte) {
 	t.Helper()
-	felt := felt.Felt{}
-	_, err := felt.SetRandom()
-	require.NoError(t, err)
 
-	feltBytes := felt.Bytes()
-	return felt, feltBytes[:]
+	f := felt.Random[felt.Felt]()
+	feltBytes := f.Bytes()
+	return f, feltBytes[:]
 }
 
 func getRandomFeltSlice(t *testing.T) ([]*felt.Felt, [][]byte) {
 	t.Helper()
+
 	size := rand.IntN(maxTransactionSize)
 	underlyingFelts := make([]felt.Felt, size)
 	felts := make([]*felt.Felt, size)

adapters/testutils/transaction_test_utils.go

@@ -16,8 +16,7 @@ import (
 // randomContractAddress generates a random contract address (felt) for testing.
 func randomContractAddress(t *testing.T) *felt.Felt {
 	t.Helper()
-	addr, err := new(felt.Felt).SetRandom()
-	require.NoError(t, err)
+	addr := felt.NewRandom[felt.Felt]()
 	return addr
 }
 
@@ -29,8 +28,7 @@ func randomEventKeys(t *testing.T, keysPerEvent, subKeysPerKey int) [][]felt.Fel
 	for i := range keys {
 		keys[i] = make([]felt.Felt, subKeysPerKey)
 		for j := range keys[i] {
-			key, err := new(felt.Felt).SetRandom()
-			require.NoError(t, err)
+			key := felt.NewRandom[felt.Felt]()
 			keys[i][j] = *key
 		}
 	}

blockchain/aggregated_bloom_filter_cache_test.go

@@ -99,16 +99,14 @@ func TestBlockByNumberAndHash(t *testing.T) {
 		assert.EqualError(t, err, db.ErrKeyNotFound.Error())
 	})
 	t.Run("GetBlockByHash returns error if block doesn't exist", func(t *testing.T) {
-		f, err := new(felt.Felt).SetRandom()
-		require.NoError(t, err)
-		_, err = chain.BlockByHash(f)
+		f := felt.NewRandom[felt.Felt]()
+		_, err := chain.BlockByHash(f)
 		assert.EqualError(t, err, db.ErrKeyNotFound.Error())
 	})
 }
 
 func TestVerifyBlock(t *testing.T) {
-	h1, err := new(felt.Felt).SetRandom()
-	require.NoError(t, err)
+	h1 := felt.NewRandom[felt.Felt]()
 
 	chain := blockchain.New(memory.New(), &utils.Mainnet)
 
@@ -198,8 +196,7 @@ func TestVerifyBlock(t *testing.T) {
 }
 
 func TestSanityCheckNewHeight(t *testing.T) {
-	h1, err := new(felt.Felt).SetRandom()
-	require.NoError(t, err)
+	h1 := felt.NewRandom[felt.Felt]()
 
 	chain := blockchain.New(memory.New(), &utils.Mainnet)
 
@@ -310,7 +307,7 @@ func TestStoreL1HandlerTxnHash(t *testing.T) {
 	l1HandlerMsgHash := common.HexToHash("0x42e76df4e3d5255262929c27132bd0d295a8d3db2cfe63d2fcd061c7a7a7ab34")
 	l1HandlerTxnHash, err := chain.L1HandlerTxnHash(&l1HandlerMsgHash)
 	require.NoError(t, err)
-	require.Equal(t, utils.HexToFelt(t, "0x785c2ada3f53fbc66078d47715c27718f92e6e48b96372b36e5197de69b82b5"), l1HandlerTxnHash)
+	require.Equal(t, felt.NewUnsafeFromString[felt.Felt]("0x785c2ada3f53fbc66078d47715c27718f92e6e48b96372b36e5197de69b82b5"), l1HandlerTxnHash)
 }
 
 func TestBlockCommitments(t *testing.T) {
@@ -472,7 +469,7 @@ func TestState(t *testing.T) {
 	})
 
 	t.Run("non-existent hash", func(t *testing.T) {
-		hash, _ := new(felt.Felt).SetRandom()
+		hash := felt.NewRandom[felt.Felt]()
 		_, _, err := chain.StateAtBlockHash(hash)
 		require.Error(t, err)
 	})
@@ -533,7 +530,7 @@ func TestEvents(t *testing.T) {
 		require.NoError(t, filter.Close())
 	})
 
-	from := utils.HexToFelt(t, "0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7")
+	from := felt.NewUnsafeFromString[felt.Felt]("0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7")
 	t.Run("filter with no keys", func(t *testing.T) {
 		filter, err := chain.EventFilter(from, [][]felt.Felt{{}, {}, {}}, pendingBlockFn)
 		require.NoError(t, err)
@@ -575,14 +572,14 @@ func TestEvents(t *testing.T) {
 	})
 
 	t.Run("filter with keys", func(t *testing.T) {
-		key := utils.HexToFelt(t, "0x3774b0545aabb37c45c1eddc6a7dae57de498aae6d5e3589e362d4b4323a533")
+		key := felt.NewUnsafeFromString[felt.Felt]("0x3774b0545aabb37c45c1eddc6a7dae57de498aae6d5e3589e362d4b4323a533")
 		filter, err := chain.EventFilter(from, [][]felt.Felt{{*key}}, pendingBlockFn)
 		require.NoError(t, err)
 
 		require.NoError(t, filter.SetRangeEndBlockByHash(blockchain.EventFilterFrom,
-			utils.HexToFelt(t, "0x3b43b334f46b921938854ba85ffc890c1b1321f8fd69e7b2961b18b4260de14")))
+			felt.NewUnsafeFromString[felt.Felt]("0x3b43b334f46b921938854ba85ffc890c1b1321f8fd69e7b2961b18b4260de14")))
 		require.NoError(t, filter.SetRangeEndBlockByHash(blockchain.EventFilterTo,
-			utils.HexToFelt(t, "0x3b43b334f46b921938854ba85ffc890c1b1321f8fd69e7b2961b18b4260de14")))
+			felt.NewUnsafeFromString[felt.Felt]("0x3b43b334f46b921938854ba85ffc890c1b1321f8fd69e7b2961b18b4260de14")))
 
 		t.Run("get all events without pagination", func(t *testing.T) {
 			events, cToken, err := filter.Events(nil, 10)
@@ -595,8 +592,8 @@ func TestEvents(t *testing.T) {
 
 	t.Run("filter with not matching keys", func(t *testing.T) {
 		filter, err := chain.EventFilter(from, [][]felt.Felt{
-			{*utils.HexToFelt(t, "0x3774b0545aabb37c45c1eddc6a7dae57de498aae6d5e3589e362d4b4323a533")},
-			{*utils.HexToFelt(t, "0xDEADBEEF")},
+			{*felt.NewUnsafeFromString[felt.Felt]("0x3774b0545aabb37c45c1eddc6a7dae57de498aae6d5e3589e362d4b4323a533")},
+			{*felt.NewUnsafeFromString[felt.Felt]("0xDEADBEEF")},
 		}, pendingBlockFn)
 		require.NoError(t, err)
 		require.NoError(t, filter.SetRangeEndBlockByNumber(blockchain.EventFilterFrom, 0))