diff --git a/adapters/sn2core/sn2core_test.go b/adapters/sn2core/sn2core_test.go
index c6ccb0de28..70555c37c0 100644
--- a/adapters/sn2core/sn2core_test.go
+++ b/adapters/sn2core/sn2core_test.go
@@ -63,7 +63,7 @@ func TestAdaptBlock(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.network.String()+" block number "+strconv.FormatUint(test.number, 10), func(t *testing.T) {
-			client := feeder.NewTestClient(t, test.network)
+			client := feeder.NewTestClient(t, &test.network)
 
 			response, err := client.Block(ctx, strconv.FormatUint(test.number, 10))
 			require.NoError(t, err)
@@ -108,7 +108,7 @@ func TestAdaptBlock(t *testing.T) {
 func TestStateUpdate(t *testing.T) {
 	numbers := []uint64{0, 1, 2, 21656}
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	ctx := context.Background()
 
 	for _, number := range numbers {
@@ -157,7 +157,7 @@ func TestStateUpdate(t *testing.T) {
 	}
 
 	t.Run("v0.11.0 state update", func(t *testing.T) {
-		integClient := feeder.NewTestClient(t, utils.Integration)
+		integClient := feeder.NewTestClient(t, &utils.Integration)
 
 		t.Run("declared Cairo0 classes", func(t *testing.T) {
 			feederUpdate, err := integClient.StateUpdate(ctx, "283746")
@@ -199,7 +199,7 @@ func TestClassV0(t *testing.T) {
 		"0x56b96c1d1bbfa01af44b465763d1b71150fa00c6c9d54c3947f57e979ff68c3",
 	}
 
-	client := feeder.NewTestClient(t, utils.Goerli)
+	client := feeder.NewTestClient(t, &utils.Goerli)
 	ctx := context.Background()
 
 	for _, hashString := range classHashes {
@@ -236,8 +236,8 @@ func TestClassV0(t *testing.T) {
 }
 
 func TestTransaction(t *testing.T) {
-	clientGoerli := feeder.NewTestClient(t, utils.Goerli)
-	clientMainnet := feeder.NewTestClient(t, utils.Mainnet)
+	clientGoerli := feeder.NewTestClient(t, &utils.Goerli)
+	clientMainnet := feeder.NewTestClient(t, &utils.Mainnet)
 	ctx := context.Background()
 
 	t.Run("invoke transaction", func(t *testing.T) {
@@ -348,7 +348,7 @@ func TestTransaction(t *testing.T) {
 }
 
 func TestTransactionV3(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	ctx := context.Background()
 
 	tests := map[string]core.Transaction{
@@ -469,7 +469,7 @@ func TestTransactionV3(t *testing.T) {
 }
 
 func TestClassV1(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 
 	classHash := utils.HexToFelt(t, "0x1cd2edfb485241c4403254d550de0a097fa76743cd30696f714a491a454bad5")
 
diff --git a/blockchain/blockchain.go b/blockchain/blockchain.go
index 75d5175aee..1517558e4b 100644
--- a/blockchain/blockchain.go
+++ b/blockchain/blockchain.go
@@ -77,11 +77,11 @@ type Blockchain struct {
 	cachedPending atomic.Pointer[Pending]
 }
 
-func New(database db.DB, network utils.Network, log utils.SimpleLogger) *Blockchain {
+func New(database db.DB, network *utils.Network, log utils.SimpleLogger) *Blockchain {
 	RegisterCoreTypesToEncoder()
 	return &Blockchain{
 		database: database,
-		network:  network,
+		network:  *network,
 		log:      log,
 		listener: &SelectiveListener{},
 	}
@@ -639,7 +639,7 @@ func (b *Blockchain) SanityCheckNewHeight(block *core.Block, stateUpdate *core.S
 		return nil, err
 	}
 
-	return core.VerifyBlockHash(block, b.network)
+	return core.VerifyBlockHash(block, &b.network)
 }
 
 type txAndReceiptDBKey struct {
diff --git a/blockchain/blockchain_test.go b/blockchain/blockchain_test.go
index e975028f6a..e2321206e9 100644
--- a/blockchain/blockchain_test.go
+++ b/blockchain/blockchain_test.go
@@ -22,11 +22,11 @@ import (
 var emptyCommitments = core.BlockCommitments{}
 
 func TestNew(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 	log := utils.NewNopZapLogger()
 	t.Run("empty blockchain's head is nil", func(t *testing.T) {
-		chain := blockchain.New(pebble.NewMemTest(t), utils.Mainnet, log)
+		chain := blockchain.New(pebble.NewMemTest(t), &utils.Mainnet, log)
 		assert.Equal(t, utils.Mainnet, chain.Network())
 		b, err := chain.Head()
 		assert.Nil(t, b)
@@ -40,10 +40,10 @@ func TestNew(t *testing.T) {
 		require.NoError(t, err)
 
 		testDB := pebble.NewMemTest(t)
-		chain := blockchain.New(testDB, utils.Mainnet, log)
+		chain := blockchain.New(testDB, &utils.Mainnet, log)
 		assert.NoError(t, chain.Store(block0, &emptyCommitments, stateUpdate0, nil))
 
-		chain = blockchain.New(testDB, utils.Mainnet, log)
+		chain = blockchain.New(testDB, &utils.Mainnet, log)
 		b, err := chain.Head()
 		require.NoError(t, err)
 		assert.Equal(t, block0, b)
@@ -51,11 +51,11 @@ func TestNew(t *testing.T) {
 }
 
 func TestHeight(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 	log := utils.NewNopZapLogger()
 	t.Run("return nil if blockchain is empty", func(t *testing.T) {
-		chain := blockchain.New(pebble.NewMemTest(t), utils.Goerli, log)
+		chain := blockchain.New(pebble.NewMemTest(t), &utils.Goerli, log)
 		_, err := chain.Height()
 		assert.Error(t, err)
 	})
@@ -67,10 +67,10 @@ func TestHeight(t *testing.T) {
 		require.NoError(t, err)
 
 		testDB := pebble.NewMemTest(t)
-		chain := blockchain.New(testDB, utils.Mainnet, log)
+		chain := blockchain.New(testDB, &utils.Mainnet, log)
 		assert.NoError(t, chain.Store(block0, &emptyCommitments, stateUpdate0, nil))
 
-		chain = blockchain.New(testDB, utils.Mainnet, log)
+		chain = blockchain.New(testDB, &utils.Mainnet, log)
 		height, err := chain.Height()
 		require.NoError(t, err)
 		assert.Equal(t, block0.Number, height)
@@ -78,9 +78,9 @@ func TestHeight(t *testing.T) {
 }
 
 func TestBlockByNumberAndHash(t *testing.T) {
-	chain := blockchain.New(pebble.NewMemTest(t), utils.Goerli, utils.NewNopZapLogger())
+	chain := blockchain.New(pebble.NewMemTest(t), &utils.Goerli, utils.NewNopZapLogger())
 	t.Run("same block is returned for both GetBlockByNumber and GetBlockByHash", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Mainnet)
+		client := feeder.NewTestClient(t, &utils.Mainnet)
 		gw := adaptfeeder.New(client)
 
 		block, err := gw.BlockByNumber(context.Background(), 0)
@@ -114,7 +114,7 @@ func TestVerifyBlock(t *testing.T) {
 	h1, err := new(felt.Felt).SetRandom()
 	require.NoError(t, err)
 
-	chain := blockchain.New(pebble.NewMemTest(t), utils.Mainnet, utils.NewNopZapLogger())
+	chain := blockchain.New(pebble.NewMemTest(t), &utils.Mainnet, utils.NewNopZapLogger())
 
 	t.Run("error if chain is empty and incoming block number is not 0", func(t *testing.T) {
 		block := &core.Block{Header: &core.Header{Number: 10}}
@@ -126,7 +126,7 @@ func TestVerifyBlock(t *testing.T) {
 		assert.EqualError(t, chain.VerifyBlock(block), "block's parent hash does not match head block hash")
 	})
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	gw := adaptfeeder.New(client)
 	mainnetBlock0, err := gw.BlockByNumber(context.Background(), 0)
@@ -176,9 +176,9 @@ func TestSanityCheckNewHeight(t *testing.T) {
 	h1, err := new(felt.Felt).SetRandom()
 	require.NoError(t, err)
 
-	chain := blockchain.New(pebble.NewMemTest(t), utils.Mainnet, utils.NewNopZapLogger())
+	chain := blockchain.New(pebble.NewMemTest(t), &utils.Mainnet, utils.NewNopZapLogger())
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	gw := adaptfeeder.New(client)
 
@@ -211,7 +211,7 @@ func TestSanityCheckNewHeight(t *testing.T) {
 }
 
 func TestStore(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 	log := utils.NewNopZapLogger()
 
@@ -222,7 +222,7 @@ func TestStore(t *testing.T) {
 	require.NoError(t, err)
 
 	t.Run("add block to empty blockchain", func(t *testing.T) {
-		chain := blockchain.New(pebble.NewMemTest(t), utils.Mainnet, log)
+		chain := blockchain.New(pebble.NewMemTest(t), &utils.Mainnet, log)
 		require.NoError(t, chain.Store(block0, &emptyCommitments, stateUpdate0, nil))
 
 		headBlock, err := chain.Head()
@@ -248,7 +248,7 @@ func TestStore(t *testing.T) {
 		stateUpdate1, err := gw.StateUpdate(context.Background(), 1)
 		require.NoError(t, err)
 
-		chain := blockchain.New(pebble.NewMemTest(t), utils.Mainnet, log)
+		chain := blockchain.New(pebble.NewMemTest(t), &utils.Mainnet, log)
 		require.NoError(t, chain.Store(block0, &emptyCommitments, stateUpdate0, nil))
 		require.NoError(t, chain.Store(block1, &emptyCommitments, stateUpdate1, nil))
 
@@ -271,9 +271,9 @@ func TestStore(t *testing.T) {
 }
 
 func TestTransactionAndReceipt(t *testing.T) {
-	chain := blockchain.New(pebble.NewMemTest(t), utils.Mainnet, utils.NewNopZapLogger())
+	chain := blockchain.New(pebble.NewMemTest(t), &utils.Mainnet, utils.NewNopZapLogger())
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	for i := uint64(0); i < 3; i++ {
@@ -359,9 +359,9 @@ func TestTransactionAndReceipt(t *testing.T) {
 
 func TestState(t *testing.T) {
 	testDB := pebble.NewMemTest(t)
-	chain := blockchain.New(testDB, utils.Mainnet, utils.NewNopZapLogger())
+	chain := blockchain.New(testDB, &utils.Mainnet, utils.NewNopZapLogger())
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	t.Run("head with no blocks", func(t *testing.T) {
@@ -422,9 +422,9 @@ func TestState(t *testing.T) {
 
 func TestEvents(t *testing.T) {
 	testDB := pebble.NewMemTest(t)
-	chain := blockchain.New(testDB, utils.Goerli2, utils.NewNopZapLogger())
+	chain := blockchain.New(testDB, &utils.Goerli2, utils.NewNopZapLogger())
 
-	client := feeder.NewTestClient(t, utils.Goerli2)
+	client := feeder.NewTestClient(t, &utils.Goerli2)
 	gw := adaptfeeder.New(client)
 
 	for i := 0; i < 7; i++ {
@@ -541,9 +541,9 @@ func TestEvents(t *testing.T) {
 
 func TestRevert(t *testing.T) {
 	testdb := pebble.NewMemTest(t)
-	chain := blockchain.New(testdb, utils.Mainnet, utils.NewNopZapLogger())
+	chain := blockchain.New(testdb, &utils.Mainnet, utils.NewNopZapLogger())
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	for i := uint64(0); i < 3; i++ {
@@ -625,7 +625,7 @@ func TestL1Update(t *testing.T) {
 
 	for _, head := range heads {
 		t.Run(fmt.Sprintf("update L1 head to block %d", head.BlockNumber), func(t *testing.T) {
-			chain := blockchain.New(pebble.NewMemTest(t), utils.Mainnet, utils.NewNopZapLogger())
+			chain := blockchain.New(pebble.NewMemTest(t), &utils.Mainnet, utils.NewNopZapLogger())
 			require.NoError(t, chain.SetL1Head(head))
 			got, err := chain.L1Head()
 			require.NoError(t, err)
@@ -636,8 +636,8 @@ func TestL1Update(t *testing.T) {
 
 func TestPending(t *testing.T) {
 	testDB := pebble.NewMemTest(t)
-	chain := blockchain.New(testDB, utils.Mainnet, utils.NewNopZapLogger())
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	chain := blockchain.New(testDB, &utils.Mainnet, utils.NewNopZapLogger())
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	b, err := gw.BlockByNumber(context.Background(), 0)
diff --git a/clients/feeder/feeder.go b/clients/feeder/feeder.go
index 58033c13e9..55ff19bb00 100644
--- a/clients/feeder/feeder.go
+++ b/clients/feeder/feeder.go
@@ -76,7 +76,7 @@ func NopBackoff(d time.Duration) time.Duration {
 }
 
 // NewTestClient returns a client and a function to close a test server.
-func NewTestClient(t *testing.T, network utils.Network) *Client {
+func NewTestClient(t *testing.T, network *utils.Network) *Client {
 	srv := newTestServer(network)
 	t.Cleanup(srv.Close)
 	ua := "Juno/v0.0.1-test Starknet Implementation"
@@ -100,7 +100,7 @@ func NewTestClient(t *testing.T, network utils.Network) *Client {
 	return c
 }
 
-func newTestServer(network utils.Network) *httptest.Server {
+func newTestServer(network *utils.Network) *httptest.Server {
 	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		queryMap, err := url.ParseQuery(r.URL.RawQuery)
 		if err != nil {
diff --git a/clients/feeder/feeder_test.go b/clients/feeder/feeder_test.go
index cc88032e1d..e7580c4170 100644
--- a/clients/feeder/feeder_test.go
+++ b/clients/feeder/feeder_test.go
@@ -22,7 +22,7 @@ const (
 
 func TestDeclareTransactionUnmarshal(t *testing.T) {
 	t.Run("pre-v0.3", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Mainnet)
+		client := feeder.NewTestClient(t, &utils.Mainnet)
 		txnHash := utils.HexToFelt(t, "0x93f542728e403f1edcea4a41f1509a39be35ebcad7d4b5aa77623e5e6480d")
 		status, err := client.Transaction(context.Background(), txnHash)
 		require.NoError(t, err)
@@ -41,7 +41,7 @@ func TestDeclareTransactionUnmarshal(t *testing.T) {
 	})
 
 	t.Run("v0.3", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Integration)
+		client := feeder.NewTestClient(t, &utils.Integration)
 		txnHash := utils.HexToFelt(t, "0x41d1f5206ef58a443e7d3d1ca073171ec25fa75313394318fc83a074a6631c3")
 		status, err := client.Transaction(context.Background(), txnHash)
 		require.NoError(t, err)
@@ -79,7 +79,7 @@ func TestDeclareTransactionUnmarshal(t *testing.T) {
 
 func TestInvokeTransactionUnmarshal(t *testing.T) {
 	t.Run("pre-v0.3", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Mainnet)
+		client := feeder.NewTestClient(t, &utils.Mainnet)
 
 		txnHash := utils.HexToFelt(t, "0x631333277e88053336d8c302630b4420dc3ff24018a1c464da37d5e36ea19df")
 		status, err := client.Transaction(context.Background(), txnHash)
@@ -99,7 +99,7 @@ func TestInvokeTransactionUnmarshal(t *testing.T) {
 	})
 
 	t.Run("v0.3", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Integration)
+		client := feeder.NewTestClient(t, &utils.Integration)
 		txnHash := utils.HexToFelt(t, "0x49728601e0bb2f48ce506b0cbd9c0e2a9e50d95858aa41463f46386dca489fd")
 		status, err := client.Transaction(context.Background(), txnHash)
 		require.NoError(t, err)
@@ -152,7 +152,7 @@ func TestInvokeTransactionUnmarshal(t *testing.T) {
 
 //nolint:dupl
 func TestDeployTransactionUnmarshal(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	txnHash := utils.HexToFelt(t, "0x6d3e06989ee2245139cd677f59b4da7f360a27b2b614a4eb088fdf5862d23ee")
 	status, err := client.Transaction(context.Background(), txnHash)
@@ -174,7 +174,7 @@ func TestDeployTransactionUnmarshal(t *testing.T) {
 
 func TestDeployAccountTransactionUnmarshal(t *testing.T) {
 	t.Run("pre-v0.3", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Mainnet)
+		client := feeder.NewTestClient(t, &utils.Mainnet)
 
 		txnHash := utils.HexToFelt(t, "0x32b272b6d0d584305a460197aa849b5c7a9a85903b66e9d3e1afa2427ef093e")
 		status, err := client.Transaction(context.Background(), txnHash)
@@ -202,7 +202,7 @@ func TestDeployAccountTransactionUnmarshal(t *testing.T) {
 	})
 
 	t.Run("v0.3", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Integration)
+		client := feeder.NewTestClient(t, &utils.Integration)
 		txnHash := utils.HexToFelt(t, "0x29fd7881f14380842414cdfdd8d6c0b1f2174f8916edcfeb1ede1eb26ac3ef0")
 		status, err := client.Transaction(context.Background(), txnHash)
 		require.NoError(t, err)
@@ -242,7 +242,7 @@ func TestDeployAccountTransactionUnmarshal(t *testing.T) {
 
 //nolint:dupl
 func TestL1HandlerTransactionUnmarshal(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	txnHash := utils.HexToFelt(t, "0x218adbb5aea7985d67fe49b45d44a991380b63db41622f9f4adc36274d02190")
 	status, err := client.Transaction(context.Background(), txnHash)
@@ -263,7 +263,7 @@ func TestL1HandlerTransactionUnmarshal(t *testing.T) {
 }
 
 func TestBlockWithoutSequencerAddressUnmarshal(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	block, err := client.Block(context.Background(), strconv.Itoa(11817))
 	require.NoError(t, err)
@@ -281,7 +281,7 @@ func TestBlockWithoutSequencerAddressUnmarshal(t *testing.T) {
 }
 
 func TestBlockWithSequencerAddressUnmarshal(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	block, err := client.Block(context.Background(), strconv.Itoa(19199))
 	require.NoError(t, err)
@@ -300,7 +300,7 @@ func TestBlockWithSequencerAddressUnmarshal(t *testing.T) {
 }
 
 func TestBlockHeaderV013Unmarshal(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	block, err := client.Block(context.Background(), "319132")
 	require.NoError(t, err)
 
@@ -317,7 +317,7 @@ func TestBlockHeaderV013Unmarshal(t *testing.T) {
 }
 
 func TestClassV0Unmarshal(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	hash := utils.HexToFelt(t, "0x01efa8f84fd4dff9e2902ec88717cf0dafc8c188f80c3450615944a469428f7f")
 	class, err := client.ClassDefinition(context.Background(), hash)
@@ -335,7 +335,7 @@ func TestClassV0Unmarshal(t *testing.T) {
 }
 
 func TestClassV1Unmarshal(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 
 	hash := utils.HexToFelt(t, "0x4e70b19333ae94bd958625f7b61ce9eec631653597e68645e13780061b2136c")
 	class, err := client.ClassDefinition(context.Background(), hash)
@@ -375,7 +375,7 @@ func TestBuildQueryString_WithErrorUrl(t *testing.T) {
 }
 
 func TestStateUpdate(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	t.Run("Test normal case", func(t *testing.T) {
 		stateUpdate, err := client.StateUpdate(context.Background(), "0")
@@ -404,7 +404,7 @@ func TestStateUpdate(t *testing.T) {
 	})
 
 	t.Run("v0.11.0 state update", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Integration)
+		client := feeder.NewTestClient(t, &utils.Integration)
 
 		t.Run("declared Cairo0 classes", func(t *testing.T) {
 			update, err := client.StateUpdate(context.Background(), "283746")
@@ -427,7 +427,7 @@ func TestStateUpdate(t *testing.T) {
 }
 
 func TestTransaction(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	t.Run("Test normal case", func(t *testing.T) {
 		transactionHash := utils.HexToFelt(t, "0x631333277e88053336d8c302630b4420dc3ff24018a1c464da37d5e36ea19df")
@@ -444,7 +444,7 @@ func TestTransaction(t *testing.T) {
 }
 
 func TestBlock(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	t.Run("Test normal case", func(t *testing.T) {
 		actualBlock, err := client.Block(context.Background(), strconv.Itoa(11817))
@@ -464,7 +464,7 @@ func TestBlock(t *testing.T) {
 }
 
 func TestClassDefinition(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 
 	t.Run("Test normal case", func(t *testing.T) {
 		classHash := utils.HexToFelt(t, "0x01efa8f84fd4dff9e2902ec88717cf0dafc8c188f80c3450615944a469428f7f")
@@ -533,7 +533,7 @@ func TestBackoffFailure(t *testing.T) {
 }
 
 func TestCompiledClassDefinition(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 
 	classHash := utils.HexToFelt(t, "0x1cd2edfb485241c4403254d550de0a097fa76743cd30696f714a491a454bad5")
 	class, err := client.CompiledClassDefinition(context.Background(), classHash)
@@ -542,7 +542,7 @@ func TestCompiledClassDefinition(t *testing.T) {
 }
 
 func TestTransactionStatusRevertError(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 
 	txnHash := utils.HexToFelt(t, "0x19abec18bbacec23c2eee160c70190a48e4b41dd5ff98ad8f247f9393559998")
 	status, err := client.Transaction(context.Background(), txnHash)
@@ -551,7 +551,7 @@ func TestTransactionStatusRevertError(t *testing.T) {
 }
 
 func TestPublicKey(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 
 	actualPublicKey, err := client.PublicKey(context.Background())
 	assert.NoError(t, err)
@@ -559,7 +559,7 @@ func TestPublicKey(t *testing.T) {
 }
 
 func TestSignature(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 
 	t.Run("Test normal case", func(t *testing.T) {
 		actualSignature, err := client.Signature(context.Background(), strconv.Itoa(214584))
@@ -583,7 +583,7 @@ func TestSignature(t *testing.T) {
 }
 
 func TestStateUpdateWithBlock(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 
 	t.Run("Test normal case", func(t *testing.T) {
 		actualStateUpdate, err := client.StateUpdateWithBlock(context.Background(), strconv.Itoa(0))
@@ -610,7 +610,7 @@ func TestStateUpdateWithBlock(t *testing.T) {
 }
 
 func TestBlockTrace(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 
 	t.Run("old block", func(t *testing.T) {
 		trace, err := client.BlockTrace(context.Background(), "0x3ae41b0f023e53151b0c8ab8b9caafb7005d5f41c9ab260276d5bdc49726279")
diff --git a/core/block.go b/core/block.go
index 7ad9004598..f12e7da462 100644
--- a/core/block.go
+++ b/core/block.go
@@ -53,7 +53,7 @@ type blockHashMetaInfo struct {
 	FallBackSequencerAddress *felt.Felt // The sequencer address to use for blocks that do not have one
 }
 
-func NetworkBlockHashMetaInfo(network utils.Network) *blockHashMetaInfo {
+func NetworkBlockHashMetaInfo(network *utils.Network) *blockHashMetaInfo {
 	fallBackSequencerAddress, err := new(felt.Felt).SetString(
 		"0x046a89ae102987331d369645031b49c27738ed096f2789c24449966da4c6de6b")
 	if err != nil {
@@ -61,7 +61,7 @@ func NetworkBlockHashMetaInfo(network utils.Network) *blockHashMetaInfo {
 	}
 
 	switch network {
-	case utils.Mainnet:
+	case &utils.Mainnet:
 		fallBackSequencerAddress, err = new(felt.Felt).SetString(
 			"0x021f4b90b0377c82bf330b7b5295820769e72d79d8acd0effa0ebde6e9988bc5")
 		if err != nil {
@@ -71,31 +71,31 @@ func NetworkBlockHashMetaInfo(network utils.Network) *blockHashMetaInfo {
 			First07Block:             833,
 			FallBackSequencerAddress: fallBackSequencerAddress,
 		}
-	case utils.Goerli:
+	case &utils.Goerli:
 		return &blockHashMetaInfo{
 			First07Block:             47028,
 			UnverifiableRange:        []uint64{119802, 148428},
 			FallBackSequencerAddress: fallBackSequencerAddress,
 		}
-	case utils.Goerli2:
+	case &utils.Goerli2:
 		return &blockHashMetaInfo{
 			First07Block:             0,
 			FallBackSequencerAddress: fallBackSequencerAddress,
 		}
-	case utils.Integration:
+	case &utils.Integration:
 		return &blockHashMetaInfo{
 			First07Block:             110511,
 			UnverifiableRange:        []uint64{0, 110511},
 			FallBackSequencerAddress: fallBackSequencerAddress,
 		}
-	case utils.Sepolia, utils.SepoliaIntegration:
+	case &utils.Sepolia, &utils.SepoliaIntegration:
 		return &blockHashMetaInfo{
 			First07Block:             0,
 			FallBackSequencerAddress: fallBackSequencerAddress,
 		}
 	default:
 		// This should never happen
-		panic(fmt.Sprintf("unknown network: %d", network))
+		panic(fmt.Sprintf("unknown network: %p", network))
 	}
 }
 
@@ -106,7 +106,7 @@ type BlockCommitments struct {
 
 // VerifyBlockHash verifies the block hash. Due to bugs in Starknet alpha, not all blocks have
 // verifiable hashes.
-func VerifyBlockHash(b *Block, network utils.Network) (*BlockCommitments, error) {
+func VerifyBlockHash(b *Block, network *utils.Network) (*BlockCommitments, error) {
 	if len(b.Transactions) != len(b.Receipts) {
 		return nil, fmt.Errorf("len of transactions: %v do not match len of receipts: %v",
 			len(b.Transactions), len(b.Receipts))
@@ -124,7 +124,7 @@ func VerifyBlockHash(b *Block, network utils.Network) (*BlockCommitments, error)
 		return nil, err
 	}
 
-	metaInfo := NetworkBlockHashMetaInfo(network)
+	metaInfo := network.MetaInfo()
 	unverifiableRange := metaInfo.UnverifiableRange
 	for _, fallbackSeq := range []*felt.Felt{&felt.Zero, metaInfo.FallBackSequencerAddress} {
 		var overrideSeq *felt.Felt
@@ -151,11 +151,11 @@ func VerifyBlockHash(b *Block, network utils.Network) (*BlockCommitments, error)
 }
 
 // blockHash computes the block hash, with option to override sequence address
-func blockHash(b *Block, network utils.Network, overrideSeqAddr *felt.Felt) (*felt.Felt, *BlockCommitments, error) {
-	metaInfo := NetworkBlockHashMetaInfo(network)
+func blockHash(b *Block, network *utils.Network, overrideSeqAddr *felt.Felt) (*felt.Felt, *BlockCommitments, error) {
+	metaInfo := network.MetaInfo()
 
 	if b.Number < metaInfo.First07Block {
-		return pre07Hash(b, network.ChainID())
+		return pre07Hash(b, network.ChainIDFelt())
 	}
 	return post07Hash(b, overrideSeqAddr)
 }
diff --git a/core/block_test.go b/core/block_test.go
index 1a056911b4..8721bf5a18 100644
--- a/core/block_test.go
+++ b/core/block_test.go
@@ -169,13 +169,13 @@ func TestBlockHash(t *testing.T) {
 		tc := testcase
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			client := feeder.NewTestClient(t, tc.chain)
+			client := feeder.NewTestClient(t, &tc.chain)
 			gw := adaptfeeder.New(client)
 
 			block, err := gw.BlockByNumber(context.Background(), tc.number)
 			require.NoError(t, err)
 
-			commitments, err := core.VerifyBlockHash(block, tc.chain)
+			commitments, err := core.VerifyBlockHash(block, &tc.chain)
 			assert.NoError(t, err)
 			assert.NotNil(t, commitments)
 		})
@@ -184,7 +184,7 @@ func TestBlockHash(t *testing.T) {
 	h1, err := new(felt.Felt).SetRandom()
 	require.NoError(t, err)
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	mainnetGW := adaptfeeder.New(client)
 	t.Run("error if block hash has not being calculated properly", func(t *testing.T) {
 		mainnetBlock1, err := mainnetGW.BlockByNumber(context.Background(), 1)
@@ -193,18 +193,18 @@ func TestBlockHash(t *testing.T) {
 		mainnetBlock1.Hash = h1
 
 		expectedErr := "can not verify hash in block header"
-		commitments, err := core.VerifyBlockHash(mainnetBlock1, utils.Mainnet)
+		commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet)
 		assert.EqualError(t, err, expectedErr)
 		assert.Nil(t, commitments)
 	})
 
 	t.Run("no error if block is unverifiable", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Goerli)
+		client := feeder.NewTestClient(t, &utils.Goerli)
 		goerliGW := adaptfeeder.New(client)
 		block119802, err := goerliGW.BlockByNumber(context.Background(), 119802)
 		require.NoError(t, err)
 
-		commitments, err := core.VerifyBlockHash(block119802, utils.Goerli)
+		commitments, err := core.VerifyBlockHash(block119802, &utils.Goerli)
 		assert.NoError(t, err)
 		assert.NotNil(t, commitments)
 	})
@@ -218,7 +218,7 @@ func TestBlockHash(t *testing.T) {
 		expectedErr := fmt.Sprintf("len of transactions: %v do not match len of receipts: %v",
 			len(mainnetBlock1.Transactions), len(mainnetBlock1.Receipts))
 
-		commitments, err := core.VerifyBlockHash(mainnetBlock1, utils.Mainnet)
+		commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet)
 		assert.EqualError(t, err, expectedErr)
 		assert.Nil(t, commitments)
 	})
@@ -233,7 +233,7 @@ func TestBlockHash(t *testing.T) {
 				"transaction hash (%v) at index: %v does not match receipt's hash (%v)",
 				mainnetBlock1.Transactions[1].Hash().String(), 1,
 				mainnetBlock1.Receipts[1].TransactionHash)
-			commitments, err := core.VerifyBlockHash(mainnetBlock1, utils.Mainnet)
+			commitments, err := core.VerifyBlockHash(mainnetBlock1, &utils.Mainnet)
 			assert.EqualError(t, err, expectedErr)
 			assert.Nil(t, commitments)
 		})
diff --git a/core/class_test.go b/core/class_test.go
index 31c0bc7f44..c34c794e29 100644
--- a/core/class_test.go
+++ b/core/class_test.go
@@ -18,7 +18,7 @@ import (
 )
 
 func TestClassV0Hash(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Goerli)
+	client := feeder.NewTestClient(t, &utils.Goerli)
 
 	gw := adaptfeeder.New(client)
 	tests := []struct {
@@ -52,7 +52,7 @@ func TestClassV0Hash(t *testing.T) {
 }
 
 func TestClassV1Hash(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	gw := adaptfeeder.New(client)
 	tests := []struct {
 		classHash string
@@ -153,7 +153,7 @@ func TestVerifyClassHash(t *testing.T) {
 		wantErr   error
 	}
 
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	gw := adaptfeeder.New(client)
 
 	cairo1ClassHash := utils.HexToFelt(t, "0x1cd2edfb485241c4403254d550de0a097fa76743cd30696f714a491a454bad5")
diff --git a/core/state_test.go b/core/state_test.go
index 5941315d32..69b18b6869 100644
--- a/core/state_test.go
+++ b/core/state_test.go
@@ -26,7 +26,7 @@ var (
 )
 
 func TestUpdate(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	testDB := pebble.NewMemTest(t)
@@ -153,7 +153,7 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestContractClassHash(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	testDB := pebble.NewMemTest(t)
@@ -269,7 +269,7 @@ func TestStateHistory(t *testing.T) {
 		require.NoError(t, txn.Discard())
 	})
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	state := core.NewState(txn)
@@ -311,7 +311,7 @@ func TestStateHistory(t *testing.T) {
 }
 
 func TestContractIsDeployedAt(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	testDB := pebble.NewMemTest(t)
@@ -370,7 +370,7 @@ func TestClass(t *testing.T) {
 		require.NoError(t, txn.Discard())
 	})
 
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	gw := adaptfeeder.New(client)
 
 	cairo0Hash := utils.HexToFelt(t, "0x4631b6b3fa31e140524b7d21ba784cea223e618bffe60b5bbdca44a8b45be04")
@@ -415,7 +415,7 @@ func TestRevert(t *testing.T) {
 		require.NoError(t, txn.Discard())
 	})
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	state := core.NewState(txn)
@@ -583,7 +583,7 @@ func TestRevertGenesisStateDiff(t *testing.T) {
 }
 
 func TestRevertNoClassContracts(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	testDB := pebble.NewMemTest(t)
diff --git a/core/state_update_test.go b/core/state_update_test.go
index ab037544d4..0d03b4f67e 100644
--- a/core/state_update_test.go
+++ b/core/state_update_test.go
@@ -12,7 +12,7 @@ import (
 )
 
 func TestStateDiffCommitment(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	gw := adaptfeeder.New(client)
 
 	for _, test := range []struct {
diff --git a/core/transaction.go b/core/transaction.go
index cdbd663254..d6ba7c6ed3 100644
--- a/core/transaction.go
+++ b/core/transaction.go
@@ -398,7 +398,7 @@ func (l *L1HandlerTransaction) MessageHash() []byte {
 	return digest.Sum(nil)
 }
 
-func TransactionHash(transaction Transaction, n utils.Network) (*felt.Felt, error) {
+func TransactionHash(transaction Transaction, n *utils.Network) (*felt.Felt, error) {
 	switch t := transaction.(type) {
 	case *DeclareTransaction:
 		return declareTransactionHash(t, n)
@@ -428,7 +428,7 @@ func errInvalidTransactionVersion(t Transaction, version *TransactionVersion) er
 	return fmt.Errorf("invalid Transaction (type: %T) version: %s", t, version)
 }
 
-func invokeTransactionHash(i *InvokeTransaction, n utils.Network) (*felt.Felt, error) {
+func invokeTransactionHash(i *InvokeTransaction, n *utils.Network) (*felt.Felt, error) {
 	switch {
 	case i.Version.Is(0):
 		return crypto.PedersenArray(
@@ -438,7 +438,7 @@ func invokeTransactionHash(i *InvokeTransaction, n utils.Network) (*felt.Felt, e
 			i.EntryPointSelector,
 			crypto.PedersenArray(i.CallData...),
 			i.MaxFee,
-			n.ChainID(),
+			n.ChainIDFelt(),
 		), nil
 	case i.Version.Is(1):
 		return crypto.PedersenArray(
@@ -448,7 +448,7 @@ func invokeTransactionHash(i *InvokeTransaction, n utils.Network) (*felt.Felt, e
 			new(felt.Felt),
 			crypto.PedersenArray(i.CallData...),
 			i.MaxFee,
-			n.ChainID(),
+			n.ChainIDFelt(),
 			i.Nonce,
 		), nil
 	case i.Version.Is(3):
@@ -458,7 +458,7 @@ func invokeTransactionHash(i *InvokeTransaction, n utils.Network) (*felt.Felt, e
 			i.SenderAddress,
 			tipAndResourcesHash(i.Tip, i.ResourceBounds),
 			crypto.PoseidonArray(i.PaymasterData...),
-			n.ChainID(),
+			n.ChainIDFelt(),
 			i.Nonce,
 			new(felt.Felt).SetUint64(dataAvailabilityMode(i.FeeDAMode, i.NonceDAMode)),
 			crypto.PoseidonArray(i.AccountDeploymentData...),
@@ -480,7 +480,7 @@ func dataAvailabilityMode(feeDAMode, nonceDAMode DataAvailabilityMode) uint64 {
 	return uint64(feeDAMode) + uint64(nonceDAMode)<<dataAvailabilityModeBits
 }
 
-func declareTransactionHash(d *DeclareTransaction, n utils.Network) (*felt.Felt, error) {
+func declareTransactionHash(d *DeclareTransaction, n *utils.Network) (*felt.Felt, error) {
 	switch {
 	case d.Version.Is(0):
 		// Due to inconsistencies in version 0 hash calculation we don't verify the hash
@@ -493,7 +493,7 @@ func declareTransactionHash(d *DeclareTransaction, n utils.Network) (*felt.Felt,
 			new(felt.Felt),
 			crypto.PedersenArray(d.ClassHash),
 			d.MaxFee,
-			n.ChainID(),
+			n.ChainIDFelt(),
 			d.Nonce,
 		), nil
 	case d.Version.Is(2):
@@ -504,7 +504,7 @@ func declareTransactionHash(d *DeclareTransaction, n utils.Network) (*felt.Felt,
 			&felt.Zero,
 			crypto.PedersenArray(d.ClassHash),
 			d.MaxFee,
-			n.ChainID(),
+			n.ChainIDFelt(),
 			d.Nonce,
 			d.CompiledClassHash,
 		), nil
@@ -515,7 +515,7 @@ func declareTransactionHash(d *DeclareTransaction, n utils.Network) (*felt.Felt,
 			d.SenderAddress,
 			tipAndResourcesHash(d.Tip, d.ResourceBounds),
 			crypto.PoseidonArray(d.PaymasterData...),
-			n.ChainID(),
+			n.ChainIDFelt(),
 			d.Nonce,
 			new(felt.Felt).SetUint64(dataAvailabilityMode(d.FeeDAMode, d.NonceDAMode)),
 			crypto.PoseidonArray(d.AccountDeploymentData...),
@@ -527,7 +527,7 @@ func declareTransactionHash(d *DeclareTransaction, n utils.Network) (*felt.Felt,
 	}
 }
 
-func l1HandlerTransactionHash(l *L1HandlerTransaction, n utils.Network) (*felt.Felt, error) {
+func l1HandlerTransactionHash(l *L1HandlerTransaction, n *utils.Network) (*felt.Felt, error) {
 	switch {
 	case l.Version.Is(0):
 		// There are some l1 handler transaction which do not return a nonce and for some random
@@ -542,7 +542,7 @@ func l1HandlerTransactionHash(l *L1HandlerTransaction, n utils.Network) (*felt.F
 			l.EntryPointSelector,
 			crypto.PedersenArray(l.CallData...),
 			&felt.Zero,
-			n.ChainID(),
+			n.ChainIDFelt(),
 			l.Nonce,
 		), nil
 	default:
@@ -550,7 +550,7 @@ func l1HandlerTransactionHash(l *L1HandlerTransaction, n utils.Network) (*felt.F
 	}
 }
 
-func deployAccountTransactionHash(d *DeployAccountTransaction, n utils.Network) (*felt.Felt, error) {
+func deployAccountTransactionHash(d *DeployAccountTransaction, n *utils.Network) (*felt.Felt, error) {
 	callData := []*felt.Felt{d.ClassHash, d.ContractAddressSalt}
 	callData = append(callData, d.ConstructorCallData...)
 	// There is no version 0 for deploy account
@@ -563,7 +563,7 @@ func deployAccountTransactionHash(d *DeployAccountTransaction, n utils.Network)
 			&felt.Zero,
 			crypto.PedersenArray(callData...),
 			d.MaxFee,
-			n.ChainID(),
+			n.ChainIDFelt(),
 			d.Nonce,
 		), nil
 	case d.Version.Is(3):
@@ -573,7 +573,7 @@ func deployAccountTransactionHash(d *DeployAccountTransaction, n utils.Network)
 			d.ContractAddress,
 			tipAndResourcesHash(d.Tip, d.ResourceBounds),
 			crypto.PoseidonArray(d.PaymasterData...),
-			n.ChainID(),
+			n.ChainIDFelt(),
 			d.Nonce,
 			new(felt.Felt).SetUint64(dataAvailabilityMode(d.FeeDAMode, d.NonceDAMode)),
 			crypto.PoseidonArray(d.ConstructorCallData...),
@@ -585,7 +585,7 @@ func deployAccountTransactionHash(d *DeployAccountTransaction, n utils.Network)
 	}
 }
 
-func VerifyTransactions(txs []Transaction, n utils.Network, protocolVersion string) error {
+func VerifyTransactions(txs []Transaction, n *utils.Network, protocolVersion string) error {
 	blockVersion, err := ParseBlockVersion(protocolVersion)
 	if err != nil {
 		return err
diff --git a/core/transaction_test.go b/core/transaction_test.go
index 572ec862a4..82282a50f9 100644
--- a/core/transaction_test.go
+++ b/core/transaction_test.go
@@ -143,7 +143,7 @@ func checkTransactionSymmetry(t *testing.T, input core.Transaction) {
 }
 
 func TestVerifyTransactionHash(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	txnHash0 := utils.HexToFelt(t, "0x1b4d9f09276629d496af1af8ff00173c11ff146affacb1b5c858d7aa89001ae")
@@ -199,7 +199,7 @@ func TestVerifyTransactionHash(t *testing.T) {
 
 		for _, test := range tests {
 			t.Run(test.name, func(t *testing.T) {
-				tErr := core.VerifyTransactions([]core.Transaction{test.txn}, utils.Mainnet, "99.99.99")
+				tErr := core.VerifyTransactions([]core.Transaction{test.txn}, &utils.Mainnet, "99.99.99")
 				require.Equal(t, test.wantErr, tErr)
 			})
 		}
@@ -207,13 +207,13 @@ func TestVerifyTransactionHash(t *testing.T) {
 
 	t.Run("does not contain bad transaction(s)", func(t *testing.T) {
 		txns := []core.Transaction{txn0, txn1, txn2, txn3, txn4}
-		assert.NoError(t, core.VerifyTransactions(txns, utils.Mainnet, "99.99.99"))
+		assert.NoError(t, core.VerifyTransactions(txns, &utils.Mainnet, "99.99.99"))
 	})
 }
 
 func TestTransactionV3Hash(t *testing.T) {
 	network := utils.Integration
-	gw := adaptfeeder.New(feeder.NewTestClient(t, network))
+	gw := adaptfeeder.New(feeder.NewTestClient(t, &network))
 	ctx := context.Background()
 
 	// Test data was obtained by playing with Papyrus's implementation before v0.13 was released on integration.
@@ -261,7 +261,7 @@ func TestTransactionV3Hash(t *testing.T) {
 
 	for description, test := range tests {
 		t.Run(description, func(t *testing.T) {
-			got, err := core.TransactionHash(test.tx(test.want), network)
+			got, err := core.TransactionHash(test.tx(test.want), &network)
 			require.NoError(t, err)
 			require.Equal(t, test.want, got)
 		})
diff --git a/l1/l1.go b/l1/l1.go
index 089d29ee6c..8078be3713 100644
--- a/l1/l1.go
+++ b/l1/l1.go
@@ -88,14 +88,14 @@ func (c *Client) checkChainID(ctx context.Context) error {
 		return fmt.Errorf("retrieve Ethereum chain ID: %w", err)
 	}
 
-	wantChainID := c.network.DefaultL1ChainID()
+	wantChainID := c.network.L1ChainID
 	if gotChainID.Cmp(wantChainID) == 0 {
 		return nil
 	}
 
 	// NOTE: for now we return an error. If we want to support users who fork
 	// Starknet to create a "custom" Starknet network, we will need to log a warning instead.
-	return fmt.Errorf("mismatched L1 and L2 networks: L2 network %s; is the L1 node on the correct network?", c.network)
+	return fmt.Errorf("mismatched L1 and L2 networks: L2 network %s; is the L1 node on the correct network?", c.network.Name)
 }
 
 func (c *Client) Run(ctx context.Context) error {
diff --git a/l1/l1_pkg_test.go b/l1/l1_pkg_test.go
index adeac6edd9..a8e9131a2a 100644
--- a/l1/l1_pkg_test.go
+++ b/l1/l1_pkg_test.go
@@ -337,7 +337,7 @@ func TestClient(t *testing.T) {
 			ctrl := gomock.NewController(t)
 			nopLog := utils.NewNopZapLogger()
 			network := utils.Mainnet
-			chain := blockchain.New(pebble.NewMemTest(t), network, nopLog)
+			chain := blockchain.New(pebble.NewMemTest(t), &network, nopLog)
 
 			client := NewClient(nil, chain, nopLog).WithResubscribeDelay(0).WithPollFinalisedInterval(time.Nanosecond)
 
@@ -364,7 +364,7 @@ func TestClient(t *testing.T) {
 				subscriber.
 					EXPECT().
 					ChainID(gomock.Any()).
-					Return(network.DefaultL1ChainID(), nil).
+					Return(network.L1ChainID, nil).
 					Times(1)
 
 				subscriber.EXPECT().Close().Times(1)
@@ -398,7 +398,7 @@ func TestUnreliableSubscription(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	nopLog := utils.NewNopZapLogger()
 	network := utils.Mainnet
-	chain := blockchain.New(pebble.NewMemTest(t), network, nopLog)
+	chain := blockchain.New(pebble.NewMemTest(t), &network, nopLog)
 	client := NewClient(nil, chain, nopLog).WithResubscribeDelay(0).WithPollFinalisedInterval(time.Nanosecond)
 
 	err := errors.New("test err")
@@ -431,7 +431,7 @@ func TestUnreliableSubscription(t *testing.T) {
 		subscriber.
 			EXPECT().
 			ChainID(gomock.Any()).
-			Return(network.DefaultL1ChainID(), nil).
+			Return(network.L1ChainID, nil).
 			Times(1)
 
 		subscriber.
diff --git a/l1/l1_test.go b/l1/l1_test.go
index 6d7c21464a..31392dda45 100644
--- a/l1/l1_test.go
+++ b/l1/l1_test.go
@@ -49,7 +49,7 @@ func TestFailToCreateSubscription(t *testing.T) {
 	network := utils.Mainnet
 	ctrl := gomock.NewController(t)
 	nopLog := utils.NewNopZapLogger()
-	chain := blockchain.New(pebble.NewMemTest(t), network, nopLog)
+	chain := blockchain.New(pebble.NewMemTest(t), &network, nopLog)
 
 	subscriber := mocks.NewMockSubscriber(ctrl)
 
@@ -62,7 +62,7 @@ func TestFailToCreateSubscription(t *testing.T) {
 	subscriber.
 		EXPECT().
 		ChainID(gomock.Any()).
-		Return(network.DefaultL1ChainID(), nil).
+		Return(network.L1ChainID, nil).
 		Times(1)
 
 	subscriber.EXPECT().Close().Times(1)
@@ -80,7 +80,7 @@ func TestMismatchedChainID(t *testing.T) {
 	network := utils.Mainnet
 	ctrl := gomock.NewController(t)
 	nopLog := utils.NewNopZapLogger()
-	chain := blockchain.New(pebble.NewMemTest(t), network, nopLog)
+	chain := blockchain.New(pebble.NewMemTest(t), &network, nopLog)
 
 	subscriber := mocks.NewMockSubscriber(ctrl)
 
@@ -105,7 +105,7 @@ func TestEventListener(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	nopLog := utils.NewNopZapLogger()
 	network := utils.Mainnet
-	chain := blockchain.New(pebble.NewMemTest(t), network, nopLog)
+	chain := blockchain.New(pebble.NewMemTest(t), &network, nopLog)
 
 	subscriber := mocks.NewMockSubscriber(ctrl)
 	subscriber.
@@ -130,7 +130,7 @@ func TestEventListener(t *testing.T) {
 	subscriber.
 		EXPECT().
 		ChainID(gomock.Any()).
-		Return(network.DefaultL1ChainID(), nil).
+		Return(network.L1ChainID, nil).
 		Times(1)
 
 	subscriber.EXPECT().Close().Times(1)
diff --git a/migration/bucket_migrator.go b/migration/bucket_migrator.go
index bff63799de..8b404545df 100644
--- a/migration/bucket_migrator.go
+++ b/migration/bucket_migrator.go
@@ -11,7 +11,7 @@ import (
 var _ Migration = (*BucketMigrator)(nil)
 
 type (
-	BucketMigratorDoFunc    func(t db.Transaction, b1, b2 []byte, n utils.Network) error
+	BucketMigratorDoFunc    func(t db.Transaction, b1, b2 []byte, n *utils.Network) error
 	BucketMigratorKeyFilter func([]byte) (bool, error)
 )
 
@@ -41,7 +41,7 @@ func NewBucketMigrator(target db.Bucket, do BucketMigratorDoFunc) *BucketMigrato
 }
 
 func NewBucketMover(source, destination db.Bucket) *BucketMigrator {
-	return NewBucketMigrator(source, func(txn db.Transaction, key, value []byte, n utils.Network) error {
+	return NewBucketMigrator(source, func(txn db.Transaction, key, value []byte, n *utils.Network) error {
 		err := txn.Delete(key)
 		if err != nil {
 			return err
@@ -72,7 +72,7 @@ func (m *BucketMigrator) Before(_ []byte) error {
 	return nil
 }
 
-func (m *BucketMigrator) Migrate(_ context.Context, txn db.Transaction, network utils.Network) ([]byte, error) {
+func (m *BucketMigrator) Migrate(_ context.Context, txn db.Transaction, network *utils.Network) ([]byte, error) {
 	remainingInBatch := m.batchSize
 	iterator, err := txn.NewIterator()
 	if err != nil {
diff --git a/migration/bucket_migrator_test.go b/migration/bucket_migrator_test.go
index 718ce28946..79c540f572 100644
--- a/migration/bucket_migrator_test.go
+++ b/migration/bucket_migrator_test.go
@@ -40,13 +40,13 @@ func TestBucketMover(t *testing.T) {
 		err               error
 	)
 	err = testDB.Update(func(txn db.Transaction) error {
-		intermediateState, err = mover.Migrate(context.Background(), txn, utils.Mainnet)
+		intermediateState, err = mover.Migrate(context.Background(), txn, &utils.Mainnet)
 		require.ErrorIs(t, err, migration.ErrCallWithNewTransaction)
 		return nil
 	})
 	require.NoError(t, err)
 	err = testDB.Update(func(txn db.Transaction) error {
-		intermediateState, err = mover.Migrate(context.Background(), txn, utils.Mainnet)
+		intermediateState, err = mover.Migrate(context.Background(), txn, &utils.Mainnet)
 		require.NoError(t, err)
 		return nil
 	})
diff --git a/migration/migration.go b/migration/migration.go
index 8f4a9e8f44..00c9a7b62e 100644
--- a/migration/migration.go
+++ b/migration/migration.go
@@ -29,13 +29,13 @@ type schemaMetadata struct {
 type Migration interface {
 	Before(intermediateState []byte) error
 	// Migration should return intermediate state whenever it requests new txn or detects cancelled ctx.
-	Migrate(context.Context, db.Transaction, utils.Network) ([]byte, error)
+	Migrate(context.Context, db.Transaction, *utils.Network) ([]byte, error)
 }
 
-type MigrationFunc func(db.Transaction, utils.Network) error
+type MigrationFunc func(db.Transaction, *utils.Network) error
 
 // Migrate returns f(txn).
-func (f MigrationFunc) Migrate(_ context.Context, txn db.Transaction, network utils.Network) ([]byte, error) {
+func (f MigrationFunc) Migrate(_ context.Context, txn db.Transaction, network *utils.Network) ([]byte, error) {
 	return nil, f(txn, network)
 }
 
@@ -65,11 +65,11 @@ var defaultMigrations = []Migration{
 
 var ErrCallWithNewTransaction = errors.New("call with new transaction")
 
-func MigrateIfNeeded(ctx context.Context, targetDB db.DB, network utils.Network, log utils.SimpleLogger) error {
+func MigrateIfNeeded(ctx context.Context, targetDB db.DB, network *utils.Network, log utils.SimpleLogger) error {
 	return migrateIfNeeded(ctx, targetDB, network, log, defaultMigrations)
 }
 
-func migrateIfNeeded(ctx context.Context, targetDB db.DB, network utils.Network, log utils.SimpleLogger, migrations []Migration) error {
+func migrateIfNeeded(ctx context.Context, targetDB db.DB, network *utils.Network, log utils.SimpleLogger, migrations []Migration) error {
 	/*
 		Schema metadata of the targetDB determines which set of migrations need to be applied to the database.
 		After a migration is successfully executed, which may update the database, the schema version is incremented
@@ -170,7 +170,7 @@ func updateSchemaMetadata(txn db.Transaction, schema schemaMetadata) error {
 }
 
 // migration0000 makes sure the targetDB is empty
-func migration0000(txn db.Transaction, _ utils.Network) error {
+func migration0000(txn db.Transaction, _ *utils.Network) error {
 	it, err := txn.NewIterator()
 	if err != nil {
 		return err
@@ -189,7 +189,7 @@ func migration0000(txn db.Transaction, _ utils.Network) error {
 // After: the key to the root of the contract storage trie is stored at 3+<contractAddress>.
 //
 // This enables us to remove the db.ContractRootKey prefix.
-func relocateContractStorageRootKeys(txn db.Transaction, _ utils.Network) error {
+func relocateContractStorageRootKeys(txn db.Transaction, _ *utils.Network) error {
 	it, err := txn.NewIterator()
 	if err != nil {
 		return err
@@ -242,7 +242,7 @@ func relocateContractStorageRootKeys(txn db.Transaction, _ utils.Network) error
 }
 
 // recalculateBloomFilters updates bloom filters in block headers to match what the most recent implementation expects
-func recalculateBloomFilters(txn db.Transaction, _ utils.Network) error {
+func recalculateBloomFilters(txn db.Transaction, _ *utils.Network) error {
 	blockchain.RegisterCoreTypesToEncoder()
 	for blockNumber := uint64(0); ; blockNumber++ {
 		block, err := blockchain.BlockByNumber(txn, blockNumber)
@@ -357,7 +357,7 @@ func (n *node) _UnmarshalBinary(data []byte) error {
 	return err
 }
 
-func (m *changeTrieNodeEncoding) Migrate(_ context.Context, txn db.Transaction, _ utils.Network) ([]byte, error) {
+func (m *changeTrieNodeEncoding) Migrate(_ context.Context, txn db.Transaction, _ *utils.Network) ([]byte, error) {
 	// If we made n a trie.Node, the encoder would fall back to the custom encoding methods.
 	// We instead define a cutom struct to force the encoder to use the default encoding.
 	var n node
@@ -426,7 +426,7 @@ func (m *changeTrieNodeEncoding) Migrate(_ context.Context, txn db.Transaction,
 }
 
 // calculateBlockCommitments calculates the txn and event commitments for each block and stores them separately
-func calculateBlockCommitments(txn db.Transaction, network utils.Network) error {
+func calculateBlockCommitments(txn db.Transaction, network *utils.Network) error {
 	var txnLock sync.RWMutex
 	workerPool := pool.New().WithErrors().WithMaxGoroutines(runtime.GOMAXPROCS(0))
 
@@ -471,7 +471,7 @@ func bitset2Key(bs *bitset.BitSet) *trie.Key {
 	return &k
 }
 
-func migrateTrieRootKeysFromBitsetToTrieKeys(txn db.Transaction, key, value []byte, _ utils.Network) error {
+func migrateTrieRootKeysFromBitsetToTrieKeys(txn db.Transaction, key, value []byte, _ *utils.Network) error {
 	var bs bitset.BitSet
 	var tempBuf bytes.Buffer
 	if err := bs.UnmarshalBinary(value); err != nil {
@@ -505,7 +505,7 @@ func nodesFilter(target db.Bucket) BucketMigratorKeyFilter {
 }
 
 func migrateTrieNodesFromBitsetToTrieKey(target db.Bucket) BucketMigratorDoFunc {
-	return func(txn db.Transaction, key, value []byte, _ utils.Network) error {
+	return func(txn db.Transaction, key, value []byte, _ *utils.Network) error {
 		var n node
 		var tempBuf bytes.Buffer
 		if err := n._UnmarshalBinary(value); err != nil {
@@ -572,7 +572,7 @@ type oldStateUpdate struct {
 	StateDiff *oldStateDiff
 }
 
-func changeStateDiffStruct(txn db.Transaction, key, value []byte, _ utils.Network) error {
+func changeStateDiffStruct(txn db.Transaction, key, value []byte, _ *utils.Network) error {
 	old := new(oldStateUpdate)
 	if err := encoder.Unmarshal(value, old); err != nil {
 		return fmt.Errorf("unmarshal: %v", err)
diff --git a/migration/migration_pkg_test.go b/migration/migration_pkg_test.go
index 6fa24bb68a..bc59f91285 100644
--- a/migration/migration_pkg_test.go
+++ b/migration/migration_pkg_test.go
@@ -27,7 +27,7 @@ func TestMigration0000(t *testing.T) {
 
 	t.Run("empty DB", func(t *testing.T) {
 		require.NoError(t, testDB.View(func(txn db.Transaction) error {
-			return migration0000(txn, utils.Mainnet)
+			return migration0000(txn, &utils.Mainnet)
 		}))
 	})
 
@@ -36,7 +36,7 @@ func TestMigration0000(t *testing.T) {
 			return txn.Set([]byte("asd"), []byte("123"))
 		}))
 		require.EqualError(t, testDB.View(func(txn db.Transaction) error {
-			return migration0000(txn, utils.Mainnet)
+			return migration0000(txn, &utils.Mainnet)
 		}), "initial DB should be empty")
 	})
 }
@@ -56,7 +56,7 @@ func TestRelocateContractStorageRootKeys(t *testing.T) {
 		require.NoError(t, err)
 	}
 
-	require.NoError(t, relocateContractStorageRootKeys(txn, utils.Mainnet))
+	require.NoError(t, relocateContractStorageRootKeys(txn, &utils.Mainnet))
 
 	// Each root-key entry should have been moved to its new location
 	// and the old entry should not exist.
@@ -78,8 +78,8 @@ func TestRelocateContractStorageRootKeys(t *testing.T) {
 
 func TestRecalculateBloomFilters(t *testing.T) {
 	testdb := pebble.NewMemTest(t)
-	chain := blockchain.New(testdb, utils.Mainnet, utils.NewNopZapLogger())
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	chain := blockchain.New(testdb, &utils.Mainnet, utils.NewNopZapLogger())
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	for i := uint64(0); i < 3; i++ {
@@ -93,7 +93,7 @@ func TestRecalculateBloomFilters(t *testing.T) {
 	}
 
 	require.NoError(t, testdb.Update(func(txn db.Transaction) error {
-		return recalculateBloomFilters(txn, utils.Mainnet)
+		return recalculateBloomFilters(txn, &utils.Mainnet)
 	}))
 
 	for i := uint64(0); i < 3; i++ {
@@ -141,7 +141,7 @@ func TestChangeTrieNodeEncoding(t *testing.T) {
 	m := new(changeTrieNodeEncoding)
 	require.NoError(t, m.Before(nil))
 	require.NoError(t, testdb.Update(func(txn db.Transaction) error {
-		_, err := m.Migrate(context.Background(), txn, utils.Mainnet)
+		_, err := m.Migrate(context.Background(), txn, &utils.Mainnet)
 		return err
 	}))
 
@@ -162,8 +162,8 @@ func TestChangeTrieNodeEncoding(t *testing.T) {
 
 func TestCalculateBlockCommitments(t *testing.T) {
 	testdb := pebble.NewMemTest(t)
-	chain := blockchain.New(testdb, utils.Mainnet, utils.NewNopZapLogger())
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	chain := blockchain.New(testdb, &utils.Mainnet, utils.NewNopZapLogger())
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	for i := uint64(0); i < 3; i++ {
@@ -175,7 +175,7 @@ func TestCalculateBlockCommitments(t *testing.T) {
 	}
 
 	require.NoError(t, testdb.Update(func(txn db.Transaction) error {
-		return calculateBlockCommitments(txn, utils.Mainnet)
+		return calculateBlockCommitments(txn, &utils.Mainnet)
 	}))
 
 	for i := uint64(0); i < 3; i++ {
@@ -196,7 +196,7 @@ func TestMigrateTrieRootKeysFromBitsetToTrieKeys(t *testing.T) {
 	err = memTxn.Set(key, bsBytes)
 	require.NoError(t, err)
 
-	require.NoError(t, migrateTrieRootKeysFromBitsetToTrieKeys(memTxn, key, bsBytes, utils.Mainnet))
+	require.NoError(t, migrateTrieRootKeysFromBitsetToTrieKeys(memTxn, key, bsBytes, &utils.Mainnet))
 
 	var trieKey trie.Key
 	err = memTxn.Get(key, trieKey.UnmarshalBinary)
@@ -228,7 +228,7 @@ func TestMigrateTrieNodesFromBitsetToTrieKey(t *testing.T) {
 	err = memTxn.Set(nodeKey, nodeBytes.Bytes())
 	require.NoError(t, err)
 
-	require.NoError(t, migrator(memTxn, nodeKey, nodeBytes.Bytes(), utils.Mainnet))
+	require.NoError(t, migrator(memTxn, nodeKey, nodeBytes.Bytes(), &utils.Mainnet))
 
 	err = memTxn.Get(db.ClassesTrie.Key(bsBytes), func(b []byte) error {
 		return nil
@@ -331,11 +331,11 @@ func TestSchemaMetadata(t *testing.T) {
 }
 
 type testMigration struct {
-	exec   func(context.Context, db.Transaction, utils.Network) ([]byte, error)
+	exec   func(context.Context, db.Transaction, *utils.Network) ([]byte, error)
 	before func([]byte) error
 }
 
-func (f testMigration) Migrate(ctx context.Context, txn db.Transaction, network utils.Network) ([]byte, error) {
+func (f testMigration) Migrate(ctx context.Context, txn db.Transaction, network *utils.Network) ([]byte, error) {
 	return f.exec(ctx, txn, network)
 }
 
@@ -346,7 +346,7 @@ func TestMigrateIfNeededInternal(t *testing.T) {
 		testDB := pebble.NewMemTest(t)
 		migrations := []Migration{
 			testMigration{
-				exec: func(context.Context, db.Transaction, utils.Network) ([]byte, error) {
+				exec: func(context.Context, db.Transaction, *utils.Network) ([]byte, error) {
 					return nil, errors.New("foo")
 				},
 				before: func([]byte) error {
@@ -354,7 +354,7 @@ func TestMigrateIfNeededInternal(t *testing.T) {
 				},
 			},
 		}
-		require.ErrorContains(t, migrateIfNeeded(context.Background(), testDB, utils.Mainnet, utils.NewNopZapLogger(), migrations), "bar")
+		require.ErrorContains(t, migrateIfNeeded(context.Background(), testDB, &utils.Mainnet, utils.NewNopZapLogger(), migrations), "bar")
 	})
 
 	t.Run("call with new tx", func(t *testing.T) {
@@ -362,7 +362,7 @@ func TestMigrateIfNeededInternal(t *testing.T) {
 		var counter int
 		migrations := []Migration{
 			testMigration{
-				exec: func(context.Context, db.Transaction, utils.Network) ([]byte, error) {
+				exec: func(context.Context, db.Transaction, *utils.Network) ([]byte, error) {
 					if counter == 0 {
 						counter++
 						return nil, ErrCallWithNewTransaction
@@ -374,14 +374,14 @@ func TestMigrateIfNeededInternal(t *testing.T) {
 				},
 			},
 		}
-		require.NoError(t, migrateIfNeeded(context.Background(), testDB, utils.Mainnet, utils.NewNopZapLogger(), migrations))
+		require.NoError(t, migrateIfNeeded(context.Background(), testDB, &utils.Mainnet, utils.NewNopZapLogger(), migrations))
 	})
 
 	t.Run("error during migration", func(t *testing.T) {
 		testDB := pebble.NewMemTest(t)
 		migrations := []Migration{
 			testMigration{
-				exec: func(context.Context, db.Transaction, utils.Network) ([]byte, error) {
+				exec: func(context.Context, db.Transaction, *utils.Network) ([]byte, error) {
 					return nil, errors.New("foo")
 				},
 				before: func([]byte) error {
@@ -389,7 +389,7 @@ func TestMigrateIfNeededInternal(t *testing.T) {
 				},
 			},
 		}
-		require.ErrorContains(t, migrateIfNeeded(context.Background(), testDB, utils.Mainnet, utils.NewNopZapLogger(), migrations), "foo")
+		require.ErrorContains(t, migrateIfNeeded(context.Background(), testDB, &utils.Mainnet, utils.NewNopZapLogger(), migrations), "foo")
 	})
 }
 
@@ -398,7 +398,7 @@ func TestChangeStateDiffStructEmptyDB(t *testing.T) {
 	require.NoError(t, testdb.Update(func(txn db.Transaction) error {
 		migrator := NewBucketMigrator(db.StateUpdatesByBlockNumber, changeStateDiffStruct)
 		require.NoError(t, migrator.Before(nil))
-		intermediateState, err := migrator.Migrate(context.Background(), txn, utils.Mainnet)
+		intermediateState, err := migrator.Migrate(context.Background(), txn, &utils.Mainnet)
 		require.NoError(t, err)
 		require.Nil(t, intermediateState)
 
@@ -475,7 +475,7 @@ func TestChangeStateDiffStruct(t *testing.T) {
 	require.NoError(t, testdb.Update(func(txn db.Transaction) error {
 		migrator := NewBucketMigrator(db.StateUpdatesByBlockNumber, changeStateDiffStruct)
 		require.NoError(t, migrator.Before(nil))
-		intermediateState, err := migrator.Migrate(context.Background(), txn, utils.Mainnet)
+		intermediateState, err := migrator.Migrate(context.Background(), txn, &utils.Mainnet)
 		require.NoError(t, err)
 		require.Nil(t, intermediateState)
 		return nil
diff --git a/migration/migration_test.go b/migration/migration_test.go
index 48dd3257fc..f037974fb1 100644
--- a/migration/migration_test.go
+++ b/migration/migration_test.go
@@ -16,7 +16,7 @@ func TestMigrateIfNeeded(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
 	t.Run("Migration should not happen on cancelled ctx", func(t *testing.T) {
-		require.ErrorIs(t, migration.MigrateIfNeeded(ctx, testDB, utils.Mainnet, utils.NewNopZapLogger()), ctx.Err())
+		require.ErrorIs(t, migration.MigrateIfNeeded(ctx, testDB, &utils.Mainnet, utils.NewNopZapLogger()), ctx.Err())
 	})
 
 	meta, err := migration.SchemaMetadata(testDB)
@@ -25,7 +25,7 @@ func TestMigrateIfNeeded(t *testing.T) {
 	require.Nil(t, meta.IntermediateState)
 
 	t.Run("Migration should happen on empty DB", func(t *testing.T) {
-		require.NoError(t, migration.MigrateIfNeeded(context.Background(), testDB, utils.Mainnet, utils.NewNopZapLogger()))
+		require.NoError(t, migration.MigrateIfNeeded(context.Background(), testDB, &utils.Mainnet, utils.NewNopZapLogger()))
 	})
 
 	meta, err = migration.SchemaMetadata(testDB)
@@ -34,7 +34,7 @@ func TestMigrateIfNeeded(t *testing.T) {
 	require.Nil(t, meta.IntermediateState)
 
 	t.Run("subsequent calls to MigrateIfNeeded should not change the DB version", func(t *testing.T) {
-		require.NoError(t, migration.MigrateIfNeeded(context.Background(), testDB, utils.Mainnet, utils.NewNopZapLogger()))
+		require.NoError(t, migration.MigrateIfNeeded(context.Background(), testDB, &utils.Mainnet, utils.NewNopZapLogger()))
 		postVersion, postErr := migration.SchemaMetadata(testDB)
 		require.NoError(t, postErr)
 		require.Equal(t, meta, postVersion)
diff --git a/mocks/mock_vm.go b/mocks/mock_vm.go
index e8e5d88d14..8b0f1b4fa2 100644
--- a/mocks/mock_vm.go
+++ b/mocks/mock_vm.go
@@ -42,7 +42,7 @@ func (m *MockVM) EXPECT() *MockVMMockRecorder {
 }
 
 // Call mocks base method.
-func (m *MockVM) Call(arg0, arg1, arg2 *felt.Felt, arg3 []felt.Felt, arg4, arg5 uint64, arg6 core.StateReader, arg7 utils.Network) ([]*felt.Felt, error) {
+func (m *MockVM) Call(arg0, arg1, arg2 *felt.Felt, arg3 []felt.Felt, arg4, arg5 uint64, arg6 core.StateReader, arg7 *utils.Network) ([]*felt.Felt, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Call", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 	ret0, _ := ret[0].([]*felt.Felt)
@@ -57,7 +57,7 @@ func (mr *MockVMMockRecorder) Call(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg
 }
 
 // Execute mocks base method.
-func (m *MockVM) Execute(arg0 []core.Transaction, arg1 []core.Class, arg2, arg3 uint64, arg4 *felt.Felt, arg5 core.StateReader, arg6 utils.Network, arg7 []*felt.Felt, arg8, arg9, arg10 bool, arg11, arg12 *felt.Felt, arg13 bool) ([]*felt.Felt, []json.RawMessage, error) {
+func (m *MockVM) Execute(arg0 []core.Transaction, arg1 []core.Class, arg2, arg3 uint64, arg4 *felt.Felt, arg5 core.StateReader, arg6 *utils.Network, arg7 []*felt.Felt, arg8, arg9, arg10 bool, arg11, arg12 *felt.Felt, arg13 bool) ([]*felt.Felt, []json.RawMessage, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Execute", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
 	ret0, _ := ret[0].([]*felt.Felt)
diff --git a/node/node.go b/node/node.go
index 1a22e8acbc..564f72333a 100644
--- a/node/node.go
+++ b/node/node.go
@@ -118,7 +118,7 @@ func New(cfg *Config, version string) (*Node, error) { //nolint:gocyclo,funlen
 
 	services := make([]service.Service, 0)
 
-	chain := blockchain.New(database, cfg.Network, log)
+	chain := blockchain.New(database, &cfg.Network, log)
 
 	// Verify that cfg.Network is compatible with the database.
 	head, err := chain.Head()
@@ -127,19 +127,19 @@ func New(cfg *Config, version string) (*Node, error) { //nolint:gocyclo,funlen
 	}
 	if head != nil {
 		// We assume that there is at least one transaction in the block or that it is a pre-0.7 block.
-		if _, err = core.VerifyBlockHash(head, cfg.Network); err != nil {
+		if _, err = core.VerifyBlockHash(head, &cfg.Network); err != nil {
 			return nil, errors.New("unable to verify latest block hash; are the database and --network option compatible?")
 		}
 	}
 
 	feederClientTimeout := 5 * time.Second
-	client := feeder.NewClient(cfg.Network.FeederURL()).WithUserAgent(ua).WithLogger(log).WithTimeout(feederClientTimeout)
+	client := feeder.NewClient(cfg.Network.FeederURL).WithUserAgent(ua).WithLogger(log).WithTimeout(feederClientTimeout)
 	synchronizer := sync.New(chain, adaptfeeder.New(client), log, cfg.PendingPollInterval, dbIsRemote)
 	services = append(services, synchronizer)
-	gatewayClient := gateway.NewClient(cfg.Network.GatewayURL(), log).WithUserAgent(ua)
+	gatewayClient := gateway.NewClient(cfg.Network.GatewayURL, log).WithUserAgent(ua)
 
 	throttledVM := NewThrottledVM(vm.New(log), cfg.MaxVMs, int32(cfg.MaxVMQueue))
-	rpcHandler := rpc.New(chain, synchronizer, cfg.Network, gatewayClient, client, throttledVM, version, log)
+	rpcHandler := rpc.New(chain, synchronizer, &cfg.Network, gatewayClient, client, throttledVM, version, log)
 	rpcHandler = rpcHandler.WithFilterLimit(cfg.RPCMaxBlockScan)
 	services = append(services, rpcHandler)
 	// to improve RPC throughput we double GOMAXPROCS
@@ -217,7 +217,7 @@ func New(cfg *Config, version string) (*Node, error) { //nolint:gocyclo,funlen
 	}
 
 	if cfg.P2P {
-		p2pService, err := p2p.New(cfg.P2PAddr, "juno", cfg.P2PBootPeers, "", cfg.Network, log)
+		p2pService, err := p2p.New(cfg.P2PAddr, "juno", cfg.P2PBootPeers, "", &cfg.Network, log)
 		if err != nil {
 			return nil, fmt.Errorf("set up p2p service: %w", err)
 		}
@@ -236,14 +236,13 @@ func New(cfg *Config, version string) (*Node, error) { //nolint:gocyclo,funlen
 }
 
 func newL1Client(ethNode string, chain *blockchain.Blockchain, log utils.SimpleLogger) (*l1.Client, error) {
-	var coreContractAddress common.Address
-	coreContractAddress, err := chain.Network().CoreContractAddress()
-	if err != nil {
-		return nil, fmt.Errorf("find core contract address for network %s: %w", chain.Network(), err)
+	coreContractAddress := chain.Network().CoreContractAddress
+	if coreContractAddress == (common.Address{}) {
+		return nil, fmt.Errorf("find core contract address for network %p: l1 contract is not available on this network ", chain.Network)
 	}
 
 	var ethSubscriber *l1.EthSubscriber
-	ethSubscriber, err = l1.NewEthSubscriber(ethNode, coreContractAddress)
+	ethSubscriber, err := l1.NewEthSubscriber(ethNode, coreContractAddress)
 	if err != nil {
 		return nil, fmt.Errorf("set up ethSubscriber: %w", err)
 	}
@@ -273,7 +272,7 @@ func (n *Node) Run(ctx context.Context) {
 	}
 	n.log.Debugw(fmt.Sprintf("Running Juno with config:\n%s", string(yamlConfig)))
 
-	if err := migration.MigrateIfNeeded(ctx, n.db, n.cfg.Network, n.log); err != nil {
+	if err := migration.MigrateIfNeeded(ctx, n.db, &n.cfg.Network, n.log); err != nil {
 		if errors.Is(err, context.Canceled) {
 			n.log.Infow("DB Migration cancelled")
 			return
diff --git a/node/node_test.go b/node/node_test.go
index 7cebf7add8..1a3796f771 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -69,8 +69,8 @@ func TestNetworkVerificationOnNonEmptyDB(t *testing.T) {
 			log := utils.NewNopZapLogger()
 			database, err := pebble.New(dbPath, 1, log)
 			require.NoError(t, err)
-			chain := blockchain.New(database, network, log)
-			syncer := sync.New(chain, adaptfeeder.New(feeder.NewTestClient(t, network)), log, 0, false)
+			chain := blockchain.New(database, &network, log)
+			syncer := sync.New(chain, adaptfeeder.New(feeder.NewTestClient(t, &network)), log, 0, false)
 			ctx, cancel := context.WithTimeout(context.Background(), 250*time.Millisecond)
 			require.NoError(t, syncer.Run(ctx))
 			cancel()
diff --git a/node/throttled_vm.go b/node/throttled_vm.go
index 92205de7be..a4d6b55a44 100644
--- a/node/throttled_vm.go
+++ b/node/throttled_vm.go
@@ -18,7 +18,7 @@ func NewThrottledVM(res vm.VM, concurrenyBudget uint, maxQueueLen int32) *Thrott
 }
 
 func (tvm *ThrottledVM) Call(contractAddr, classHash, selector *felt.Felt, calldata []felt.Felt, blockNumber,
-	blockTimestamp uint64, state core.StateReader, network utils.Network,
+	blockTimestamp uint64, state core.StateReader, network *utils.Network,
 ) ([]*felt.Felt, error) {
 	var ret []*felt.Felt
 	throttler := (*utils.Throttler[vm.VM])(tvm)
@@ -30,7 +30,7 @@ func (tvm *ThrottledVM) Call(contractAddr, classHash, selector *felt.Felt, calld
 }
 
 func (tvm *ThrottledVM) Execute(txns []core.Transaction, declaredClasses []core.Class, blockNumber, blockTimestamp uint64,
-	sequencerAddress *felt.Felt, state core.StateReader, network utils.Network, paidFeesOnL1 []*felt.Felt,
+	sequencerAddress *felt.Felt, state core.StateReader, network *utils.Network, paidFeesOnL1 []*felt.Felt,
 	skipChargeFee, skipValidate, errOnRevert bool, gasPriceWEI *felt.Felt, gasPriceSTRK *felt.Felt, legacyTraceJSON bool,
 ) ([]*felt.Felt, []json.RawMessage, error) {
 	var ret []*felt.Felt
diff --git a/p2p/p2p.go b/p2p/p2p.go
index ddc756ef39..cfc852a86e 100644
--- a/p2p/p2p.go
+++ b/p2p/p2p.go
@@ -44,7 +44,7 @@ type Service struct {
 	runLock sync.RWMutex
 }
 
-func New(addr, userAgent, bootPeers, privKeyStr string, snNetwork utils.Network, log utils.SimpleLogger) (*Service, error) {
+func New(addr, userAgent, bootPeers, privKeyStr string, snNetwork *utils.Network, log utils.SimpleLogger) (*Service, error) {
 	if addr == "" {
 		// 0.0.0.0/tcp/0 will listen on any interface device and assing a free port.
 		addr = "/ip4/0.0.0.0/tcp/0"
@@ -66,7 +66,7 @@ func New(addr, userAgent, bootPeers, privKeyStr string, snNetwork utils.Network,
 	return NewWithHost(p2pHost, bootPeers, snNetwork, log)
 }
 
-func NewWithHost(p2phost host.Host, bootPeers string, snNetwork utils.Network, log utils.SimpleLogger) (*Service, error) {
+func NewWithHost(p2phost host.Host, bootPeers string, snNetwork *utils.Network, log utils.SimpleLogger) (*Service, error) {
 	p2pdht, err := makeDHT(p2phost, snNetwork, bootPeers)
 	if err != nil {
 		return nil, err
@@ -76,7 +76,7 @@ func NewWithHost(p2phost host.Host, bootPeers string, snNetwork utils.Network, l
 		bootPeers: bootPeers,
 		log:       log,
 		host:      p2phost,
-		network:   snNetwork,
+		network:   *snNetwork,
 		dht:       p2pdht,
 		topics:    make(map[string]*pubsub.Topic),
 	}
@@ -84,7 +84,7 @@ func NewWithHost(p2phost host.Host, bootPeers string, snNetwork utils.Network, l
 	return s, nil
 }
 
-func makeDHT(p2phost host.Host, snNetwork utils.Network, cfgBootPeers string) (*dht.IpfsDHT, error) {
+func makeDHT(p2phost host.Host, snNetwork *utils.Network, cfgBootPeers string) (*dht.IpfsDHT, error) {
 	bootPeers := []peer.AddrInfo{}
 	if cfgBootPeers != "" {
 		splitted := strings.Split(cfgBootPeers, ",")
diff --git a/p2p/p2p_test.go b/p2p/p2p_test.go
index e04713a609..b75eefe11a 100644
--- a/p2p/p2p_test.go
+++ b/p2p/p2p_test.go
@@ -28,7 +28,7 @@ func TestService(t *testing.T) {
 	peerA, err := p2p.NewWithHost(
 		peerHosts[0],
 		"",
-		utils.Integration,
+		&utils.Integration,
 		utils.NewNopZapLogger(),
 	)
 	require.NoError(t, err)
@@ -47,7 +47,7 @@ func TestService(t *testing.T) {
 	peerB, err := p2p.NewWithHost(
 		peerHosts[1],
 		strings.Join(bootAddrsString, ","),
-		utils.Integration,
+		&utils.Integration,
 		utils.NewNopZapLogger(),
 	)
 	require.NoError(t, err)
@@ -131,7 +131,7 @@ func TestInvalidKey(t *testing.T) {
 		"peerA",
 		"",
 		"something",
-		utils.Integration,
+		&utils.Integration,
 		utils.NewNopZapLogger(),
 	)
 
@@ -144,7 +144,7 @@ func TestValidKey(t *testing.T) {
 		"peerA",
 		"",
 		"08011240333b4a433f16d7ca225c0e99d0d8c437b835cb74a98d9279c561977690c80f681b25ccf3fa45e2f2de260149c112fa516b69057dd3b0151a879416c0cb12d9b3",
-		utils.Integration,
+		&utils.Integration,
 		utils.NewNopZapLogger(),
 	)
 
diff --git a/p2p/starknet/client.go b/p2p/starknet/client.go
index 3a6897025b..4349acdaaf 100644
--- a/p2p/starknet/client.go
+++ b/p2p/starknet/client.go
@@ -19,10 +19,10 @@ type Client struct {
 	log       utils.Logger
 }
 
-func NewClient(newStream NewStreamFunc, snNetwork utils.Network, log utils.Logger) *Client {
+func NewClient(newStream NewStreamFunc, snNetwork *utils.Network, log utils.Logger) *Client {
 	return &Client{
 		newStream: newStream,
-		network:   snNetwork,
+		network:   *snNetwork,
 		log:       log,
 	}
 }
@@ -66,21 +66,21 @@ func requestAndReceiveStream[ReqT proto.Message, ResT proto.Message](ctx context
 }
 
 func (c *Client) RequestBlockHeaders(ctx context.Context, req *spec.BlockHeadersRequest) (Stream[*spec.BlockHeadersResponse], error) {
-	return requestAndReceiveStream[*spec.BlockHeadersRequest, *spec.BlockHeadersResponse](ctx, c.newStream, BlockHeadersPID(c.network), req)
+	return requestAndReceiveStream[*spec.BlockHeadersRequest, *spec.BlockHeadersResponse](ctx, c.newStream, BlockHeadersPID(&c.network), req)
 }
 
 func (c *Client) RequestBlockBodies(ctx context.Context, req *spec.BlockBodiesRequest) (Stream[*spec.BlockBodiesResponse], error) {
-	return requestAndReceiveStream[*spec.BlockBodiesRequest, *spec.BlockBodiesResponse](ctx, c.newStream, BlockBodiesPID(c.network), req)
+	return requestAndReceiveStream[*spec.BlockBodiesRequest, *spec.BlockBodiesResponse](ctx, c.newStream, BlockBodiesPID(&c.network), req)
 }
 
 func (c *Client) RequestEvents(ctx context.Context, req *spec.EventsRequest) (Stream[*spec.EventsResponse], error) {
-	return requestAndReceiveStream[*spec.EventsRequest, *spec.EventsResponse](ctx, c.newStream, EventsPID(c.network), req)
+	return requestAndReceiveStream[*spec.EventsRequest, *spec.EventsResponse](ctx, c.newStream, EventsPID(&c.network), req)
 }
 
 func (c *Client) RequestReceipts(ctx context.Context, req *spec.ReceiptsRequest) (Stream[*spec.ReceiptsResponse], error) {
-	return requestAndReceiveStream[*spec.ReceiptsRequest, *spec.ReceiptsResponse](ctx, c.newStream, ReceiptsPID(c.network), req)
+	return requestAndReceiveStream[*spec.ReceiptsRequest, *spec.ReceiptsResponse](ctx, c.newStream, ReceiptsPID(&c.network), req)
 }
 
 func (c *Client) RequestTransactions(ctx context.Context, req *spec.TransactionsRequest) (Stream[*spec.TransactionsResponse], error) {
-	return requestAndReceiveStream[*spec.TransactionsRequest, *spec.TransactionsResponse](ctx, c.newStream, TransactionsPID(c.network), req)
+	return requestAndReceiveStream[*spec.TransactionsRequest, *spec.TransactionsResponse](ctx, c.newStream, TransactionsPID(&c.network), req)
 }
diff --git a/p2p/starknet/ids.go b/p2p/starknet/ids.go
index 13cd984b6f..25b6a25cd2 100644
--- a/p2p/starknet/ids.go
+++ b/p2p/starknet/ids.go
@@ -5,22 +5,22 @@ import (
 	"github.com/libp2p/go-libp2p/core/protocol"
 )
 
-func BlockHeadersPID(n utils.Network) protocol.ID {
+func BlockHeadersPID(n *utils.Network) protocol.ID {
 	return n.ProtocolID() + "/block_headers/0"
 }
 
-func BlockBodiesPID(n utils.Network) protocol.ID {
+func BlockBodiesPID(n *utils.Network) protocol.ID {
 	return n.ProtocolID() + "/block_bodies/0"
 }
 
-func EventsPID(n utils.Network) protocol.ID {
+func EventsPID(n *utils.Network) protocol.ID {
 	return n.ProtocolID() + "/events/0"
 }
 
-func ReceiptsPID(n utils.Network) protocol.ID {
+func ReceiptsPID(n *utils.Network) protocol.ID {
 	return n.ProtocolID() + "/receipts/0"
 }
 
-func TransactionsPID(n utils.Network) protocol.ID {
+func TransactionsPID(n *utils.Network) protocol.ID {
 	return n.ProtocolID() + "/transactions/0"
 }
diff --git a/p2p/starknet/starknet_test.go b/p2p/starknet/starknet_test.go
index 3d8437802a..ace34ef151 100644
--- a/p2p/starknet/starknet_test.go
+++ b/p2p/starknet/starknet_test.go
@@ -51,16 +51,16 @@ func TestClientHandler(t *testing.T) { //nolint:gocyclo
 	handler := starknet.NewHandler(mockReader, log)
 
 	handlerHost := mockNet.Host(handlerID)
-	handlerHost.SetStreamHandler(starknet.BlockHeadersPID(testNetwork), handler.BlockHeadersHandler)
-	handlerHost.SetStreamHandler(starknet.BlockBodiesPID(testNetwork), handler.BlockBodiesHandler)
-	handlerHost.SetStreamHandler(starknet.EventsPID(testNetwork), handler.EventsHandler)
-	handlerHost.SetStreamHandler(starknet.ReceiptsPID(testNetwork), handler.ReceiptsHandler)
-	handlerHost.SetStreamHandler(starknet.TransactionsPID(testNetwork), handler.TransactionsHandler)
+	handlerHost.SetStreamHandler(starknet.BlockHeadersPID(&testNetwork), handler.BlockHeadersHandler)
+	handlerHost.SetStreamHandler(starknet.BlockBodiesPID(&testNetwork), handler.BlockBodiesHandler)
+	handlerHost.SetStreamHandler(starknet.EventsPID(&testNetwork), handler.EventsHandler)
+	handlerHost.SetStreamHandler(starknet.ReceiptsPID(&testNetwork), handler.ReceiptsHandler)
+	handlerHost.SetStreamHandler(starknet.TransactionsPID(&testNetwork), handler.TransactionsHandler)
 
 	clientHost := mockNet.Host(clientID)
 	client := starknet.NewClient(func(ctx context.Context, pids ...protocol.ID) (network.Stream, error) {
 		return clientHost.NewStream(ctx, handlerID, pids...)
-	}, testNetwork, log)
+	}, &testNetwork, log)
 
 	t.Run("get block headers", func(t *testing.T) {
 		type pair struct {
diff --git a/rpc/handlers.go b/rpc/handlers.go
index 61350945b4..9fe9b09a60 100644
--- a/rpc/handlers.go
+++ b/rpc/handlers.go
@@ -106,13 +106,13 @@ type subscription struct {
 	conn   jsonrpc.Conn
 }
 
-func New(bcReader blockchain.Reader, syncReader sync.Reader, n utils.Network,
+func New(bcReader blockchain.Reader, syncReader sync.Reader, n *utils.Network,
 	gatewayClient Gateway, feederClient *feeder.Client, virtualMachine vm.VM, version string, logger utils.Logger,
 ) *Handler {
 	return &Handler{
 		bcReader:      bcReader,
 		syncReader:    syncReader,
-		network:       n,
+		network:       *n,
 		log:           logger,
 		feederClient:  feederClient,
 		gatewayClient: gatewayClient,
@@ -159,7 +159,7 @@ func (h *Handler) Run(ctx context.Context) error {
 // It follows the specification defined here:
 // https://github.com/starkware-libs/starknet-specs/blob/a789ccc3432c57777beceaa53a34a7ae2f25fda0/api/starknet_api_openrpc.json#L542
 func (h *Handler) ChainID() (*felt.Felt, *jsonrpc.Error) {
-	return h.network.ChainID(), nil
+	return h.network.ChainIDFelt(), nil
 }
 
 // BlockNumber returns the latest synced block number.
@@ -1188,7 +1188,7 @@ func (h *Handler) Version() (string, *jsonrpc.Error) {
 }
 
 // https://github.com/starkware-libs/starknet-specs/blob/e0b76ed0d8d8eba405e182371f9edac8b2bcbc5a/api/starknet_api_openrpc.json#L401-L445
-func (h *Handler) Call(call FunctionCall, id BlockID) ([]*felt.Felt, *jsonrpc.Error) { //nolint:gocritic
+func (h *Handler) Call(call *FunctionCall, id BlockID) ([]*felt.Felt, *jsonrpc.Error) {
 	state, closer, err := h.stateByBlockID(&id)
 	if err != nil {
 		return nil, ErrBlockNotFound
@@ -1215,7 +1215,7 @@ func (h *Handler) Call(call FunctionCall, id BlockID) ([]*felt.Felt, *jsonrpc.Er
 	}
 
 	res, err := h.vm.Call(&call.ContractAddress, classHash, &call.EntryPointSelector,
-		call.Calldata, blockNumber, header.Timestamp, state, h.network)
+		call.Calldata, blockNumber, header.Timestamp, state, &h.network)
 	if err != nil {
 		if errors.Is(err, utils.ErrResourceBusy) {
 			return nil, ErrUnexpectedError.CloneWithData(err.Error())
@@ -1436,7 +1436,7 @@ func (h *Handler) simulateTransactions(id BlockID, transactions []BroadcastedTra
 
 	paidFeesOnL1 := make([]*felt.Felt, 0)
 	for idx := range transactions {
-		txn, declaredClass, paidFeeOnL1, aErr := adaptBroadcastedTransaction(&transactions[idx], h.network)
+		txn, declaredClass, paidFeeOnL1, aErr := adaptBroadcastedTransaction(&transactions[idx], &h.network)
 		if aErr != nil {
 			return nil, jsonrpc.Err(jsonrpc.InvalidParams, aErr.Error())
 		}
@@ -1462,10 +1462,10 @@ func (h *Handler) simulateTransactions(id BlockID, transactions []BroadcastedTra
 
 	sequencerAddress := header.SequencerAddress
 	if sequencerAddress == nil {
-		sequencerAddress = core.NetworkBlockHashMetaInfo(h.network).FallBackSequencerAddress
+		sequencerAddress = h.network.MetaInfo().FallBackSequencerAddress
 	}
 	overallFees, traces, err := h.vm.Execute(txns, classes, blockNumber, header.Timestamp, sequencerAddress,
-		state, h.network, paidFeesOnL1, skipFeeCharge, skipValidate, errOnRevert, header.GasPrice, header.GasPriceSTRK, legacyTraceJSON)
+		state, &h.network, paidFeesOnL1, skipFeeCharge, skipValidate, errOnRevert, header.GasPrice, header.GasPriceSTRK, legacyTraceJSON)
 	if err != nil {
 		if errors.Is(err, utils.ErrResourceBusy) {
 			return nil, ErrInternal.CloneWithData(err.Error())
@@ -1611,11 +1611,11 @@ func (h *Handler) traceBlockTransactions(ctx context.Context, block *core.Block,
 
 	sequencerAddress := block.Header.SequencerAddress
 	if sequencerAddress == nil {
-		sequencerAddress = core.NetworkBlockHashMetaInfo(h.network).FallBackSequencerAddress
+		sequencerAddress = h.network.MetaInfo().FallBackSequencerAddress
 	}
 
 	_, traces, err := h.vm.Execute(block.Transactions, classes, blockNumber, block.Header.Timestamp,
-		sequencerAddress, state, h.network, paidFeesOnL1, false, false, false, block.Header.GasPrice, block.Header.GasPriceSTRK, legacyJSON)
+		sequencerAddress, state, &h.network, paidFeesOnL1, false, false, false, block.Header.GasPrice, block.Header.GasPriceSTRK, legacyJSON)
 	if err != nil {
 		if errors.Is(err, utils.ErrResourceBusy) {
 			return nil, ErrInternal.CloneWithData(err.Error())
diff --git a/rpc/handlers_test.go b/rpc/handlers_test.go
index 2ed4977ca2..f22a814969 100644
--- a/rpc/handlers_test.go
+++ b/rpc/handlers_test.go
@@ -43,11 +43,11 @@ func TestChainId(t *testing.T) {
 			t.Cleanup(mockCtrl.Finish)
 
 			mockReader := mocks.NewMockReader(mockCtrl)
-			handler := rpc.New(mockReader, nil, n, nil, nil, nil, "", nil)
+			handler := rpc.New(mockReader, nil, &n, nil, nil, nil, "", nil)
 
 			cID, err := handler.ChainID()
 			require.Nil(t, err)
-			assert.Equal(t, n.ChainID(), cID)
+			assert.Equal(t, n.ChainIDFelt(), cID)
 		})
 	}
 }
@@ -57,7 +57,7 @@ func TestBlockNumber(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", nil)
 
 	t.Run("empty blockchain", func(t *testing.T) {
 		expectedHeight := uint64(0)
@@ -83,7 +83,7 @@ func TestBlockHashAndNumber(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", nil)
 
 	t.Run("empty blockchain", func(t *testing.T) {
 		mockReader.EXPECT().Head().Return(nil, errors.New("empty blockchain"))
@@ -94,7 +94,7 @@ func TestBlockHashAndNumber(t *testing.T) {
 	})
 
 	t.Run("blockchain height is 147", func(t *testing.T) {
-		client := feeder.NewTestClient(t, utils.Mainnet)
+		client := feeder.NewTestClient(t, &utils.Mainnet)
 		gw := adaptfeeder.New(client)
 
 		expectedBlock, err := gw.BlockByNumber(context.Background(), 147)
@@ -115,9 +115,9 @@ func TestBlockTransactionCount(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Goerli, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Goerli, nil, nil, nil, "", nil)
 
-	client := feeder.NewTestClient(t, utils.Goerli)
+	client := feeder.NewTestClient(t, &utils.Goerli)
 	gw := adaptfeeder.New(client)
 
 	latestBlockNumber := uint64(485004)
@@ -192,9 +192,9 @@ func TestBlockWithTxHashes(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Goerli, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Goerli, nil, nil, nil, "", nil)
 
-	client := feeder.NewTestClient(t, utils.Goerli)
+	client := feeder.NewTestClient(t, &utils.Goerli)
 	gw := adaptfeeder.New(client)
 
 	latestBlockNumber := uint64(485004)
@@ -314,9 +314,9 @@ func TestBlockWithTxs(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", nil)
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	latestBlockNumber := uint64(16697)
@@ -458,10 +458,10 @@ func TestBlockWithTxHashesV013(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, network, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &network, nil, nil, nil, "", nil)
 
 	blockNumber := uint64(319132)
-	gw := adaptfeeder.New(feeder.NewTestClient(t, network))
+	gw := adaptfeeder.New(feeder.NewTestClient(t, &network))
 	coreBlock, err := gw.BlockByNumber(context.Background(), blockNumber)
 	require.NoError(t, err)
 	tx, ok := coreBlock.Transactions[0].(*core.InvokeTransaction)
@@ -528,7 +528,7 @@ func TestTransactionByHashNotFound(t *testing.T) {
 	txHash := new(felt.Felt).SetBytes([]byte("random hash"))
 	mockReader.EXPECT().TransactionByHash(txHash).Return(nil, errors.New("tx not found"))
 
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", nil)
 
 	tx, rpcErr := handler.TransactionByHash(*txHash)
 	assert.Nil(t, tx)
@@ -796,14 +796,14 @@ func TestTransactionByHash(t *testing.T) {
 
 	for name, test := range tests {
 		t.Run(name, func(t *testing.T) {
-			gw := adaptfeeder.New(feeder.NewTestClient(t, test.network))
+			gw := adaptfeeder.New(feeder.NewTestClient(t, &test.network))
 			mockCtrl := gomock.NewController(t)
 			t.Cleanup(mockCtrl.Finish)
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockReader.EXPECT().TransactionByHash(gomock.Any()).DoAndReturn(func(hash *felt.Felt) (core.Transaction, error) {
 				return gw.Transaction(context.Background(), hash)
 			}).Times(1)
-			handler := rpc.New(mockReader, nil, test.network, nil, nil, nil, "", nil)
+			handler := rpc.New(mockReader, nil, &test.network, nil, nil, nil, "", nil)
 
 			hash, err := new(felt.Felt).SetString(test.hash)
 			require.NoError(t, err)
@@ -1053,14 +1053,14 @@ func TestLegacyTransactionByHash(t *testing.T) {
 
 	for name, test := range tests {
 		t.Run(name, func(t *testing.T) {
-			gw := adaptfeeder.New(feeder.NewTestClient(t, test.network))
+			gw := adaptfeeder.New(feeder.NewTestClient(t, &test.network))
 			mockCtrl := gomock.NewController(t)
 			t.Cleanup(mockCtrl.Finish)
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockReader.EXPECT().TransactionByHash(gomock.Any()).DoAndReturn(func(hash *felt.Felt) (core.Transaction, error) {
 				return gw.Transaction(context.Background(), hash)
 			}).Times(1)
-			handler := rpc.New(mockReader, nil, test.network, nil, nil, nil, "", nil)
+			handler := rpc.New(mockReader, nil, &test.network, nil, nil, nil, "", nil)
 
 			hash, err := new(felt.Felt).SetString(test.hash)
 			require.NoError(t, err)
@@ -1086,7 +1086,7 @@ func TestTransactionByBlockIdAndIndex(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	mainnetGw := adaptfeeder.New(client)
 
 	latestBlockNumber := 19199
@@ -1094,7 +1094,7 @@ func TestTransactionByBlockIdAndIndex(t *testing.T) {
 	require.NoError(t, err)
 	latestBlockHash := latestBlock.Hash
 
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", nil)
 
 	t.Run("empty blockchain", func(t *testing.T) {
 		mockReader.EXPECT().HeadsHeader().Return(nil, errors.New("empty blockchain"))
@@ -1232,7 +1232,7 @@ func TestTransactionReceiptByHash(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", nil)
 
 	t.Run("transaction not found", func(t *testing.T) {
 		txHash := new(felt.Felt).SetBytes([]byte("random hash"))
@@ -1243,7 +1243,7 @@ func TestTransactionReceiptByHash(t *testing.T) {
 		assert.Equal(t, rpc.ErrTxnHashNotFound, rpcErr)
 	})
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	mainnetGw := adaptfeeder.New(client)
 
 	block0, err := mainnetGw.BlockByNumber(context.Background(), 0)
@@ -1401,7 +1401,7 @@ func TestTransactionReceiptByHash(t *testing.T) {
 			"execution_resources":{"steps":0}
 		}`
 
-		integClient := feeder.NewTestClient(t, utils.Integration)
+		integClient := feeder.NewTestClient(t, &utils.Integration)
 		integGw := adaptfeeder.New(integClient)
 
 		blockWithRevertedTxn, err := integGw.BlockByNumber(context.Background(), 304740)
@@ -1465,7 +1465,7 @@ func TestTransactionReceiptByHash(t *testing.T) {
 			"type": "INVOKE"
 		}`
 
-		integClient := feeder.NewTestClient(t, utils.Integration)
+		integClient := feeder.NewTestClient(t, &utils.Integration)
 		integGw := adaptfeeder.New(integClient)
 
 		block, err := integGw.BlockByNumber(context.Background(), 319132)
@@ -1489,7 +1489,7 @@ func TestLegacyTransactionReceiptByHash(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", nil)
 
 	t.Run("transaction not found", func(t *testing.T) {
 		txHash := new(felt.Felt).SetBytes([]byte("random hash"))
@@ -1500,7 +1500,7 @@ func TestLegacyTransactionReceiptByHash(t *testing.T) {
 		assert.Equal(t, rpc.ErrTxnHashNotFound, rpcErr)
 	})
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	mainnetGw := adaptfeeder.New(client)
 
 	block0, err := mainnetGw.BlockByNumber(context.Background(), 0)
@@ -1658,7 +1658,7 @@ func TestLegacyTransactionReceiptByHash(t *testing.T) {
 			"execution_resources":{"bitwise_builtin_applications":"0x0", "ec_op_builtin_applications":"0x0", "ecdsa_builtin_applications":"0x0", "keccak_builtin_applications":"0x0", "memory_holes":"0x0", "pedersen_builtin_applications":"0x0", "poseidon_builtin_applications":"0x0", "range_check_builtin_applications":"0x0","steps":"0x0"}
 		}`
 
-		integClient := feeder.NewTestClient(t, utils.Integration)
+		integClient := feeder.NewTestClient(t, &utils.Integration)
 		integGw := adaptfeeder.New(integClient)
 
 		blockWithRevertedTxn, err := integGw.BlockByNumber(context.Background(), 304740)
@@ -1715,7 +1715,7 @@ func TestLegacyTransactionReceiptByHash(t *testing.T) {
 			"type": "INVOKE"
 		}`
 
-		integClient := feeder.NewTestClient(t, utils.Integration)
+		integClient := feeder.NewTestClient(t, &utils.Integration)
 		integGw := adaptfeeder.New(integClient)
 
 		block, err := integGw.BlockByNumber(context.Background(), 319132)
@@ -1738,7 +1738,7 @@ func TestStateUpdate(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", nil)
 
 	t.Run("empty blockchain", func(t *testing.T) {
 		mockReader.EXPECT().Height().Return(uint64(0), errors.New("empty blockchain"))
@@ -1764,7 +1764,7 @@ func TestStateUpdate(t *testing.T) {
 		assert.Equal(t, rpc.ErrBlockNotFound, rpcErr)
 	})
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	mainnetGw := adaptfeeder.New(client)
 
 	update21656, err := mainnetGw.StateUpdate(context.Background(), 21656)
@@ -1836,7 +1836,7 @@ func TestStateUpdate(t *testing.T) {
 	})
 
 	t.Run("post v0.11.0", func(t *testing.T) {
-		integrationClient := feeder.NewTestClient(t, utils.Integration)
+		integrationClient := feeder.NewTestClient(t, &utils.Integration)
 		integGw := adaptfeeder.New(integrationClient)
 
 		for name, height := range map[string]uint64{
@@ -1877,7 +1877,7 @@ func TestSyncing(t *testing.T) {
 
 	synchronizer := mocks.NewMockSyncReader(mockCtrl)
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, synchronizer, utils.Mainnet, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, synchronizer, &utils.Mainnet, nil, nil, nil, "", nil)
 	defaultSyncState := false
 
 	startingBlock := uint64(0)
@@ -1950,7 +1950,7 @@ func TestNonce(t *testing.T) {
 
 	mockReader := mocks.NewMockReader(mockCtrl)
 	log := utils.NewNopZapLogger()
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", log)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", log)
 
 	t.Run("empty blockchain", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(nil, nil, errors.New("empty blockchain"))
@@ -2023,7 +2023,7 @@ func TestStorageAt(t *testing.T) {
 
 	mockReader := mocks.NewMockReader(mockCtrl)
 	log := utils.NewNopZapLogger()
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", log)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", log)
 
 	t.Run("empty blockchain", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(nil, nil, errors.New("empty blockchain"))
@@ -2105,7 +2105,7 @@ func TestClassHashAt(t *testing.T) {
 
 	mockReader := mocks.NewMockReader(mockCtrl)
 	log := utils.NewNopZapLogger()
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", log)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", log)
 
 	t.Run("empty blockchain", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(nil, nil, errors.New("empty blockchain"))
@@ -2226,7 +2226,7 @@ func assertEqualCairo1Class(t *testing.T, cairo1Class *core.Cairo1Class, class *
 }
 
 func TestClass(t *testing.T) {
-	integrationClient := feeder.NewTestClient(t, utils.Integration)
+	integrationClient := feeder.NewTestClient(t, &utils.Integration)
 	integGw := adaptfeeder.New(integrationClient)
 
 	mockCtrl := gomock.NewController(t)
@@ -2243,7 +2243,7 @@ func TestClass(t *testing.T) {
 		return nil
 	}, nil).AnyTimes()
 	mockReader.EXPECT().HeadsHeader().Return(new(core.Header), nil).AnyTimes()
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", utils.NewNopZapLogger())
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", utils.NewNopZapLogger())
 
 	latest := rpc.BlockID{Latest: true}
 
@@ -2274,7 +2274,7 @@ func TestClass(t *testing.T) {
 }
 
 func TestClassAt(t *testing.T) {
-	integrationClient := feeder.NewTestClient(t, utils.Integration)
+	integrationClient := feeder.NewTestClient(t, &utils.Integration)
 	integGw := adaptfeeder.New(integrationClient)
 
 	mockCtrl := gomock.NewController(t)
@@ -2299,7 +2299,7 @@ func TestClassAt(t *testing.T) {
 		return nil
 	}, nil).AnyTimes()
 	mockReader.EXPECT().HeadsHeader().Return(new(core.Header), nil).AnyTimes()
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", utils.NewNopZapLogger())
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", utils.NewNopZapLogger())
 
 	latest := rpc.BlockID{Latest: true}
 
@@ -2327,9 +2327,9 @@ func TestClassAt(t *testing.T) {
 
 func TestEvents(t *testing.T) {
 	testDB := pebble.NewMemTest(t)
-	chain := blockchain.New(testDB, utils.Goerli2, utils.NewNopZapLogger())
+	chain := blockchain.New(testDB, &utils.Goerli2, utils.NewNopZapLogger())
 
-	client := feeder.NewTestClient(t, utils.Goerli2)
+	client := feeder.NewTestClient(t, &utils.Goerli2)
 	gw := adaptfeeder.New(client)
 
 	for i := 0; i < 7; i++ {
@@ -2350,7 +2350,7 @@ func TestEvents(t *testing.T) {
 		}
 	}
 
-	handler := rpc.New(chain, nil, utils.Goerli2, nil, nil, nil, "", utils.NewNopZapLogger())
+	handler := rpc.New(chain, nil, &utils.Goerli2, nil, nil, nil, "", utils.NewNopZapLogger())
 	from := utils.HexToFelt(t, "0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7")
 	args := rpc.EventsArg{
 		EventFilter: rpc.EventFilter{
@@ -2553,7 +2553,7 @@ func TestAddTransactionUnmarshal(t *testing.T) {
 
 func TestAddTransaction(t *testing.T) {
 	network := utils.Integration
-	gw := adaptfeeder.New(feeder.NewTestClient(t, network))
+	gw := adaptfeeder.New(feeder.NewTestClient(t, &network))
 	txWithoutClass := func(hash string) rpc.BroadcastedTransaction {
 		tx, err := gw.Transaction(context.Background(), utils.HexToFelt(t, hash))
 		require.NoError(t, err)
@@ -2818,7 +2818,7 @@ func TestAddTransaction(t *testing.T) {
 				}`), nil).
 				Times(1)
 
-			handler := rpc.New(nil, nil, network, mockGateway, nil, nil, "", utils.NewNopZapLogger())
+			handler := rpc.New(nil, nil, &network, mockGateway, nil, nil, "", utils.NewNopZapLogger())
 			got, rpcErr := handler.AddTransaction(test.txn)
 			require.Nil(t, rpcErr)
 			require.Equal(t, &rpc.AddTxResponse{
@@ -2833,7 +2833,7 @@ func TestAddTransaction(t *testing.T) {
 func TestVersion(t *testing.T) {
 	const version = "1.2.3-rc1"
 
-	handler := rpc.New(nil, nil, utils.Mainnet, nil, nil, nil, version, nil)
+	handler := rpc.New(nil, nil, &utils.Mainnet, nil, nil, nil, version, nil)
 	ver, err := handler.Version()
 	require.Nil(t, err)
 	assert.Equal(t, version, ver)
@@ -2870,7 +2870,7 @@ func TestTransactionStatus(t *testing.T) {
 			mockCtrl := gomock.NewController(t)
 			t.Cleanup(mockCtrl.Finish)
 
-			client := feeder.NewTestClient(t, test.network)
+			client := feeder.NewTestClient(t, &test.network)
 
 			t.Run("tx found in db", func(t *testing.T) {
 				gw := adaptfeeder.New(client)
@@ -2886,7 +2886,7 @@ func TestTransactionStatus(t *testing.T) {
 					mockReader.EXPECT().Receipt(tx.Hash()).Return(block.Receipts[0], block.Hash, block.Number, nil)
 					mockReader.EXPECT().L1Head().Return(nil, nil)
 
-					handler := rpc.New(mockReader, nil, test.network, nil, nil, nil, "", nil)
+					handler := rpc.New(mockReader, nil, &test.network, nil, nil, nil, "", nil)
 
 					want := &rpc.TransactionStatus{
 						Finality:  rpc.TxnStatusAcceptedOnL2,
@@ -2904,7 +2904,7 @@ func TestTransactionStatus(t *testing.T) {
 						BlockNumber: block.Number + 1,
 					}, nil)
 
-					handler := rpc.New(mockReader, nil, test.network, nil, nil, nil, "", nil)
+					handler := rpc.New(mockReader, nil, &test.network, nil, nil, nil, "", nil)
 
 					want := &rpc.TransactionStatus{
 						Finality:  rpc.TxnStatusAcceptedOnL1,
@@ -2934,7 +2934,7 @@ func TestTransactionStatus(t *testing.T) {
 					t.Run(description, func(t *testing.T) {
 						mockReader := mocks.NewMockReader(mockCtrl)
 						mockReader.EXPECT().TransactionByHash(notFoundTest.hash).Return(nil, db.ErrKeyNotFound)
-						handler := rpc.New(mockReader, nil, test.network, nil, client, nil, "", nil)
+						handler := rpc.New(mockReader, nil, &test.network, nil, client, nil, "", nil)
 
 						status, err := handler.TransactionStatus(ctx, *notFoundTest.hash)
 						require.Nil(t, err)
@@ -2948,7 +2948,7 @@ func TestTransactionStatus(t *testing.T) {
 			t.Run("transaction not found in db and feeder  ", func(t *testing.T) {
 				mockReader := mocks.NewMockReader(mockCtrl)
 				mockReader.EXPECT().TransactionByHash(test.notFoundTxHash).Return(nil, db.ErrKeyNotFound)
-				handler := rpc.New(mockReader, nil, test.network, nil, client, nil, "", nil)
+				handler := rpc.New(mockReader, nil, &test.network, nil, client, nil, "", nil)
 
 				_, err := handler.TransactionStatus(ctx, *test.notFoundTxHash)
 				require.NotNil(t, err)
@@ -2964,12 +2964,12 @@ func TestCall(t *testing.T) {
 
 	mockReader := mocks.NewMockReader(mockCtrl)
 	log := utils.NewNopZapLogger()
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, nil, "", log)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, nil, "", log)
 
 	t.Run("empty blockchain", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(nil, nil, errors.New("empty blockchain"))
 
-		res, rpcErr := handler.Call(rpc.FunctionCall{}, rpc.BlockID{Latest: true})
+		res, rpcErr := handler.Call(nil, rpc.BlockID{Latest: true})
 		require.Nil(t, res)
 		assert.Equal(t, rpc.ErrBlockNotFound, rpcErr)
 	})
@@ -2977,7 +2977,7 @@ func TestCall(t *testing.T) {
 	t.Run("non-existent block hash", func(t *testing.T) {
 		mockReader.EXPECT().StateAtBlockHash(&felt.Zero).Return(nil, nil, errors.New("non-existent block hash"))
 
-		res, rpcErr := handler.Call(rpc.FunctionCall{}, rpc.BlockID{Hash: &felt.Zero})
+		res, rpcErr := handler.Call(nil, rpc.BlockID{Hash: &felt.Zero})
 		require.Nil(t, res)
 		assert.Equal(t, rpc.ErrBlockNotFound, rpcErr)
 	})
@@ -2985,19 +2985,17 @@ func TestCall(t *testing.T) {
 	t.Run("non-existent block number", func(t *testing.T) {
 		mockReader.EXPECT().StateAtBlockNumber(uint64(0)).Return(nil, nil, errors.New("non-existent block number"))
 
-		res, rpcErr := handler.Call(rpc.FunctionCall{}, rpc.BlockID{Number: 0})
+		res, rpcErr := handler.Call(nil, rpc.BlockID{Number: 0})
 		require.Nil(t, res)
 		assert.Equal(t, rpc.ErrBlockNotFound, rpcErr)
 	})
-
 	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
-
 	t.Run("call - unknown contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 		mockReader.EXPECT().HeadsHeader().Return(new(core.Header), nil)
 		mockState.EXPECT().ContractClassHash(&felt.Zero).Return(nil, errors.New("unknown contract"))
 
-		res, rpcErr := handler.Call(rpc.FunctionCall{}, rpc.BlockID{Latest: true})
+		res, rpcErr := handler.Call(&rpc.FunctionCall{}, rpc.BlockID{Latest: true})
 		require.Nil(t, res)
 		assert.Equal(t, rpc.ErrContractNotFound, rpcErr)
 	})
@@ -3011,7 +3009,7 @@ func TestEstimateMessageFee(t *testing.T) {
 	mockVM := mocks.NewMockVM(mockCtrl)
 	log := utils.NewNopZapLogger()
 
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, mockVM, "", log)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, mockVM, "", log)
 	msg := rpc.MsgFromL1{
 		From:     common.HexToAddress("0xDEADBEEF"),
 		To:       *new(felt.Felt).SetUint64(1337),
@@ -3037,10 +3035,10 @@ func TestEstimateMessageFee(t *testing.T) {
 
 	expectedGasConsumed := new(felt.Felt).SetUint64(37)
 	mockVM.EXPECT().Execute(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
-		gomock.Any(), utils.Mainnet, gomock.Any(), gomock.Any(), gomock.Any(), true, latestHeader.GasPrice,
+		gomock.Any(), &utils.Mainnet, gomock.Any(), gomock.Any(), gomock.Any(), true, latestHeader.GasPrice,
 		latestHeader.GasPriceSTRK, false).DoAndReturn(
 		func(txns []core.Transaction, declaredClasses []core.Class, blockNumber, blockTimestamp uint64,
-			sequencerAddress *felt.Felt, state core.StateReader, network utils.Network, paidFeesOnL1 []*felt.Felt,
+			sequencerAddress *felt.Felt, state core.StateReader, network *utils.Network, paidFeesOnL1 []*felt.Felt,
 			skipChargeFee, skipValidate, errOnRevert bool, gasPriceWei, gasPriceSTRK *felt.Felt, legacyTraceJson bool,
 		) ([]*felt.Felt, []json.RawMessage, error) {
 			require.Len(t, txns, 1)
@@ -3076,7 +3074,7 @@ func TestLegacyEstimateMessageFee(t *testing.T) {
 	mockVM := mocks.NewMockVM(mockCtrl)
 	log := utils.NewNopZapLogger()
 
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, mockVM, "", log)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, mockVM, "", log)
 	msg := rpc.MsgFromL1{
 		From:     common.HexToAddress("0xDEADBEEF"),
 		To:       *new(felt.Felt).SetUint64(1337),
@@ -3096,9 +3094,9 @@ func TestLegacyEstimateMessageFee(t *testing.T) {
 
 	expectedGasConsumed := new(felt.Felt).SetUint64(37)
 	mockVM.EXPECT().Execute(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
-		gomock.Any(), utils.Mainnet, gomock.Any(), gomock.Any(), gomock.Any(), true, latestHeader.GasPrice, latestHeader.GasPriceSTRK, false).DoAndReturn(
+		gomock.Any(), &utils.Mainnet, gomock.Any(), gomock.Any(), gomock.Any(), true, latestHeader.GasPrice, latestHeader.GasPriceSTRK, false).DoAndReturn(
 		func(txns []core.Transaction, declaredClasses []core.Class, blockNumber, blockTimestamp uint64,
-			sequencerAddress *felt.Felt, state core.StateReader, network utils.Network, paidFeesOnL1 []*felt.Felt,
+			sequencerAddress *felt.Felt, state core.StateReader, network *utils.Network, paidFeesOnL1 []*felt.Felt,
 			skipChargeFee, skipValidate, errOnRevert bool, gasPriceWei, gasPriceSTRK *felt.Felt, legacyTraceJson bool,
 		) ([]*felt.Felt, []json.RawMessage, error) {
 			actualFee := new(felt.Felt).Mul(expectedGasConsumed, gasPriceWei)
@@ -3122,7 +3120,7 @@ func TestTraceTransaction(t *testing.T) {
 	mockReader := mocks.NewMockReader(mockCtrl)
 	mockVM := mocks.NewMockVM(mockCtrl)
 	log := utils.NewNopZapLogger()
-	handler := rpc.New(mockReader, nil, utils.Mainnet, nil, nil, mockVM, "", log)
+	handler := rpc.New(mockReader, nil, &utils.Mainnet, nil, nil, mockVM, "", log)
 
 	t.Run("not found", func(t *testing.T) {
 		hash := utils.HexToFelt(t, "0xBBBB")
@@ -3170,7 +3168,7 @@ func TestTraceTransaction(t *testing.T) {
 		"fee_transfer_invocation": {"contract_address": "0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7", "entry_point_selector": "0x83afd3f4caedc6eebf44246fe54e38c95e3179a5ec9ea81740eca5b482d12e", "calldata": ["0x1176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8", "0x2cb6", "0x0"], "caller_address": "0xd747220b2744d8d8d48c8a52bd3869fb98aea915665ab2485d5eadb49def6a", "class_hash": "0xd0e183745e9dae3e4e78a8ffedcce0903fc4900beace4e0abf192d4c202da3", "entry_point_type": "EXTERNAL", "call_type": "CALL", "result": ["0x1"], "calls": [{"contract_address": "0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7", "entry_point_selector": "0x83afd3f4caedc6eebf44246fe54e38c95e3179a5ec9ea81740eca5b482d12e", "calldata": ["0x1176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8", "0x2cb6", "0x0"], "caller_address": "0xd747220b2744d8d8d48c8a52bd3869fb98aea915665ab2485d5eadb49def6a", "class_hash": "0x2760f25d5a4fb2bdde5f561fd0b44a3dee78c28903577d37d669939d97036a0", "entry_point_type": "EXTERNAL", "call_type": "DELEGATE", "result": ["0x1"], "calls": [], "events": [{"keys": ["0x99cd8bde557814842a3121e8ddfd433a539b8c9f14bf31ebf108d12e6196e9"], "data": ["0xd747220b2744d8d8d48c8a52bd3869fb98aea915665ab2485d5eadb49def6a", "0x1176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8", "0x2cb6", "0x0"]}], "messages": []}], "events": [], "messages": []}
 	}`)
 		mockVM.EXPECT().Execute([]core.Transaction{tx}, []core.Class{declaredClass.Class}, header.Number, header.Timestamp, header.SequencerAddress,
-			gomock.Any(), utils.Mainnet, []*felt.Felt{}, false, false, false, gomock.Any(), gomock.Any(), false).Return(nil, []json.RawMessage{vmTrace}, nil)
+			gomock.Any(), &utils.Mainnet, []*felt.Felt{}, false, false, false, gomock.Any(), gomock.Any(), false).Return(nil, []json.RawMessage{vmTrace}, nil)
 
 		trace, err := handler.TraceTransaction(context.Background(), *hash)
 		require.Nil(t, err)
@@ -3182,7 +3180,7 @@ func TestSimulateTransactions(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 
-	const network = utils.Mainnet
+	network := &utils.Mainnet
 
 	mockReader := mocks.NewMockReader(mockCtrl)
 	mockVM := mocks.NewMockVM(mockCtrl)
@@ -3244,7 +3242,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 	mockVM := mocks.NewMockVM(mockCtrl)
 	log := utils.NewNopZapLogger()
 
-	const network = utils.Mainnet
+	network := &utils.Mainnet
 	handler := rpc.New(mockReader, nil, network, nil, nil, mockVM, "", log)
 
 	t.Run("block not found", func(t *testing.T) {
@@ -3289,7 +3287,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 		const height uint64 = 8
 		mockReader.EXPECT().Height().Return(height, nil)
 
-		sequencerAddress := core.NetworkBlockHashMetaInfo(network).FallBackSequencerAddress
+		sequencerAddress := network.MetaInfo().FallBackSequencerAddress
 		paidL1Fees := []*felt.Felt{(&felt.Felt{}).SetUint64(1)}
 		vmTrace := json.RawMessage(`{
 			"validate_invocation": {},
@@ -3360,9 +3358,9 @@ func TestRpcBlockAdaptation(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpc.New(mockReader, nil, utils.Goerli, nil, nil, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &utils.Goerli, nil, nil, nil, "", nil)
 
-	client := feeder.NewTestClient(t, utils.Goerli)
+	client := feeder.NewTestClient(t, &utils.Goerli)
 	gw := adaptfeeder.New(client)
 	latestBlockNumber := uint64(485004)
 
@@ -3401,7 +3399,7 @@ func (fc *fakeConn) Equal(other jsonrpc.Conn) bool {
 
 func TestSubscribeNewHeadsAndUnsubscribe(t *testing.T) {
 	log := utils.NewNopZapLogger()
-	network := utils.Mainnet
+	network := &utils.Mainnet
 	client := feeder.NewTestClient(t, network)
 	gw := adaptfeeder.New(client)
 	ctx, cancel := context.WithCancel(context.Background())
@@ -3480,7 +3478,7 @@ func TestSubscribeNewHeadsAndUnsubscribe(t *testing.T) {
 
 func TestMultipleSubscribeNewHeadsAndUnsubscribe(t *testing.T) {
 	log := utils.NewNopZapLogger()
-	network := utils.Mainnet
+	network := &utils.Mainnet
 	feederClient := feeder.NewTestClient(t, network)
 	gw := adaptfeeder.New(feederClient)
 	ctx, cancel := context.WithCancel(context.Background())
@@ -3567,10 +3565,10 @@ func TestTraceFallback(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
 	network := utils.Integration
-	client := feeder.NewTestClient(t, network)
+	client := feeder.NewTestClient(t, &network)
 	mockReader := mocks.NewMockReader(mockCtrl)
 	gateway := adaptfeeder.New(client)
-	handler := rpc.New(mockReader, nil, network, nil, client, nil, "", nil)
+	handler := rpc.New(mockReader, nil, &network, nil, client, nil, "", nil)
 
 	mockReader.EXPECT().BlockByNumber(gomock.Any()).DoAndReturn(func(number uint64) (block *core.Block, err error) {
 		return gateway.BlockByNumber(context.Background(), number)
@@ -3616,14 +3614,14 @@ func TestThrottledVMError(t *testing.T) {
 	mockVM := mocks.NewMockVM(mockCtrl)
 
 	throttledVM := node.NewThrottledVM(mockVM, 0, 0)
-	handler := rpc.New(mockReader, nil, network, nil, nil, throttledVM, "", nil)
+	handler := rpc.New(mockReader, nil, &network, nil, nil, throttledVM, "", nil)
 	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
 
 	t.Run("call", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 		mockReader.EXPECT().HeadsHeader().Return(new(core.Header), nil)
 		mockState.EXPECT().ContractClassHash(&felt.Zero).Return(new(felt.Felt), nil)
-		_, rpcErr := handler.Call(rpc.FunctionCall{}, rpc.BlockID{Latest: true})
+		_, rpcErr := handler.Call(&rpc.FunctionCall{}, rpc.BlockID{Latest: true})
 		assert.Equal(t, utils.ErrResourceBusy.Error(), rpcErr.Data)
 	})
 
@@ -3673,7 +3671,7 @@ func TestThrottledVMError(t *testing.T) {
 }
 
 func TestSpecVersion(t *testing.T) {
-	handler := rpc.New(nil, nil, 0, nil, nil, nil, "", nil)
+	handler := rpc.New(nil, nil, &utils.Network{}, nil, nil, nil, "", nil)
 	version, rpcErr := handler.SpecVersion()
 	require.Nil(t, rpcErr)
 	require.Equal(t, "0.6.0", version)
@@ -3687,7 +3685,7 @@ func TestEstimateFee(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 
-	const network = utils.Mainnet
+	network := &utils.Mainnet
 
 	mockReader := mocks.NewMockReader(mockCtrl)
 	mockVM := mocks.NewMockVM(mockCtrl)
diff --git a/rpc/transaction.go b/rpc/transaction.go
index e859942664..017827645a 100644
--- a/rpc/transaction.go
+++ b/rpc/transaction.go
@@ -393,7 +393,7 @@ type FeeEstimate struct {
 }
 
 func adaptBroadcastedTransaction(broadcastedTxn *BroadcastedTransaction,
-	network utils.Network,
+	network *utils.Network,
 ) (core.Transaction, core.Class, *felt.Felt, error) {
 	var feederTxn starknet.Transaction
 	if err := copier.Copy(&feederTxn, broadcastedTxn.Transaction); err != nil {
diff --git a/starknetdata/feeder/feeder_test.go b/starknetdata/feeder/feeder_test.go
index a00af607a5..5b3e0b3ec1 100644
--- a/starknetdata/feeder/feeder_test.go
+++ b/starknetdata/feeder/feeder_test.go
@@ -17,7 +17,7 @@ import (
 func TestBlockByNumber(t *testing.T) {
 	numbers := []uint64{147, 11817}
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	adapter := adaptfeeder.New(client)
 	ctx := context.Background()
 
@@ -37,7 +37,7 @@ func TestBlockByNumber(t *testing.T) {
 }
 
 func TestBlockLatest(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	adapter := adaptfeeder.New(client)
 	ctx := context.Background()
 
@@ -55,7 +55,7 @@ func TestBlockLatest(t *testing.T) {
 func TestStateUpdate(t *testing.T) {
 	numbers := []uint64{0, 1, 2, 21656}
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	adapter := adaptfeeder.New(client)
 	ctx := context.Background()
 
@@ -81,7 +81,7 @@ func TestClassV0(t *testing.T) {
 		"0x56b96c1d1bbfa01af44b465763d1b71150fa00c6c9d54c3947f57e979ff68c3",
 	}
 
-	client := feeder.NewTestClient(t, utils.Goerli)
+	client := feeder.NewTestClient(t, &utils.Goerli)
 	adapter := adaptfeeder.New(client)
 	ctx := context.Background()
 
@@ -101,10 +101,10 @@ func TestClassV0(t *testing.T) {
 }
 
 func TestTransaction(t *testing.T) {
-	clientGoerli := feeder.NewTestClient(t, utils.Goerli)
+	clientGoerli := feeder.NewTestClient(t, &utils.Goerli)
 	adapterGoerli := adaptfeeder.New(clientGoerli)
 
-	clientMainnet := feeder.NewTestClient(t, utils.Mainnet)
+	clientMainnet := feeder.NewTestClient(t, &utils.Mainnet)
 	adapterMainnet := adaptfeeder.New(clientMainnet)
 
 	ctx := context.Background()
@@ -176,7 +176,7 @@ func TestTransaction(t *testing.T) {
 }
 
 func TestClassV1(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	adapter := adaptfeeder.New(client)
 
 	classHash := utils.HexToFelt(t, "0x1cd2edfb485241c4403254d550de0a097fa76743cd30696f714a491a454bad5")
@@ -196,7 +196,7 @@ func TestClassV1(t *testing.T) {
 func TestStateUpdateWithBlock(t *testing.T) {
 	numbers := []uint64{0, 78541}
 
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	adapter := adaptfeeder.New(client)
 	ctx := context.Background()
 
@@ -219,7 +219,7 @@ func TestStateUpdateWithBlock(t *testing.T) {
 }
 
 func TestStateUpdatePendingWithBlock(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	adapter := adaptfeeder.New(client)
 	ctx := context.Background()
 
diff --git a/sync/sync_test.go b/sync/sync_test.go
index 0a33c3eb24..7812c6d574 100644
--- a/sync/sync_test.go
+++ b/sync/sync_test.go
@@ -29,7 +29,7 @@ func TestSyncBlocks(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 	testBlockchain := func(t *testing.T, bc *blockchain.Blockchain) {
 		t.Helper()
@@ -58,7 +58,7 @@ func TestSyncBlocks(t *testing.T) {
 	t.Run("sync multiple blocks in an empty db", func(t *testing.T) {
 		t.Parallel()
 		testDB := pebble.NewMemTest(t)
-		bc := blockchain.New(testDB, utils.Mainnet, log)
+		bc := blockchain.New(testDB, &utils.Mainnet, log)
 		synchronizer := sync.New(bc, gw, log, time.Duration(0), false)
 		ctx, cancel := context.WithTimeout(context.Background(), timeout)
 
@@ -71,7 +71,7 @@ func TestSyncBlocks(t *testing.T) {
 	t.Run("sync multiple blocks in a non-empty db", func(t *testing.T) {
 		t.Parallel()
 		testDB := pebble.NewMemTest(t)
-		bc := blockchain.New(testDB, utils.Mainnet, log)
+		bc := blockchain.New(testDB, &utils.Mainnet, log)
 		b0, err := gw.BlockByNumber(context.Background(), 0)
 		require.NoError(t, err)
 		s0, err := gw.StateUpdate(context.Background(), 0)
@@ -90,7 +90,7 @@ func TestSyncBlocks(t *testing.T) {
 	t.Run("sync multiple blocks, with an unreliable gw", func(t *testing.T) {
 		t.Parallel()
 		testDB := pebble.NewMemTest(t)
-		bc := blockchain.New(testDB, utils.Mainnet, log)
+		bc := blockchain.New(testDB, &utils.Mainnet, log)
 
 		mockSNData := mocks.NewMockStarknetData(mockCtrl)
 
@@ -143,16 +143,16 @@ func TestSyncBlocks(t *testing.T) {
 
 func TestReorg(t *testing.T) {
 	t.Parallel()
-	mainClient := feeder.NewTestClient(t, utils.Mainnet)
+	mainClient := feeder.NewTestClient(t, &utils.Mainnet)
 	mainGw := adaptfeeder.New(mainClient)
 
-	integClient := feeder.NewTestClient(t, utils.Integration)
+	integClient := feeder.NewTestClient(t, &utils.Integration)
 	integGw := adaptfeeder.New(integClient)
 
 	testDB := pebble.NewMemTest(t)
 
 	// sync to integration for 2 blocks
-	bc := blockchain.New(testDB, utils.Integration, utils.NewNopZapLogger())
+	bc := blockchain.New(testDB, &utils.Integration, utils.NewNopZapLogger())
 	synchronizer := sync.New(bc, integGw, utils.NewNopZapLogger(), time.Duration(0), false)
 
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -161,7 +161,7 @@ func TestReorg(t *testing.T) {
 
 	t.Run("resync to mainnet with the same db", func(t *testing.T) {
 		t.Parallel()
-		bc = blockchain.New(testDB, utils.Mainnet, utils.NewNopZapLogger())
+		bc = blockchain.New(testDB, &utils.Mainnet, utils.NewNopZapLogger())
 
 		// Ensure current head is Integration head
 		head, err := bc.HeadsHeader()
@@ -183,12 +183,12 @@ func TestReorg(t *testing.T) {
 func TestPending(t *testing.T) {
 	t.Parallel()
 
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 
 	testDB := pebble.NewMemTest(t)
 	log := utils.NewNopZapLogger()
-	bc := blockchain.New(testDB, utils.Mainnet, log)
+	bc := blockchain.New(testDB, &utils.Mainnet, log)
 	synchronizer := sync.New(bc, gw, log, time.Millisecond*100, false)
 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 
@@ -206,7 +206,7 @@ func TestSubscribeNewHeads(t *testing.T) {
 	t.Parallel()
 	testDB := pebble.NewMemTest(t)
 	log := utils.NewNopZapLogger()
-	integration := utils.Integration
+	integration := &utils.Integration
 	chain := blockchain.New(testDB, integration, log)
 	integrationClient := feeder.NewTestClient(t, integration)
 	gw := adaptfeeder.New(integrationClient)
diff --git a/utils/log_test.go b/utils/log_test.go
index 8df092325f..cbc3a1b376 100644
--- a/utils/log_test.go
+++ b/utils/log_test.go
@@ -28,8 +28,6 @@ func TestLogLevelString(t *testing.T) {
 // both implement the pflag.Value and encoding.TextUnmarshaller interfaces.
 // We can open a PR on github.com/thediveo/enumflag to add TextUnmarshaller
 // support.
-//
-//nolint:dupl
 func TestLogLevelSet(t *testing.T) {
 	for level, str := range levelStrings {
 		t.Run("level "+str, func(t *testing.T) {
diff --git a/utils/network.go b/utils/network.go
index b2f0126825..c1263456f3 100644
--- a/utils/network.go
+++ b/utils/network.go
@@ -8,52 +8,133 @@ import (
 	"math/big"
 
 	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/validator"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/libp2p/go-libp2p/core/protocol"
 	"github.com/spf13/pflag"
 )
 
-var ErrUnknownNetwork = errors.New("unknown network (known: mainnet, goerli, goerli2, integration)")
+var (
+	ErrUnknownNetwork             = errors.New("unknown network (known: mainnet, goerli, goerli2, integration, custom)")
+	ErrNetworkNoFallbackAddr      = errors.New("the FallBackSequencerAddress (felt) parameter must be set")
+	ErrNetworkUnverifRange        = errors.New("unverifiable_range must be a list of two uint64s")
+	ErrInvalidNetworkJSONStr      = errors.New("invalid network json string")
+	ErrMissingCoreContractAddress = errors.New("missing non-optional core contract address")
+)
+
+type Network struct {
+	Name                string             `json:"name" validate:"required"`
+	FeederURL           string             `json:"feeder_url" validate:"required"`
+	GatewayURL          string             `json:"gateway_url" validate:"required"`
+	ChainID             string             `json:"chain_id" validate:"required"`
+	L1ChainID           *big.Int           `json:"l1_chain_id" validate:"required"`
+	CoreContractAddress common.Address     `json:"core_contract_address" validate:"required"`
+	BlockHashMetaInfo   *blockHashMetaInfo `json:"block_hash_meta_info" validate:"required"`
+}
 
-type Network int
+type blockHashMetaInfo struct {
+	// The sequencer address to use for blocks that do not have one
+	FallBackSequencerAddress *felt.Felt `json:"fallback_sequencer_address" validate:"required"`
+	// First block that uses the post-0.7.0 block hash algorithm
+	First07Block uint64 `json:"first_07_block" validate:"required"`
+	// Range of blocks that are not verifiable
+	UnverifiableRange []uint64 `json:"unverifiable_range" validate:"required"`
+}
 
-// The following are necessary for Cobra and Viper, respectively, to unmarshal log level
-// CLI/config parameters properly.
 var (
+	fallBackSequencerAddressMainnet, _ = new(felt.Felt).SetString("0x021f4b90b0377c82bf330b7b5295820769e72d79d8acd0effa0ebde6e9988bc5")
+	fallBackSequencerAddress, _        = new(felt.Felt).SetString("0x046a89ae102987331d369645031b49c27738ed096f2789c24449966da4c6de6b")
+	// The following are necessary for Cobra and Viper, respectively, to unmarshal log level CLI/config parameters properly.
 	_ pflag.Value              = (*Network)(nil)
 	_ encoding.TextUnmarshaler = (*Network)(nil)
-)
 
-const (
-	Mainnet Network = iota + 1
-	Goerli
-	Goerli2
-	Integration
-	Sepolia
-	SepoliaIntegration
+	// The docs states the addresses for each network: https://docs.starknet.io/documentation/useful_info/
+	Mainnet = Network{
+		Name:                "mainnet",
+		FeederURL:           "https://alpha-mainnet.starknet.io/feeder_gateway",
+		GatewayURL:          "https://alpha-mainnet.starknet.io/gateway",
+		ChainID:             "SN_MAIN",
+		L1ChainID:           big.NewInt(1),
+		CoreContractAddress: common.HexToAddress("0xc662c410C0ECf747543f5bA90660f6ABeBD9C8c4"),
+		BlockHashMetaInfo: &blockHashMetaInfo{
+			First07Block:             833,
+			FallBackSequencerAddress: fallBackSequencerAddressMainnet,
+		},
+	}
+	Goerli = Network{
+		Name:       "goerli",
+		FeederURL:  "https://alpha4.starknet.io/feeder_gateway",
+		GatewayURL: "https://alpha4.starknet.io/gateway",
+		ChainID:    "SN_GOERLI",
+		//nolint:gomnd
+		L1ChainID:           big.NewInt(5),
+		CoreContractAddress: common.HexToAddress("0xde29d060D45901Fb19ED6C6e959EB22d8626708e"),
+		BlockHashMetaInfo: &blockHashMetaInfo{
+			First07Block:             47028,
+			UnverifiableRange:        []uint64{119802, 148428},
+			FallBackSequencerAddress: fallBackSequencerAddress,
+		},
+	}
+	Goerli2 = Network{
+		Name:       "goerli2",
+		FeederURL:  "https://alpha4-2.starknet.io/feeder_gateway",
+		GatewayURL: "https://alpha4-2.starknet.io/gateway",
+		ChainID:    "SN_GOERLI2",
+		//nolint:gomnd
+		L1ChainID:           big.NewInt(5),
+		CoreContractAddress: common.HexToAddress("0xa4eD3aD27c294565cB0DCc993BDdCC75432D498c"),
+		BlockHashMetaInfo: &blockHashMetaInfo{
+			First07Block:             0,
+			FallBackSequencerAddress: fallBackSequencerAddress,
+		},
+	}
+	Integration = Network{
+		Name:       "integration",
+		FeederURL:  "https://external.integration.starknet.io/feeder_gateway",
+		GatewayURL: "https://external.integration.starknet.io/gateway",
+		ChainID:    "SN_GOERLI",
+		//nolint:gomnd
+		L1ChainID:           big.NewInt(5),
+		CoreContractAddress: common.HexToAddress("0xd5c325D183C592C94998000C5e0EED9e6655c020"),
+		BlockHashMetaInfo: &blockHashMetaInfo{
+			First07Block:             110511,
+			UnverifiableRange:        []uint64{0, 110511},
+			FallBackSequencerAddress: fallBackSequencerAddress,
+		},
+	}
+	Sepolia = Network{
+		Name:       "sepolia",
+		FeederURL:  "https://alpha-sepolia.starknet.io/feeder_gateway",
+		GatewayURL: "https://alpha-sepolia.starknet.io/gateway",
+		ChainID:    "SN_SEPOLIA",
+		//nolint:gomnd
+		L1ChainID:           big.NewInt(11155111),
+		CoreContractAddress: common.HexToAddress("0xE2Bb56ee936fd6433DC0F6e7e3b8365C906AA057"),
+		BlockHashMetaInfo: &blockHashMetaInfo{
+			First07Block:             0,
+			FallBackSequencerAddress: fallBackSequencerAddress,
+		},
+	}
+	SepoliaIntegration = Network{
+		Name:       "sepolia-integration",
+		FeederURL:  "https://integration-sepolia.starknet.io/feeder_gateway",
+		GatewayURL: "https://integration-sepolia.starknet.io/gateway",
+		ChainID:    "SN_INTEGRATION_SEPOLIA",
+		//nolint:gomnd
+		L1ChainID:           big.NewInt(11155111),
+		CoreContractAddress: common.HexToAddress("0x4737c0c1B4D5b1A687B42610DdabEE781152359c"),
+		BlockHashMetaInfo: &blockHashMetaInfo{
+			First07Block:             0,
+			FallBackSequencerAddress: fallBackSequencerAddress,
+		},
+	}
 )
 
-func (n Network) String() string {
-	switch n {
-	case Mainnet:
-		return "mainnet"
-	case Goerli:
-		return "goerli"
-	case Goerli2:
-		return "goerli2"
-	case Integration:
-		return "integration"
-	case Sepolia:
-		return "sepolia"
-	case SepoliaIntegration:
-		return "sepolia-integration"
-	default:
-		// Should not happen.
-		panic(ErrUnknownNetwork)
-	}
+func (n *Network) String() string {
+	return n.Name
 }
 
-func (n Network) MarshalYAML() (interface{}, error) {
+func (n *Network) MarshalYAML() (interface{}, error) {
 	return n.String(), nil
 }
 
@@ -62,125 +143,82 @@ func (n *Network) MarshalJSON() ([]byte, error) {
 }
 
 func (n *Network) Set(s string) error {
-	switch s {
-	case "MAINNET", "mainnet":
-		*n = Mainnet
-	case "GOERLI", "goerli":
-		*n = Goerli
-	case "GOERLI2", "goerli2":
-		*n = Goerli2
-	case "INTEGRATION", "integration":
-		*n = Integration
-	case "SEPOLIA", "sepolia":
-		*n = Sepolia
-	case "SEPOLIA_INTEGRATION", "sepolia-integration":
-		*n = SepoliaIntegration
-	default:
-		return ErrUnknownNetwork
+	predefinedNetworks := map[string]Network{
+		"MAINNET":             Mainnet,
+		"mainnet":             Mainnet,
+		"GOERLI":              Goerli,
+		"goerli":              Goerli,
+		"GOERLI2":             Goerli2,
+		"goerli2":             Goerli2,
+		"INTEGRATION":         Integration,
+		"integration":         Integration,
+		"SEPOLIA":             Sepolia,
+		"sepolia":             Sepolia,
+		"SEPOLIA-INTEGRATION": SepoliaIntegration,
+		"sepolia-integration": SepoliaIntegration,
 	}
-	return nil
-}
-
-func (n *Network) Type() string {
-	return "Network"
-}
 
-func (n *Network) UnmarshalText(text []byte) error {
-	return n.Set(string(text))
+	if network, ok := predefinedNetworks[s]; ok {
+		*n = network
+		return nil
+	}
+	return n.setCustomNetwork(s)
 }
 
-// baseURL returns the base URL without endpoint
-func (n Network) baseURL() string {
-	switch n {
-	case Goerli:
-		return "https://alpha4.starknet.io/"
-	case Mainnet:
-		return "https://alpha-mainnet.starknet.io/"
-	case Goerli2:
-		return "https://alpha4-2.starknet.io/"
-	case Integration:
-		return "https://external.integration.starknet.io/"
-	case Sepolia:
-		return "https://alpha-sepolia.starknet.io/"
-	case SepoliaIntegration:
-		return "https://integration-sepolia.starknet.io/"
-	default:
-		// Should not happen.
-		panic(ErrUnknownNetwork)
+// setCustomNetwork tries to unmarshal the json string and performs some basic validation checks
+func (n *Network) setCustomNetwork(s string) error {
+	*n = Network{}
+	if err := n.UnmarshalJSON([]byte(s)); err != nil {
+		return fmt.Errorf("%w: %s", ErrInvalidNetworkJSONStr, err)
+	}
+	if !(n.ChainID == "CUSTOM" || n.Name == "custom") {
+		return ErrUnknownNetwork
+	}
+	if n.CoreContractAddress == (common.Address{}) {
+		return ErrMissingCoreContractAddress
 	}
+	if len(n.BlockHashMetaInfo.UnverifiableRange) != 2 {
+		return ErrNetworkUnverifRange
+	}
+	return nil
 }
 
-// FeederURL returns URL for read commands
-func (n Network) FeederURL() string {
-	return n.baseURL() + "feeder_gateway/"
+func (n *Network) UnmarshalJSON(data []byte) error {
+	type Alias Network
+	aux := &struct {
+		CoreContractAddress string `json:"core_contract_address"`
+		*Alias
+	}{
+		Alias: (*Alias)(n),
+	}
+	if err := json.Unmarshal(data, &aux); err != nil {
+		return err
+	}
+	n.CoreContractAddress = common.HexToAddress(aux.CoreContractAddress)
+	return nil
 }
 
-// GatewayURL returns URL for write commands
-func (n Network) GatewayURL() string {
-	return n.baseURL() + "gateway/"
+func (n *Network) Validate() error {
+	validate := validator.Validator()
+	return validate.Struct(n)
 }
 
-func (n Network) ChainIDString() string {
-	switch n {
-	case Goerli, Integration:
-		return "SN_GOERLI"
-	case Mainnet:
-		return "SN_MAIN"
-	case Goerli2:
-		return "SN_GOERLI2"
-	case Sepolia:
-		return "SN_SEPOLIA"
-	case SepoliaIntegration:
-		return "SN_INTEGRATION_SEPOLIA"
-	default:
-		// Should not happen.
-		panic(ErrUnknownNetwork)
-	}
+func (n *Network) Type() string {
+	return "Network"
 }
 
-func (n Network) DefaultL1ChainID() *big.Int {
-	var chainID int64
-	switch n {
-	case Mainnet:
-		chainID = 1
-	case Goerli, Goerli2, Integration:
-		chainID = 5
-	case Sepolia, SepoliaIntegration:
-		chainID = 11155111
-	default:
-		// Should not happen.
-		panic(ErrUnknownNetwork)
-	}
-	return big.NewInt(chainID)
+func (n *Network) UnmarshalText(text []byte) error {
+	return n.Set(string(text))
 }
 
-func (n Network) CoreContractAddress() (common.Address, error) {
-	var address common.Address
-	// The docs states the addresses for each network: https://docs.starknet.io/documentation/useful_info/
-	switch n {
-	case Mainnet:
-		address = common.HexToAddress("0xc662c410C0ECf747543f5bA90660f6ABeBD9C8c4")
-	case Goerli:
-		address = common.HexToAddress("0xde29d060D45901Fb19ED6C6e959EB22d8626708e")
-	case Goerli2:
-		address = common.HexToAddress("0xa4eD3aD27c294565cB0DCc993BDdCC75432D498c")
-	case Integration:
-		address = common.HexToAddress("0xd5c325D183C592C94998000C5e0EED9e6655c020")
-	case Sepolia:
-		return common.HexToAddress("0xE2Bb56ee936fd6433DC0F6e7e3b8365C906AA057"), nil
-	case SepoliaIntegration:
-		return common.HexToAddress("0x4737c0c1B4D5b1A687B42610DdabEE781152359c"), nil
-	default:
-		// Should not happen.
-		return common.Address{}, ErrUnknownNetwork
-	}
-	return address, nil
+func (n *Network) ChainIDFelt() *felt.Felt {
+	return new(felt.Felt).SetBytes([]byte(n.ChainID))
 }
 
-func (n Network) ChainID() *felt.Felt {
-	return new(felt.Felt).SetBytes([]byte(n.ChainIDString()))
+func (n *Network) ProtocolID() protocol.ID {
+	return protocol.ID(fmt.Sprintf("/starknet/%s", n))
 }
 
-func (n Network) ProtocolID() protocol.ID {
-	return protocol.ID(fmt.Sprintf("/starknet/%s", n))
+func (n *Network) MetaInfo() *blockHashMetaInfo {
+	return n.BlockHashMetaInfo
 }
diff --git a/utils/network_test.go b/utils/network_test.go
index c53bd23a16..0a58b4336b 100644
--- a/utils/network_test.go
+++ b/utils/network_test.go
@@ -1,6 +1,7 @@
 package utils_test
 
 import (
+	"fmt"
 	"math/big"
 	"strings"
 	"testing"
@@ -12,11 +13,13 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-var networkStrings = map[utils.Network]string{
-	utils.Mainnet:     "mainnet",
-	utils.Goerli:      "goerli",
-	utils.Goerli2:     "goerli2",
-	utils.Integration: "integration",
+var networkStrings = map[*utils.Network]string{
+	&utils.Mainnet:            "mainnet",
+	&utils.Goerli:             "goerli",
+	&utils.Goerli2:            "goerli2",
+	&utils.Integration:        "integration",
+	&utils.Sepolia:            "sepolia",
+	&utils.SepoliaIntegration: "sepolia-integration",
 }
 
 func TestNetwork(t *testing.T) {
@@ -25,31 +28,42 @@ func TestNetwork(t *testing.T) {
 			assert.Equal(t, str, network.String())
 		}
 	})
-	t.Run("url", func(t *testing.T) {
-		for n := range networkStrings {
-			switch n {
-			case utils.Goerli:
-				assert.Equal(t, "https://alpha4.starknet.io/feeder_gateway/", n.FeederURL())
-			case utils.Mainnet:
-				assert.Equal(t, "https://alpha-mainnet.starknet.io/feeder_gateway/", n.FeederURL())
-			case utils.Goerli2:
-				assert.Equal(t, "https://alpha4-2.starknet.io/feeder_gateway/", n.FeederURL())
-			case utils.Integration:
-				assert.Equal(t, "https://external.integration.starknet.io/feeder_gateway/", n.FeederURL())
-			default:
-				assert.Fail(t, "unexpected network")
-			}
+
+	t.Run("feeder and gateway url", func(t *testing.T) {
+		testCases := []struct {
+			network    utils.Network
+			feederURL  string
+			gatewayURL string
+		}{
+			{utils.Mainnet, "https://alpha-mainnet.starknet.io/feeder_gateway", "https://alpha-mainnet.starknet.io/gateway"},
+			{utils.Goerli, "https://alpha4.starknet.io/feeder_gateway", "https://alpha4.starknet.io/gateway"},
+			{utils.Goerli2, "https://alpha4-2.starknet.io/feeder_gateway", "https://alpha4-2.starknet.io/gateway"},
+			{utils.Integration, "https://external.integration.starknet.io/feeder_gateway", "https://external.integration.starknet.io/gateway"},
+			{utils.Sepolia, "https://alpha-sepolia.starknet.io/feeder_gateway", "https://alpha-sepolia.starknet.io/gateway"},
+			{utils.SepoliaIntegration, "https://integration-sepolia.starknet.io/feeder_gateway", "https://integration-sepolia.starknet.io/gateway"},
+		}
+
+		for _, tc := range testCases {
+			t.Run(fmt.Sprintf("Network %v", tc.network), func(t *testing.T) {
+				assert.Equal(t, tc.feederURL, tc.network.FeederURL)
+				assert.Equal(t, tc.gatewayURL, tc.network.GatewayURL)
+			})
 		}
 	})
+
 	t.Run("chainId", func(t *testing.T) {
 		for n := range networkStrings {
 			switch n {
-			case utils.Goerli, utils.Integration:
-				assert.Equal(t, new(felt.Felt).SetBytes([]byte("SN_GOERLI")), n.ChainID())
-			case utils.Mainnet:
-				assert.Equal(t, new(felt.Felt).SetBytes([]byte("SN_MAIN")), n.ChainID())
-			case utils.Goerli2:
-				assert.Equal(t, new(felt.Felt).SetBytes([]byte("SN_GOERLI2")), n.ChainID())
+			case &utils.Goerli, &utils.Integration:
+				assert.Equal(t, new(felt.Felt).SetBytes([]byte("SN_GOERLI")), n.ChainIDFelt())
+			case &utils.Mainnet:
+				assert.Equal(t, new(felt.Felt).SetBytes([]byte("SN_MAIN")), n.ChainIDFelt())
+			case &utils.Goerli2:
+				assert.Equal(t, new(felt.Felt).SetBytes([]byte("SN_GOERLI2")), n.ChainIDFelt())
+			case &utils.Sepolia:
+				assert.Equal(t, new(felt.Felt).SetBytes([]byte("SN_SEPOLIA")), n.ChainIDFelt())
+			case &utils.SepoliaIntegration:
+				assert.Equal(t, new(felt.Felt).SetBytes([]byte("SN_INTEGRATION_SEPOLIA")), n.ChainIDFelt())
 			default:
 				assert.Fail(t, "unexpected network")
 			}
@@ -57,12 +71,14 @@ func TestNetwork(t *testing.T) {
 	})
 	t.Run("default L1 chainId", func(t *testing.T) {
 		for n := range networkStrings {
-			got := n.DefaultL1ChainID()
+			got := n.L1ChainID
 			switch n {
-			case utils.Mainnet:
+			case &utils.Mainnet:
 				assert.Equal(t, big.NewInt(1), got)
-			case utils.Goerli, utils.Goerli2, utils.Integration:
+			case &utils.Goerli, &utils.Goerli2, &utils.Integration:
 				assert.Equal(t, big.NewInt(5), got)
+			case &utils.Sepolia, &utils.SepoliaIntegration:
+				assert.Equal(t, big.NewInt(11155111), got)
 			default:
 				assert.Fail(t, "unexpected network")
 			}
@@ -70,25 +86,82 @@ func TestNetwork(t *testing.T) {
 	})
 }
 
-//nolint:dupl // see comment in utils/log_test.go
 func TestNetworkSet(t *testing.T) {
 	for network, str := range networkStrings {
 		t.Run("network "+str, func(t *testing.T) {
 			n := new(utils.Network)
 			require.NoError(t, n.Set(str))
-			assert.Equal(t, network, *n)
+			assert.Equal(t, network, n)
 		})
 		uppercase := strings.ToUpper(str)
 		t.Run("network "+uppercase, func(t *testing.T) {
 			n := new(utils.Network)
 			require.NoError(t, n.Set(uppercase))
-			assert.Equal(t, network, *n)
+			assert.Equal(t, network, n)
 		})
 	}
 
-	t.Run("unknown network", func(t *testing.T) {
+	t.Run("custom network - success", func(t *testing.T) {
 		n := new(utils.Network)
-		require.ErrorIs(t, n.Set("blah"), utils.ErrUnknownNetwork)
+		networkJSON := `{
+				"name": "custom",
+				"feeder_url": "baseURL/feeder_gateway/",
+				"gateway_url": "baseURL/gateway",
+				"chain_id": "SN_CUSTOM",
+				"l1_chain_id": 123,
+				"core_contract_address": "0x1",
+				"block_hash_meta_info": {
+					"first_07_block": 1,
+					"unverifiable_range": [2, 3],
+					"fallback_sequencer_address": "0x0"
+				}
+		}`
+
+		require.NoError(t, n.Set(networkJSON))
+		assert.Equal(t, "custom", n.String())
+		assert.Equal(t, "baseURL/feeder_gateway/", n.FeederURL)
+		assert.Equal(t, "SN_CUSTOM", n.ChainID)
+		assert.Equal(t, "0x0", n.MetaInfo().FallBackSequencerAddress.String())
+		assert.Equal(t, uint64(1), n.MetaInfo().First07Block)
+		assert.Equal(t, []uint64{2, 3}, n.MetaInfo().UnverifiableRange)
+	})
+	t.Run("fail - invalid json input", func(t *testing.T) {
+		n := new(utils.Network)
+		networkJSON := `some invalid json`
+		require.ErrorIs(t, n.Set(networkJSON), utils.ErrInvalidNetworkJSONStr)
+	})
+	t.Run("fail - unknown network", func(t *testing.T) {
+		n := new(utils.Network)
+		networkJSON := `{
+				"name": "typo"
+		}`
+		require.ErrorIs(t, n.Set(networkJSON), utils.ErrUnknownNetwork)
+	})
+
+	t.Run("fail - ErrMissingCoreContractAddress", func(t *testing.T) {
+		n := new(utils.Network)
+		networkJSON := `{
+			"name": "custom"
+	}`
+		require.ErrorIs(t, n.Set(networkJSON), utils.ErrMissingCoreContractAddress)
+	})
+	t.Run("fail - validate", func(t *testing.T) {
+		n := new(utils.Network)
+		networkJSON := `{
+			"name": "custom",
+			"feeder_url": "baseURL/feeder_gateway/",
+			"gateway_url": "baseURL/gateway",
+			"chain_id": "SN_CUSTOM",
+			"l1_chain_id": 123,
+			"core_contract_address": "0x1",
+			"block_hash_meta_info": {
+				"first_07_block": 1,
+				"unverifiable_range": [2, 3]
+			}
+	}`
+
+		require.Nil(t, n.Set(networkJSON))
+		require.NotNil(t, n.Validate())
 	})
 }
 
@@ -97,19 +170,19 @@ func TestNetworkUnmarshalText(t *testing.T) {
 		t.Run("network "+str, func(t *testing.T) {
 			n := new(utils.Network)
 			require.NoError(t, n.UnmarshalText([]byte(str)))
-			assert.Equal(t, network, *n)
+			assert.Equal(t, network, n)
 		})
 		uppercase := strings.ToUpper(str)
 		t.Run("network "+uppercase, func(t *testing.T) {
 			n := new(utils.Network)
 			require.NoError(t, n.UnmarshalText([]byte(uppercase)))
-			assert.Equal(t, network, *n)
+			assert.Equal(t, network, n)
 		})
 	}
 
 	t.Run("unknown network", func(t *testing.T) {
 		l := new(utils.Network)
-		require.ErrorIs(t, l.UnmarshalText([]byte("blah")), utils.ErrUnknownNetwork)
+		require.ErrorIs(t, l.UnmarshalText([]byte("blah")), utils.ErrInvalidNetworkJSONStr)
 	})
 }
 
@@ -130,19 +203,19 @@ func TestNetworkType(t *testing.T) {
 }
 
 func TestCoreContractAddress(t *testing.T) {
-	addresses := map[utils.Network]common.Address{
-		utils.Mainnet:     common.HexToAddress("0xc662c410C0ECf747543f5bA90660f6ABeBD9C8c4"),
-		utils.Goerli:      common.HexToAddress("0xde29d060D45901Fb19ED6C6e959EB22d8626708e"),
-		utils.Goerli2:     common.HexToAddress("0xa4eD3aD27c294565cB0DCc993BDdCC75432D498c"),
-		utils.Integration: common.HexToAddress("0xd5c325D183C592C94998000C5e0EED9e6655c020"),
+	addresses := map[*utils.Network]common.Address{
+		&utils.Mainnet:            common.HexToAddress("0xc662c410C0ECf747543f5bA90660f6ABeBD9C8c4"),
+		&utils.Goerli:             common.HexToAddress("0xde29d060D45901Fb19ED6C6e959EB22d8626708e"),
+		&utils.Goerli2:            common.HexToAddress("0xa4eD3aD27c294565cB0DCc993BDdCC75432D498c"),
+		&utils.Integration:        common.HexToAddress("0xd5c325D183C592C94998000C5e0EED9e6655c020"),
+		&utils.Sepolia:            common.HexToAddress("0xE2Bb56ee936fd6433DC0F6e7e3b8365C906AA057"),
+		&utils.SepoliaIntegration: common.HexToAddress("0x4737c0c1B4D5b1A687B42610DdabEE781152359c"),
 	}
 
 	for n := range networkStrings {
 		t.Run("core contract for "+n.String(), func(t *testing.T) {
-			got, err := n.CoreContractAddress()
-			require.NoError(t, err)
 			want := addresses[n]
-			assert.Equal(t, want, got)
+			assert.Equal(t, want, n.CoreContractAddress)
 		})
 	}
 }
diff --git a/validator/validator.go b/validator/validator.go
index 985e1fe251..ec2d5fea1a 100644
--- a/validator/validator.go
+++ b/validator/validator.go
@@ -5,7 +5,6 @@ import (
 	"sync"
 
 	"github.com/NethermindEth/juno/core/felt"
-	"github.com/NethermindEth/juno/rpc"
 	"github.com/go-playground/validator/v10"
 )
 
@@ -30,11 +29,40 @@ func Validator() *validator.Validate {
 			panic("not a felt")
 		}, felt.Felt{}, &felt.Felt{})
 		v.RegisterCustomTypeFunc(func(field reflect.Value) any {
-			if t, ok := field.Interface().(rpc.TransactionType); ok {
+			if t, ok := field.Interface().(TransactionType); ok {
 				return t.String()
 			}
 			panic("not a TransactionType")
-		}, rpc.TransactionType(0))
+		}, TransactionType(0))
 	})
 	return v
 }
+
+// TransactionType is duplicated here to prevent import cycles
+type TransactionType uint8
+
+const (
+	Invalid TransactionType = iota
+	TxnDeclare
+	TxnDeploy
+	TxnDeployAccount
+	TxnInvoke
+	TxnL1Handler
+)
+
+func (t TransactionType) String() string {
+	switch t {
+	case TxnDeclare:
+		return "DECLARE"
+	case TxnDeploy:
+		return "DEPLOY"
+	case TxnDeployAccount:
+		return "DEPLOY_ACCOUNT"
+	case TxnInvoke:
+		return "INVOKE"
+	case TxnL1Handler:
+		return "L1_HANDLER"
+	default:
+		return "<unknown>"
+	}
+}
diff --git a/vm/transaction_pkg_test.go b/vm/transaction_pkg_test.go
index cff7a58bb8..a6dfe7f29e 100644
--- a/vm/transaction_pkg_test.go
+++ b/vm/transaction_pkg_test.go
@@ -13,7 +13,7 @@ import (
 )
 
 func TestTransactionMarshal(t *testing.T) {
-	client := feeder.NewTestClient(t, utils.Integration)
+	client := feeder.NewTestClient(t, &utils.Integration)
 	gw := adaptfeeder.New(client)
 
 	tests := map[string]struct {
diff --git a/vm/vm.go b/vm/vm.go
index e14becddbb..40f68dd98b 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -30,10 +30,10 @@ import (
 //go:generate mockgen -destination=../mocks/mock_vm.go -package=mocks github.com/NethermindEth/juno/vm VM
 type VM interface {
 	Call(contractAddr, classHash, selector *felt.Felt, calldata []felt.Felt, blockNumber,
-		blockTimestamp uint64, state core.StateReader, network utils.Network,
+		blockTimestamp uint64, state core.StateReader, network *utils.Network,
 	) ([]*felt.Felt, error)
 	Execute(txns []core.Transaction, declaredClasses []core.Class, blockNumber, blockTimestamp uint64,
-		sequencerAddress *felt.Felt, state core.StateReader, network utils.Network, paidFeesOnL1 []*felt.Felt,
+		sequencerAddress *felt.Felt, state core.StateReader, network *utils.Network, paidFeesOnL1 []*felt.Felt,
 		skipChargeFee, skipValidate, errOnRevert bool, gasPriceWEI *felt.Felt, gasPriceSTRK *felt.Felt, legacyTraceJSON bool,
 	) ([]*felt.Felt, []json.RawMessage, error)
 }
@@ -110,7 +110,7 @@ func makePtrFromFelt(val *felt.Felt) unsafe.Pointer {
 }
 
 func (v *vm) Call(contractAddr, classHash, selector *felt.Felt, calldata []felt.Felt, blockNumber,
-	blockTimestamp uint64, state core.StateReader, network utils.Network,
+	blockTimestamp uint64, state core.StateReader, network *utils.Network,
 ) ([]*felt.Felt, error) {
 	context := &callContext{
 		state:    state,
@@ -138,7 +138,7 @@ func (v *vm) Call(contractAddr, classHash, selector *felt.Felt, calldata []felt.
 		classHashBytes := classHash.Bytes()
 		classHashPtr = &classHashBytes[0]
 	}
-	chainID := C.CString(network.ChainIDString())
+	chainID := C.CString(network.ChainID)
 	C.cairoVMCall((*C.char)(unsafe.Pointer(&addrBytes[0])),
 		(*C.char)(unsafe.Pointer(classHashPtr)),
 		(*C.char)(unsafe.Pointer(&selectorBytes[0])),
@@ -163,7 +163,7 @@ func (v *vm) Call(contractAddr, classHash, selector *felt.Felt, calldata []felt.
 
 // Execute executes a given transaction set and returns the gas spent per transaction
 func (v *vm) Execute(txns []core.Transaction, declaredClasses []core.Class, blockNumber, blockTimestamp uint64,
-	sequencerAddress *felt.Felt, state core.StateReader, network utils.Network, paidFeesOnL1 []*felt.Felt,
+	sequencerAddress *felt.Felt, state core.StateReader, network *utils.Network, paidFeesOnL1 []*felt.Felt,
 	skipChargeFee, skipValidate, errOnRevert bool, gasPriceWEI *felt.Felt, gasPriceSTRK *felt.Felt, legacyTraceJSON bool,
 ) ([]*felt.Felt, []json.RawMessage, error) {
 	context := &callContext{
@@ -214,7 +214,7 @@ func (v *vm) Execute(txns []core.Transaction, declaredClasses []core.Class, bloc
 		legacyTraceJSONByte = 1
 	}
 
-	chainID := C.CString(network.ChainIDString())
+	chainID := C.CString(network.ChainID)
 	C.cairoVMExecute(txnsJSONCstr,
 		classesJSONCStr,
 		C.uintptr_t(handle),
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 6d9b2d4570..f05ea0404a 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -20,7 +20,7 @@ func TestV0Call(t *testing.T) {
 	testDB := pebble.NewMemTest(t)
 	txn, err := testDB.NewTransaction(true)
 	require.NoError(t, err)
-	client := feeder.NewTestClient(t, utils.Mainnet)
+	client := feeder.NewTestClient(t, &utils.Mainnet)
 	gw := adaptfeeder.New(client)
 	t.Cleanup(func() {
 		require.NoError(t, txn.Discard())
@@ -48,7 +48,7 @@ func TestV0Call(t *testing.T) {
 	}))
 
 	entryPoint := utils.HexToFelt(t, "0x39e11d48192e4333233c7eb19d10ad67c362bb28580c604d67884c85da39695")
-	ret, err := New(nil).Call(contractAddr, classHash, entryPoint, nil, 0, 0, testState, utils.Mainnet)
+	ret, err := New(nil).Call(contractAddr, classHash, entryPoint, nil, 0, 0, testState, &utils.Mainnet)
 	require.NoError(t, err)
 	assert.Equal(t, []*felt.Felt{&felt.Zero}, ret)
 
@@ -64,7 +64,7 @@ func TestV0Call(t *testing.T) {
 		},
 	}, nil))
 
-	ret, err = New(nil).Call(contractAddr, classHash, entryPoint, nil, 1, 0, testState, utils.Mainnet)
+	ret, err = New(nil).Call(contractAddr, classHash, entryPoint, nil, 1, 0, testState, &utils.Mainnet)
 	require.NoError(t, err)
 	assert.Equal(t, []*felt.Felt{new(felt.Felt).SetUint64(1337)}, ret)
 }
@@ -73,7 +73,7 @@ func TestV1Call(t *testing.T) {
 	testDB := pebble.NewMemTest(t)
 	txn, err := testDB.NewTransaction(true)
 	require.NoError(t, err)
-	client := feeder.NewTestClient(t, utils.Goerli)
+	client := feeder.NewTestClient(t, &utils.Goerli)
 	gw := adaptfeeder.New(client)
 	t.Cleanup(func() {
 		require.NoError(t, txn.Discard())
@@ -105,7 +105,7 @@ func TestV1Call(t *testing.T) {
 	storageLocation := utils.HexToFelt(t, "0x44")
 	ret, err := New(nil).Call(contractAddr, nil, entryPoint, []felt.Felt{
 		*storageLocation,
-	}, 0, 0, testState, utils.Goerli)
+	}, 0, 0, testState, &utils.Goerli)
 	require.NoError(t, err)
 	assert.Equal(t, []*felt.Felt{&felt.Zero}, ret)
 
@@ -123,13 +123,13 @@ func TestV1Call(t *testing.T) {
 
 	ret, err = New(nil).Call(contractAddr, nil, entryPoint, []felt.Felt{
 		*storageLocation,
-	}, 1, 0, testState, utils.Goerli)
+	}, 1, 0, testState, &utils.Goerli)
 	require.NoError(t, err)
 	assert.Equal(t, []*felt.Felt{new(felt.Felt).SetUint64(37)}, ret)
 }
 
 func TestExecute(t *testing.T) {
-	const network = utils.Goerli2
+	network := utils.Goerli2
 
 	testDB := pebble.NewMemTest(t)
 	txn, err := testDB.NewTransaction(false)
@@ -146,11 +146,11 @@ func TestExecute(t *testing.T) {
 			address   = utils.HexToFelt(t, "0x46a89ae102987331d369645031b49c27738ed096f2789c24449966da4c6de6b")
 			timestamp = uint64(1666877926)
 		)
-		_, _, err := New(nil).Execute([]core.Transaction{}, []core.Class{}, 0, timestamp, address, state, network, []*felt.Felt{}, false, false, false, &felt.Zero, &felt.Zero, false)
+		_, _, err := New(nil).Execute([]core.Transaction{}, []core.Class{}, 0, timestamp, address, state, &network, []*felt.Felt{}, false, false, false, &felt.Zero, &felt.Zero, false)
 		require.NoError(t, err)
 	})
 	t.Run("zero data", func(t *testing.T) {
-		_, _, err := New(nil).Execute(nil, nil, 0, 0, &felt.Zero, state, network, []*felt.Felt{}, false, false, false, &felt.Zero, &felt.Zero, false)
+		_, _, err := New(nil).Execute(nil, nil, 0, 0, &felt.Zero, state, &network, []*felt.Felt{}, false, false, false, &felt.Zero, &felt.Zero, false)
 		require.NoError(t, err)
 	})
 }