diff --git a/actors/account/account_test.go b/actors/account/account_test.go
index ff9925a..28136df 100644
--- a/actors/account/account_test.go
+++ b/actors/account/account_test.go
@@ -20,8 +20,11 @@ var expectedData []byte
 var expected map[string]any
 var lib *rosettaFilecoinLib.RosettaConstructionFilecoin
 
+var network string
+
 func TestMain(m *testing.M) {
 	var err error
+	network = "mainnet"
 	lib, err = tools.GetLib(tools.NodeUrl)
 	if err != nil {
 		panic(err)
@@ -35,7 +38,7 @@ func TestMain(m *testing.M) {
 }
 
 func TestAuthenticateMessage(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("AuthenticateMessage", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "AuthenticateMessage", expected)
 	require.NoError(t, err)
 	for _, tt := range tests {
 		t.Run(tt.Name, func(t *testing.T) {
@@ -55,7 +58,7 @@ func TestAuthenticateMessage(t *testing.T) {
 }
 
 func TestPubkeyAddress(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("PubkeyAddress", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "PubkeyAddress", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/cron/cron_test.go b/actors/cron/cron_test.go
index 17877da..646fb58 100644
--- a/actors/cron/cron_test.go
+++ b/actors/cron/cron_test.go
@@ -14,8 +14,10 @@ import (
 //go:embed expected.json
 var expectedData []byte
 var expected map[string]any
+var network string
 
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -25,7 +27,7 @@ func TestMain(m *testing.M) {
 type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error)
 
 func TestCronConstructor(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("CronConstructor", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "CronConstructor", expected)
 	require.NoError(t, err)
 	runTest(t, cron.CronConstructor, tests)
 }
diff --git a/actors/datacap/allowance_test.go b/actors/datacap/allowance_test.go
index 5debae1..896b03d 100644
--- a/actors/datacap/allowance_test.go
+++ b/actors/datacap/allowance_test.go
@@ -13,28 +13,28 @@ import (
 type testFn func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error)
 
 func TestIncreaseAllowance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("IncreaseAllowance", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "IncreaseAllowance", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.IncreaseAllowance, tests)
 }
 
 func TestDecreaseAllowance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("DecreaseAllowance", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "DecreaseAllowance", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.DecreaseAllowance, tests)
 }
 
 func TestRevokeAllowance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("RevokeAllowance", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "RevokeAllowance", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.RevokeAllowance, tests)
 }
 
 func TestGetAllowance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetAllowance", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetAllowance", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.GetAllowance, tests)
diff --git a/actors/datacap/burn_test.go b/actors/datacap/burn_test.go
index c03d077..a78344d 100644
--- a/actors/datacap/burn_test.go
+++ b/actors/datacap/burn_test.go
@@ -9,21 +9,21 @@ import (
 )
 
 func TestBurnExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("BurnExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "BurnExported", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.BurnExported, tests)
 }
 
 func TestBurnFromExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("BurnFromExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "BurnFromExported", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.BurnFromExported, tests)
 }
 
 func TestDestroyExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("DestroyExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "DestroyExported", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.DestroyExported, tests)
diff --git a/actors/datacap/datacap_test.go b/actors/datacap/datacap_test.go
index 2d4b65e..404b22c 100644
--- a/actors/datacap/datacap_test.go
+++ b/actors/datacap/datacap_test.go
@@ -16,7 +16,10 @@ import (
 var expectedData []byte
 var expected map[string]any
 
+var network string
+
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -24,21 +27,21 @@ func TestMain(m *testing.M) {
 }
 
 func TestNameExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("NameExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "NameExported", expected)
 	require.NoError(t, err)
 
 	runDatacapTest(t, datacap.NameExported, tests)
 }
 
 func TestSymbolExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("SymbolExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "SymbolExported", expected)
 	require.NoError(t, err)
 
 	runDatacapTest(t, datacap.SymbolExported, tests)
 }
 
 func TestTotalSupplyExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("TotalSupplyExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "TotalSupplyExported", expected)
 	require.NoError(t, err)
 
 	runDatacapTest(t, datacap.TotalSupplyExported, tests)
diff --git a/actors/datacap/granularity_test.go b/actors/datacap/granularity_test.go
index ce65a1c..28c8b9e 100644
--- a/actors/datacap/granularity_test.go
+++ b/actors/datacap/granularity_test.go
@@ -10,7 +10,7 @@ import (
 )
 
 func TestGranularityExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GranularityExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GranularityExported", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/datacap/mint_test.go b/actors/datacap/mint_test.go
index 79cb223..abc07a3 100644
--- a/actors/datacap/mint_test.go
+++ b/actors/datacap/mint_test.go
@@ -9,7 +9,7 @@ import (
 )
 
 func TestMintExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("MintExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "MintExported", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.MintExported, tests)
diff --git a/actors/datacap/transfer_test.go b/actors/datacap/transfer_test.go
index d1be591..6d37242 100644
--- a/actors/datacap/transfer_test.go
+++ b/actors/datacap/transfer_test.go
@@ -9,7 +9,7 @@ import (
 )
 
 func TestTransferExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("TransferExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "TransferExported", expected)
 	require.NoError(t, err)
 
 	runTest(t, datacap.TransferExported, tests)
diff --git a/actors/eam/create_test.go b/actors/eam/create_test.go
index edc2bde..97aad8d 100644
--- a/actors/eam/create_test.go
+++ b/actors/eam/create_test.go
@@ -14,11 +14,14 @@ import (
 	"github.com/zondax/fil-parser/types"
 )
 
+var network string
+
 //go:embed expected.json
 var expectedData []byte
 var expected map[string]any
 
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -28,21 +31,21 @@ func TestMain(m *testing.M) {
 type testFn func(network string, height int64, raw, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error)
 
 func TestParseCreateExternal(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("CreateExternalExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "CreateExternalExported", expected)
 	require.NoError(t, err)
 
 	runTest(t, eam.ParseCreateExternal, tests)
 }
 
 func TestParseCreate(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("CreateExported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "CreateExported", expected)
 	require.NoError(t, err)
 
 	runTest(t, eam.ParseCreate, tests)
 }
 
 func TestParseCreate2(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("Create2Exported", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "Create2Exported", expected)
 	require.NoError(t, err)
 
 	runTest(t, eam.ParseCreate2, tests)
diff --git a/actors/evm/evm_test.go b/actors/evm/evm_test.go
index 41a1bd7..bfb2cdb 100644
--- a/actors/evm/evm_test.go
+++ b/actors/evm/evm_test.go
@@ -16,8 +16,10 @@ import (
 //go:embed expected.json
 var expectedData []byte
 var expected map[string]any
+var network string
 
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -27,35 +29,35 @@ func TestMain(m *testing.M) {
 type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error)
 
 func TestResurrect(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("Resurrect", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "Resurrect", expected)
 	require.NoError(t, err)
 
 	runTest(t, evm.Resurrect, tests)
 }
 
 func TestGetByteCode(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetByteCode", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetByteCode", expected)
 	require.NoError(t, err)
 
 	runTest(t, evm.GetByteCode, tests)
 }
 
 func TestGetByteCodeHash(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetByteCodeHash", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetByteCodeHash", expected)
 	require.NoError(t, err)
 
 	runTest(t, evm.GetByteCodeHash, tests)
 }
 
 func TestEVMConstructor(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("EVMConstructor", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "EVMConstructor", expected)
 	require.NoError(t, err)
 
 	runTest(t, evm.EVMConstructor, tests)
 }
 
 func TestGetStorageAt(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetStorageAt", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetStorageAt", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
@@ -76,7 +78,7 @@ func TestGetStorageAt(t *testing.T) {
 }
 
 func TestInvokeContract(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("InvokeContract", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "InvokeContract", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
@@ -97,7 +99,7 @@ func TestInvokeContract(t *testing.T) {
 }
 
 func TestInvokeContractDelegate(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("InvokeContractDelegate", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "InvokeContractDelegate", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/init/int_test.go b/actors/init/int_test.go
index af7e3d3..621649a 100644
--- a/actors/init/int_test.go
+++ b/actors/init/int_test.go
@@ -19,7 +19,10 @@ import (
 var expectedData []byte
 var expected map[string]any
 
+var network string
+
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -29,21 +32,21 @@ func TestMain(m *testing.M) {
 type testFn func(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error)
 
 func TestParseExec(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseExec", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseExec", expected)
 	require.NoError(t, err)
 
 	runTest(t, initActor.ParseExec, tests)
 }
 
 func TestParseExec4(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseExec4", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseExec4", expected)
 	require.NoError(t, err)
 
 	runTest(t, initActor.ParseExec4, tests)
 }
 
 func TestInitConstructor(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("InitConstructor", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "InitConstructor", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/market/market_test.go b/actors/market/market_test.go
index d9d9d7c..f1ac444 100644
--- a/actors/market/market_test.go
+++ b/actors/market/market_test.go
@@ -17,7 +17,10 @@ import (
 var expectedData []byte
 var expected map[string]any
 
+var network string
+
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -27,133 +30,133 @@ func TestMain(m *testing.M) {
 type testFn func(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error)
 
 func TestPublishStorageDeals(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("PublishStorageDealsParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "PublishStorageDealsParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.PublishStorageDealsParams, tests)
 }
 
 func TestVerifyDealsForActivation(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("VerifyDealsForActivationParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "VerifyDealsForActivationParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.VerifyDealsForActivationParams, tests)
 }
 
 func TestActivateDeals(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ActivateDealsParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ActivateDealsParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.ActivateDealsParams, tests)
 }
 
 func TestComputeDataCommitment(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ComputeDataCommitmentParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ComputeDataCommitmentParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.ComputeDataCommitmentParams, tests)
 }
 
 func TestGetBalance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetBalanceParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetBalanceParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetBalanceParams, tests)
 }
 
 func TestGetDealDataCommitment(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealDataCommitmentParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealDataCommitmentParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealDataCommitmentParams, tests)
 }
 
 func TestGetDealClient(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealClientParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealClientParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealClientParams, tests)
 }
 
 func TestGetDealProvider(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealProviderParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealProviderParams, tests)
 }
 
 func TestGetDealLabel(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealLabelParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealLabelParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealLabelParams, tests)
 }
 
 func TestGetDealTerm(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealTermParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealTermParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealTermParams, tests)
 }
 
 func TestGetDealTotalPrice(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealTotalPriceParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealTotalPriceParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealTotalPriceParams, tests)
 }
 
 func TestGetDealClientCollateral(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealClientCollateralParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealClientCollateralParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealClientCollateralParams, tests)
 }
 
 func TestGetDealProviderCollateral(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealProviderCollateralParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderCollateralParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealProviderCollateralParams, tests)
 }
 
 func TestGetDealVerified(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealVerifiedParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealVerifiedParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealVerifiedParams, tests)
 }
 
 func TestGetDealActivation(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealActivationParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealActivationParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealActivationParams, tests)
 }
 
 func TestDealProviderCollateral(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealProviderCollateralParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderCollateralParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealProviderCollateralParams, tests)
 }
 
 func TestGetDealVerifiedParams(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealVerifiedParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealVerifiedParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealVerifiedParams, tests)
 }
 
 func TestGetDealActivationParams(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetDealActivationParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetDealActivationParams", expected)
 	require.NoError(t, err)
 
 	runTest(t, market.GetDealActivationParams, tests)
 }
 
 func TestOnMinerSectorsTerminate(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("OnMinerSectorsTerminateParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "OnMinerSectorsTerminateParams", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
@@ -175,7 +178,7 @@ func TestOnMinerSectorsTerminate(t *testing.T) {
 }
 
 func TestParseAddBalance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseAddBalance", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseAddBalance", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
@@ -197,7 +200,7 @@ func TestParseAddBalance(t *testing.T) {
 }
 
 func TestParseWithdrawBalance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalance", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseWithdrawBalance", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/miner/address_test.go b/actors/miner/address_test.go
index 0d9db67..f911b6f 100644
--- a/actors/miner/address_test.go
+++ b/actors/miner/address_test.go
@@ -12,49 +12,49 @@ import (
 type testFn func(network string, height int64, rawReturn []byte) (map[string]interface{}, error)
 
 func TestChangeMultiaddrs(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ChangeMultiaddrs", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ChangeMultiaddrs", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ChangeMultiaddrs, tests)
 }
 
 func TestChangePeerID(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ChangePeerID", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ChangePeerID", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ChangePeerID, tests)
 }
 
 func TestChangeWorkerAddress(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ChangeWorkerAddress", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ChangeWorkerAddress", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ChangeWorkerAddress, tests)
 }
 
 func TestChangeOwnerAddress(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ChangeOwnerAddress", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ChangeOwnerAddress", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ChangeOwnerAddress, tests)
 }
 
 func TestGetOwner(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetOwner", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetOwner", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.GetOwner, tests)
 }
 
 func TestGetPeerID(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetPeerID", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetPeerID", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.GetPeerID, tests)
 }
 
 func TestGetMultiaddrs(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetMultiaddrs", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetMultiaddrs", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.GetMultiaddrs, tests)
 }
 
 func TestIsControllingAddressExported(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("IsControllingAddressExported", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "IsControllingAddressExported", expectedData)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/miner/balance_test.go b/actors/miner/balance_test.go
index cb98218..a09041a 100644
--- a/actors/miner/balance_test.go
+++ b/actors/miner/balance_test.go
@@ -9,19 +9,19 @@ import (
 )
 
 func TestGetAvailableBalance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetAvailableBalance", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetAvailableBalance", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.GetAvailableBalance, tests)
 }
 
 func TestGetVestingFunds(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetVestingFunds", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetVestingFunds", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.GetVestingFunds, tests)
 }
 
 func TestParseWithdrawBalance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalance", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseWithdrawBalance", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ParseWithdrawBalance, tests)
 }
diff --git a/actors/miner/miner_test.go b/actors/miner/miner_test.go
index 3f9e9a7..b495886 100644
--- a/actors/miner/miner_test.go
+++ b/actors/miner/miner_test.go
@@ -16,7 +16,10 @@ import (
 var expected []byte
 var expectedData map[string]any
 
+var network string
+
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expected, &expectedData); err != nil {
 		panic(err)
 	}
@@ -24,73 +27,73 @@ func TestMain(m *testing.M) {
 }
 
 func TestDeclareFaults(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("DeclareFaults", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "DeclareFaults", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.DeclareFaults, tests)
 }
 
 func TestDeclareFaultsRecovered(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("DeclareFaultsRecovered", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "DeclareFaultsRecovered", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.DeclareFaultsRecovered, tests)
 }
 
 func TestProveReplicaUpdates(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ProveReplicaUpdates", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ProveReplicaUpdates", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ProveReplicaUpdates, tests)
 }
 
 func TestPreCommitSectorBatch2(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("PreCommitSectorBatch2", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSectorBatch2", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.PreCommitSectorBatch2, tests)
 }
 
 func TestProveCommitAggregate(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ProveCommitAggregate", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitAggregate", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ProveCommitAggregate, tests)
 }
 
 func TestDisputeWindowedPoSt(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("DisputeWindowedPoSt", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "DisputeWindowedPoSt", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.DisputeWindowedPoSt, tests)
 }
 
 func TestReportConsensusFault(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ReportConsensusFault", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ReportConsensusFault", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ReportConsensusFault, tests)
 }
 
 func TestChangeBeneficiary(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ChangeBeneficiary", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ChangeBeneficiary", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ChangeBeneficiary, tests)
 }
 
 func TestMinerConstructor(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("MinerConstructor", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "MinerConstructor", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.MinerConstructor, tests)
 }
 
 func TestApplyRewards(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ApplyRewards", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ApplyRewards", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ApplyRewards, tests)
 }
 
 func TestOnDeferredCronEvent(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("OnDeferredCronEvent", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "OnDeferredCronEvent", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.OnDeferredCronEvent, tests)
 }
 
 func TestTerminateSectors(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("TerminateSectors", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "TerminateSectors", expectedData)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
@@ -113,7 +116,7 @@ func TestTerminateSectors(t *testing.T) {
 }
 
 func TestProveReplicaUpdates2(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ProveReplicaUpdates2", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ProveReplicaUpdates2", expectedData)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/miner/sector_test.go b/actors/miner/sector_test.go
index 24bc788..beb3b20 100644
--- a/actors/miner/sector_test.go
+++ b/actors/miner/sector_test.go
@@ -10,73 +10,73 @@ import (
 )
 
 func TestExtendSectorExpiration2(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ExtendSectorExpiration2", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ExtendSectorExpiration2", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ExtendSectorExpiration2, tests)
 }
 
 func TestPreCommitSector(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("PreCommitSector", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSector", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.PreCommitSector, tests)
 }
 
 func TestProveCommitSector(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ProveCommitSector", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitSector", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ProveCommitSector, tests)
 }
 
 func TestSubmitWindowedPoSt(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("SubmitWindowedPoSt", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "SubmitWindowedPoSt", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.SubmitWindowedPoSt, tests)
 }
 
 func TestConfirmSectorProofsValid(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ConfirmSectorProofsValid", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ConfirmSectorProofsValid", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ConfirmSectorProofsValid, tests)
 }
 
 func TestCheckSectorProven(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("CheckSectorProven", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "CheckSectorProven", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.CheckSectorProven, tests)
 }
 
 func TestExtendSectorExpiration(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ExtendSectorExpiration", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ExtendSectorExpiration", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.ExtendSectorExpiration, tests)
 }
 
 func TestCompactSectorNumbers(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("CompactSectorNumbers", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "CompactSectorNumbers", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.CompactSectorNumbers, tests)
 }
 
 func TestCompactPartitions(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("CompactPartitions", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "CompactPartitions", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.CompactPartitions, tests)
 }
 
 func TestPreCommitSectorBatch(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("PreCommitSectorBatch", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSectorBatch", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.PreCommitSectorBatch, tests)
 }
 
 func TestGetSectorSize(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetSectorSize", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetSectorSize", expectedData)
 	require.NoError(t, err)
 	runTest(t, miner.GetSectorSize, tests)
 }
 
 func TestProveCommitSectors3(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ProveCommitSectors3", expectedData)
+	tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitSectors3", expectedData)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/multisig/multisig_test.go b/actors/multisig/multisig_test.go
index 1f519ff..f5fb8a1 100644
--- a/actors/multisig/multisig_test.go
+++ b/actors/multisig/multisig_test.go
@@ -17,8 +17,10 @@ import (
 //go:embed expected.json
 var expectedData []byte
 var expected map[string]any
+var network string
 
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -28,43 +30,43 @@ func TestMain(m *testing.M) {
 type testFn func(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error)
 
 func TestApprove(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("Approve", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "Approve", expected)
 	require.NoError(t, err)
 	runTest(t, multisig.Approve, tests)
 }
 
 func TestCancel(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("Cancel", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "Cancel", expected)
 	require.NoError(t, err)
 	runTest(t, multisig.Cancel, tests)
 }
 
 func TestRemoveSigner(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("RemoveSigner", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "RemoveSigner", expected)
 	require.NoError(t, err)
 	runTest(t, multisig.RemoveSigner, tests)
 }
 
 func TestChangeNumApprovalsThreshold(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ChangeNumApprovalsThreshold", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ChangeNumApprovalsThreshold", expected)
 	require.NoError(t, err)
 	runTest(t, multisig.ChangeNumApprovalsThreshold, tests)
 }
 
 func TestLockBalance(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("LockBalance", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "LockBalance", expected)
 	require.NoError(t, err)
 	runTest(t, multisig.LockBalance, tests)
 }
 
 func TestUniversalReceiverHook(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("UniversalReceiverHook", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "UniversalReceiverHook", expected)
 	require.NoError(t, err)
 	runTest(t, multisig.UniversalReceiverHook, tests)
 }
 
 func TestMsigConstructor(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("MsigConstructor", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "MsigConstructor", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
@@ -86,7 +88,7 @@ func TestMsigConstructor(t *testing.T) {
 	}
 }
 func TestMsigParams(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("MsigParams", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "MsigParams", expected)
 	require.NoError(t, err)
 	for _, tt := range tests {
 		t.Run(tt.Name, func(t *testing.T) {
diff --git a/actors/multisig/values_test.go b/actors/multisig/values_test.go
index 19009b3..7d5a4a4 100644
--- a/actors/multisig/values_test.go
+++ b/actors/multisig/values_test.go
@@ -13,78 +13,78 @@ import (
 type valueTestFn func(network string, height int64, txMetadata string) (interface{}, error)
 
 func TestChangeOwnerAddressValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ChangeOwnerAddressValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ChangeOwnerAddressValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ChangeOwnerAddressValue, tests)
 }
 
 func TestParseWithdrawBalanceValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalanceValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseWithdrawBalanceValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseWithdrawBalanceValue, tests)
 }
 
 func TestParseInvokeContractValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseInvokeContractValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseInvokeContractValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseInvokeContractValue, tests)
 }
 
 func TestParseAddSignerValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseAddSignerValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseAddSignerValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseAddSignerValue, tests)
 }
 
 func TestParseApproveValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseApproveValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseApproveValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseApproveValue, tests)
 }
 
 func TestParseCancelValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseCancelValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseCancelValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseCancelValue, tests)
 }
 func TestChangeNumApprovalsThresholdValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ChangeNumApprovalsThresholdValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ChangeNumApprovalsThresholdValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ChangeNumApprovalsThresholdValue, tests)
 }
 
 func TestParseConstructorValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseConstructorValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseConstructorValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseConstructorValue, tests)
 }
 
 func TestParseLockBalanceValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseLockBalanceValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseLockBalanceValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseLockBalanceValue, tests)
 }
 
 func TestParseRemoveSignerValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseRemoveSignerValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseRemoveSignerValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseRemoveSignerValue, tests)
 }
 
 func TestParseSendValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseSendValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseSendValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseSendValue, tests)
 }
 
 func TestParseSwapSignerValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseSwapSignerValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseSwapSignerValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseSwapSignerValue, tests)
 }
 
 func TestParseUniversalReceiverHookValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ParseUniversalReceiverHookValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ParseUniversalReceiverHookValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.ParseUniversalReceiverHookValue, tests)
 }
diff --git a/actors/multisig/verifier_test.go b/actors/multisig/verifier_test.go
index 790c4e5..d951851 100644
--- a/actors/multisig/verifier_test.go
+++ b/actors/multisig/verifier_test.go
@@ -9,7 +9,7 @@ import (
 )
 
 func TestAddVerifierValue(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("AddVerifierValue", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "AddVerifierValue", expected)
 	require.NoError(t, err)
 	runValueTest(t, multisig.AddVerifierValue, tests)
 }
diff --git a/actors/paymentChannel/paymentChannel_test.go b/actors/paymentChannel/paymentChannel_test.go
index 4b89375..fffcd0d 100644
--- a/actors/paymentChannel/paymentChannel_test.go
+++ b/actors/paymentChannel/paymentChannel_test.go
@@ -15,7 +15,10 @@ import (
 var expectedData []byte
 var expected map[string]any
 
+var network string
+
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -31,13 +34,13 @@ type test struct {
 }
 
 func TestPaymentChannelConstructor(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("PaymentChannelConstructor", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "PaymentChannelConstructor", expected)
 	require.NoError(t, err)
 	runTest(t, paymentchannel.PaymentChannelConstructor, tests)
 }
 
 func TestUpdateChannelState(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("UpdateChannelState", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "UpdateChannelState", expected)
 	require.NoError(t, err)
 	runTest(t, paymentchannel.UpdateChannelState, tests)
 }
diff --git a/actors/power/power_test.go b/actors/power/power_test.go
index 745b2a9..1247e65 100644
--- a/actors/power/power_test.go
+++ b/actors/power/power_test.go
@@ -16,7 +16,10 @@ import (
 var expectedData []byte
 var expected map[string]any
 
+var network string
+
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -26,67 +29,67 @@ func TestMain(m *testing.M) {
 type testFn func(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error)
 
 func TestCurrentTotalPower(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("CurrentTotalPower", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "CurrentTotalPower", expected)
 	require.NoError(t, err)
 	runTest(t, power.CurrentTotalPower, tests)
 }
 
 func TestSubmitPoRepForBulkVerify(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("SubmitPoRepForBulkVerify", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "SubmitPoRepForBulkVerify", expected)
 	require.NoError(t, err)
 	runTest(t, power.SubmitPoRepForBulkVerify, tests)
 }
 
 func TestCreateMiner(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("CreateMiner", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "CreateMiner", expected)
 	require.NoError(t, err)
 	runTest(t, power.CreateMiner, tests)
 }
 
 func TestEnrollCronEvent(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("EnrollCronEvent", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "EnrollCronEvent", expected)
 	require.NoError(t, err)
 	runTest(t, power.EnrollCronEvent, tests)
 }
 
 func TestUpdateClaimedPower(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("UpdateClaimedPower", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "UpdateClaimedPower", expected)
 	require.NoError(t, err)
 	runTest(t, power.UpdateClaimedPower, tests)
 }
 
 func TestUpdatePledgeTotal(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("UpdatePledgeTotal", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "UpdatePledgeTotal", expected)
 	require.NoError(t, err)
 	runTest(t, power.UpdatePledgeTotal, tests)
 }
 
 func TestNetworkRawPower(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("NetworkRawPower", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "NetworkRawPower", expected)
 	require.NoError(t, err)
 	runTest(t, power.NetworkRawPower, tests)
 }
 
 func TestMinerRawPower(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("MinerRawPower", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "MinerRawPower", expected)
 	require.NoError(t, err)
 	runTest(t, power.MinerRawPower, tests)
 }
 
 func TestMinerCount(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("MinerCount", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "MinerCount", expected)
 	require.NoError(t, err)
 	runTest(t, power.MinerCount, tests)
 }
 
 func TestMinerConsensusCount(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("MinerConsensusCount", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "MinerConsensusCount", expected)
 	require.NoError(t, err)
 	runTest(t, power.MinerConsensusCount, tests)
 }
 
 func TestPowerConstructor(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("PowerConstructor", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "PowerConstructor", expected)
 	require.NoError(t, err)
 
 	for _, tt := range tests {
diff --git a/actors/reward/reward_test.go b/actors/reward/reward_test.go
index 96a9484..97b8a54 100644
--- a/actors/reward/reward_test.go
+++ b/actors/reward/reward_test.go
@@ -15,7 +15,10 @@ import (
 var expectedData []byte
 var expected map[string]any
 
+var network string
+
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -25,25 +28,25 @@ func TestMain(m *testing.M) {
 type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error)
 
 func TestRewardConstructor(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("RewardConstructor", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "RewardConstructor", expected)
 	require.NoError(t, err)
 	runTest(t, reward.RewardConstructor, tests)
 }
 
 func TestAwardBlockReward(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("AwardBlockReward", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "AwardBlockReward", expected)
 	require.NoError(t, err)
 	runTest(t, reward.AwardBlockReward, tests)
 }
 
 func TestUpdateNetworkKPI(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("UpdateNetworkKPI", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "UpdateNetworkKPI", expected)
 	require.NoError(t, err)
 	runTest(t, reward.UpdateNetworkKPI, tests)
 }
 
 func TestThisEpochReward(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ThisEpochReward", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ThisEpochReward", expected)
 	require.NoError(t, err)
 	runTest(t, reward.ThisEpochReward, tests)
 }
diff --git a/actors/verifiedRegistry/verifiedRegistry_test.go b/actors/verifiedRegistry/verifiedRegistry_test.go
index ccb4ec4..955f828 100644
--- a/actors/verifiedRegistry/verifiedRegistry_test.go
+++ b/actors/verifiedRegistry/verifiedRegistry_test.go
@@ -15,7 +15,10 @@ import (
 var expectedData []byte
 var expected map[string]any
 
+var network string
+
 func TestMain(m *testing.M) {
+	network = "mainnet"
 	if err := json.Unmarshal(expectedData, &expected); err != nil {
 		panic(err)
 	}
@@ -26,84 +29,84 @@ type testFn func(network string, height int64, raw []byte) (map[string]interface
 type testFn2 func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error)
 
 func TestAddVerifier(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("AddVerifier", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "AddVerifier", expected)
 	require.NoError(t, err)
 	runTest(t, verifiedregistry.AddVerifier, tests)
 }
 
 func TestRemoveVerifier(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("RemoveVerifier", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "RemoveVerifier", expected)
 	require.NoError(t, err)
 	runTest(t, verifiedregistry.RemoveVerifier, tests)
 }
 
 func TestAddVerifiedClient(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("AddVerifiedClient", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "AddVerifiedClient", expected)
 	require.NoError(t, err)
 	runTest(t, verifiedregistry.AddVerifiedClient, tests)
 }
 
 func TestUseBytes(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("UseBytes", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "UseBytes", expected)
 	require.NoError(t, err)
 	runTest(t, verifiedregistry.UseBytes, tests)
 }
 
 func TestRestoreBytes(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("RestoreBytes", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "RestoreBytes", expected)
 	require.NoError(t, err)
 	runTest(t, verifiedregistry.RestoreBytes, tests)
 }
 
 func TestRemoveVerifiedClientDataCap(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("RemoveVerifiedClientDataCap", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "RemoveVerifiedClientDataCap", expected)
 	require.NoError(t, err)
 	runTest(t, verifiedregistry.RemoveVerifiedClientDataCap, tests)
 }
 
 func TestDeprecated1(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("Deprecated1", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "Deprecated1", expected)
 	require.NoError(t, err)
 	runTest(t, verifiedregistry.Deprecated1, tests)
 }
 
 func TestDeprecated2(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("Deprecated2", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "Deprecated2", expected)
 	require.NoError(t, err)
 	runTest(t, verifiedregistry.Deprecated2, tests)
 }
 
 func TestClaimAllocations(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ClaimAllocations", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ClaimAllocations", expected)
 	require.NoError(t, err)
 	runTest2(t, verifiedregistry.ClaimAllocations, tests)
 }
 
 func TestGetClaims(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("GetClaims", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "GetClaims", expected)
 	require.NoError(t, err)
 	runTest2(t, verifiedregistry.GetClaims, tests)
 }
 
 func TestExtendClaimTerms(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("ExtendClaimTerms", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "ExtendClaimTerms", expected)
 	require.NoError(t, err)
 	runTest2(t, verifiedregistry.ExtendClaimTerms, tests)
 }
 
 func TestRemoveExpiredClaims(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("RemoveExpiredClaims", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "RemoveExpiredClaims", expected)
 	require.NoError(t, err)
 	runTest2(t, verifiedregistry.RemoveExpiredClaims, tests)
 }
 
 func TestVerifregUniversalReceiverHook(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("VerifregUniversalReceiverHook", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "VerifregUniversalReceiverHook", expected)
 	require.NoError(t, err)
 	runTest2(t, verifiedregistry.VerifregUniversalReceiverHook, tests)
 }
 func TestRemoveExpiredAllocations(t *testing.T) {
-	tests, err := tools.LoadTestData[map[string]any]("RemoveExpiredAllocations", expected)
+	tests, err := tools.LoadTestData[map[string]any](network, "RemoveExpiredAllocations", expected)
 	require.NoError(t, err)
 	runTest2(t, verifiedregistry.RemoveExpiredAllocations, tests)
 }
diff --git a/tools/testutil.go b/tools/testutil.go
index c8848a4..2a781a1 100644
--- a/tools/testutil.go
+++ b/tools/testutil.go
@@ -168,7 +168,7 @@ type TestCase[T any] struct {
 	Address   *types.AddressInfo
 }
 
-func LoadTestData[T any](fnName string, network string, expected map[string]any) ([]TestCase[T], error) {
+func LoadTestData[T any](network string, fnName string, expected map[string]any) ([]TestCase[T], error) {
 	var tests []TestCase[T]
 	for _, version := range GetSupportedVersions(network) {