diff --git a/pkg/loop/internal/relayer/pluginprovider/contractreader/contract_reader_test.go b/pkg/loop/internal/relayer/pluginprovider/contractreader/contract_reader_test.go
index 88a87031c..c050f9cf9 100644
--- a/pkg/loop/internal/relayer/pluginprovider/contractreader/contract_reader_test.go
+++ b/pkg/loop/internal/relayer/pluginprovider/contractreader/contract_reader_test.go
@@ -85,6 +85,7 @@ func TestContractReaderInterfaceTests(t *testing.T) {
 					contractreadertest.WithContractReaderLoopEncoding(version),
 				),
 				true,
+				false,
 			)
 		}
 	})
@@ -1162,6 +1163,7 @@ func runContractReaderByIDQueryKey(t *testing.T) {
 		func(t *testing.T) {
 			t.Parallel()
 			fake := &fakeContractReader{}
+			fakeCW := &fakeContractWriter{cr: fake}
 			tester := &fakeContractReaderInterfaceTester{impl: fake}
 			tester.Setup(t)
 
@@ -1179,14 +1181,14 @@ func runContractReaderByIDQueryKey(t *testing.T) {
 			require.NoError(t, cr.Bind(ctx, toBind))
 
 			ts1AnyContract := CreateTestStruct(0, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1AnyContract, anyContract, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts1AnyContract, anyContract, types.Unconfirmed)
 			ts2AnyContract := CreateTestStruct(1, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2AnyContract, anyContract, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts2AnyContract, anyContract, types.Unconfirmed)
 
 			ts1AnySecondContract := CreateTestStruct(0, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1AnySecondContract, anySecondContract, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts1AnySecondContract, anySecondContract, types.Unconfirmed)
 			ts2AnySecondContract := CreateTestStruct(1, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2AnySecondContract, anySecondContract, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts2AnySecondContract, anySecondContract, types.Unconfirmed)
 
 			tsAnyContractType := &TestStruct{}
 			require.Eventually(t, func() bool {
@@ -1205,6 +1207,8 @@ func runContractReaderByIDQueryKey(t *testing.T) {
 		func(t *testing.T) {
 			t.Parallel()
 			fake := &fakeContractReader{}
+			fakeCW := &fakeContractWriter{cr: fake}
+
 			tester := &fakeContractReaderInterfaceTester{impl: fake}
 			tester.Setup(t)
 
@@ -1225,22 +1229,22 @@ func runContractReaderByIDQueryKey(t *testing.T) {
 			require.NoError(t, cr.Bind(ctx, toBind))
 
 			ts1AnyContract1 := CreateTestStruct(0, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1AnyContract1, anyContract1, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts1AnyContract1, anyContract1, types.Unconfirmed)
 			ts2AnyContract1 := CreateTestStruct(1, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2AnyContract1, anyContract1, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts2AnyContract1, anyContract1, types.Unconfirmed)
 			ts1AnyContract2 := CreateTestStruct(2, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1AnyContract2, anyContract2, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts1AnyContract2, anyContract2, types.Unconfirmed)
 			ts2AnyContract2 := CreateTestStruct(3, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2AnyContract2, anyContract2, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts2AnyContract2, anyContract2, types.Unconfirmed)
 
 			ts1AnySecondContract1 := CreateTestStruct(4, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1AnySecondContract1, anySecondContract1, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts1AnySecondContract1, anySecondContract1, types.Unconfirmed)
 			ts2AnySecondContract1 := CreateTestStruct(5, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2AnySecondContract1, anySecondContract1, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts2AnySecondContract1, anySecondContract1, types.Unconfirmed)
 			ts1AnySecondContract2 := CreateTestStruct(6, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1AnySecondContract2, anySecondContract2, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts1AnySecondContract2, anySecondContract2, types.Unconfirmed)
 			ts2AnySecondContract2 := CreateTestStruct(7, tester)
-			_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2AnySecondContract2, anySecondContract2, types.Unconfirmed)
+			_ = SubmitTransactionToCW(t, tester, fakeCW, MethodTriggeringEvent, ts2AnySecondContract2, anySecondContract2, types.Unconfirmed)
 
 			tsAnyContractType := &TestStruct{}
 			require.Eventually(t, func() bool {
diff --git a/pkg/loop/internal/relayer/pluginprovider/contractreader/test/contract_reader_loop_tester.go b/pkg/loop/internal/relayer/pluginprovider/contractreader/test/contract_reader_loop_tester.go
index 8bd159de5..23671fbe5 100644
--- a/pkg/loop/internal/relayer/pluginprovider/contractreader/test/contract_reader_loop_tester.go
+++ b/pkg/loop/internal/relayer/pluginprovider/contractreader/test/contract_reader_loop_tester.go
@@ -56,6 +56,7 @@ func WithContractReaderLoopEncoding(version contractreader.EncodingVersion) Loop
 type contractReaderLoopTester struct {
 	ChainComponentsInterfaceTester[*testing.T]
 	lst        loopServerTester
+	conn       *grpc.ClientConn
 	encodeWith contractreader.EncodingVersion
 }
 
@@ -71,10 +72,11 @@ func (c *contractReaderLoopTester) Setup(t *testing.T) {
 	}
 
 	c.lst.Setup(t)
+	c.conn = c.lst.GetConn(t)
 }
 
 func (c *contractReaderLoopTester) GetContractReader(t *testing.T) types.ContractReader {
-	return contractreader.NewClient(nil, c.lst.GetConn(t), contractreader.WithClientEncoding(c.encodeWith))
+	return contractreader.NewClient(nil, c.conn, contractreader.WithClientEncoding(c.encodeWith))
 }
 
 func (c *contractReaderLoopTester) Name() string {
diff --git a/pkg/types/interfacetests/chain_components_interface_tests.go b/pkg/types/interfacetests/chain_components_interface_tests.go
index 7d32471ce..c65f9b6ff 100644
--- a/pkg/types/interfacetests/chain_components_interface_tests.go
+++ b/pkg/types/interfacetests/chain_components_interface_tests.go
@@ -111,12 +111,12 @@ var AnySliceToReadWithoutAnArgument = []uint64{3, 4}
 
 const AnyExtraValue = 3
 
-func RunContractReaderInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], mockRun bool) {
+func RunContractReaderInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], mockRun bool, parallel bool) {
 	t.Run(tester.Name(), func(t T) {
-		t.Run("GetLatestValue", func(t T) { runContractReaderGetLatestValueInterfaceTests(t, tester, mockRun) })
-		t.Run("BatchGetLatestValues", func(t T) { runContractReaderBatchGetLatestValuesInterfaceTests(t, tester, mockRun) })
-		t.Run("QueryKey", func(t T) { runQueryKeyInterfaceTests(t, tester) })
-		t.Run("QueryKeys", func(t T) { runQueryKeysInterfaceTests(t, tester) })
+		t.Run("GetLatestValue", func(t T) { runContractReaderGetLatestValueInterfaceTests(t, tester, mockRun, parallel) })
+		t.Run("BatchGetLatestValues", func(t T) { runContractReaderBatchGetLatestValuesInterfaceTests(t, tester, mockRun, parallel) })
+		t.Run("QueryKey", func(t T) { runQueryKeyInterfaceTests(t, tester, parallel) })
+		t.Run("QueryKeys", func(t T) { runQueryKeysInterfaceTests(t, tester, parallel) })
 	})
 }
 
@@ -129,19 +129,21 @@ type sequenceWithKey struct {
 	Key string
 }
 
-func runQueryKeysInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T]) {
+func runQueryKeysInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], parallel bool) {
 	tests := []Testcase[T]{
 		{
 			Name: ContractReaderQueryKeysReturnsDataTwoEventTypes,
 			Test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
+
 				bindings := tester.GetBindings(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				boundContract := BindingsByName(bindings, AnyContractName)[0]
 
-				expectedSequenceData := createMixedEventTypeSequence(t, tester, boundContract)
+				expectedSequenceData := createMixedEventTypeSequence(t, tester, cw, boundContract)
 
 				ts := &TestStruct{}
 				require.Eventually(t, func() bool {
@@ -181,7 +183,7 @@ func runQueryKeysInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterf
 				bindings := tester.GetBindings(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
-				require.NoError(t, cr.Bind(ctx, tester.GetBindings(t)))
+				require.NoError(t, cr.Bind(ctx, bindings))
 
 				contractFilter := types.ContractKeyFilter{
 					Contract:         bound,
@@ -204,12 +206,13 @@ func runQueryKeysInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterf
 			Test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
-				expectedSequenceData := createMixedEventTypeSequence(t, tester, bound)
+				expectedSequenceData := createMixedEventTypeSequence(t, tester, cw, bound)
 
 				var value values.Value
 				require.Eventually(t, func() bool {
@@ -268,12 +271,15 @@ func runQueryKeysInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterf
 			Test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
+
 				bindings := tester.GetBindings(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				boundContract := BindingsByName(bindings, AnyContractName)[0]
 
-				expectedSequenceData := createMixedEventTypeSequence(t, tester, boundContract)
+				expectedSequenceData := createMixedEventTypeSequence(t, tester, cw, boundContract)
+				fmt.Println("expectedSequenceData", expectedSequenceData)
 
 				ts := &TestStruct{}
 				require.Eventually(t, func() bool {
@@ -321,6 +327,7 @@ func runQueryKeysInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterf
 			Test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
@@ -330,26 +337,26 @@ func runQueryKeysInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterf
 
 				ts1 := CreateTestStruct[T](0, tester)
 				expectedSequenceData = append(expectedSequenceData, &ts1)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts1, boundContract, types.Unconfirmed)
 				ts2 := CreateTestStruct[T](1, tester)
 				expectedSequenceData = append(expectedSequenceData, &ts2)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts2, boundContract, types.Unconfirmed)
 
 				ds1 := SomeDynamicTopicEvent{Field: "1"}
 				expectedSequenceData = append(expectedSequenceData, &ds1)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEventWithDynamicTopic, ds1, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEventWithDynamicTopic, ds1, boundContract, types.Unconfirmed)
 
 				ts3 := CreateTestStruct[T](2, tester)
 				expectedSequenceData = append(expectedSequenceData, &ts3)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts3, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts3, boundContract, types.Unconfirmed)
 
 				ds2 := SomeDynamicTopicEvent{Field: "2"}
 				expectedSequenceData = append(expectedSequenceData, &ds2)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEventWithDynamicTopic, ds2, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEventWithDynamicTopic, ds2, boundContract, types.Unconfirmed)
 
 				ts4 := CreateTestStruct[T](3, tester)
 				expectedSequenceData = append(expectedSequenceData, &ts4)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts4, boundContract, types.Finalized)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts4, boundContract, types.Finalized)
 
 				require.Eventually(t, func() bool {
 					var allSequences []sequenceWithKey
@@ -399,35 +406,38 @@ func runQueryKeysInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterf
 		},
 	}
 
-	RunTests(t, tester, tests)
+	if parallel {
+		RunTestsInParallel(t, tester, tests)
+	} else {
+		RunTests(t, tester, tests)
+	}
 }
 
-func createMixedEventTypeSequence[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], boundContract types.BoundContract) []any {
+func createMixedEventTypeSequence[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], cw types.ContractWriter, boundContract types.BoundContract) []any {
 	var expectedSequenceData []any
 
 	ts1 := CreateTestStruct[T](0, tester)
 	expectedSequenceData = append(expectedSequenceData, &ts1)
-	_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1, boundContract, types.Unconfirmed)
+	_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts1, boundContract, types.Unconfirmed)
 	ts2 := CreateTestStruct[T](1, tester)
 	expectedSequenceData = append(expectedSequenceData, &ts2)
-	_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2, boundContract, types.Unconfirmed)
+	_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts2, boundContract, types.Unconfirmed)
 
 	ds1 := SomeDynamicTopicEvent{Field: "1"}
 	expectedSequenceData = append(expectedSequenceData, &ds1)
-	_ = SubmitTransactionToCW(t, tester, MethodTriggeringEventWithDynamicTopic, ds1, boundContract, types.Unconfirmed)
+	_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEventWithDynamicTopic, ds1, boundContract, types.Unconfirmed)
 
 	ts3 := CreateTestStruct[T](2, tester)
 	expectedSequenceData = append(expectedSequenceData, &ts3)
-	_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts3, boundContract, types.Unconfirmed)
+	_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts3, boundContract, types.Unconfirmed)
 
 	ds2 := SomeDynamicTopicEvent{Field: "2"}
 	expectedSequenceData = append(expectedSequenceData, &ds2)
-	_ = SubmitTransactionToCW(t, tester, MethodTriggeringEventWithDynamicTopic, ds2, boundContract, types.Unconfirmed)
+	_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEventWithDynamicTopic, ds2, boundContract, types.Unconfirmed)
 
 	ts4 := CreateTestStruct[T](3, tester)
 	expectedSequenceData = append(expectedSequenceData, &ts4)
-	_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts4, boundContract, types.Unconfirmed)
-
+	_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts4, boundContract, types.Unconfirmed)
 	return expectedSequenceData
 }
 
@@ -445,26 +455,26 @@ func sequenceDataEqual(expectedSequenceData []any, sequences []sequenceWithKey)
 	return true
 }
 
-func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], mockRun bool) {
+func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], mockRun bool, parallel bool) {
 	tests := []Testcase[T]{
 		{
 			Name: ContractReaderGetLatestValueAsValuesDotValue,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
+				contracts := tester.GetBindings(t)
 				ctx := tests.Context(t)
 				firstItem := CreateTestStruct(0, tester)
 
-				contracts := tester.GetBindings(t)
-				_ = SubmitTransactionToCW(t, tester, MethodSettingStruct, firstItem, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodSettingStruct, firstItem, contracts[0], types.Unconfirmed)
 
 				secondItem := CreateTestStruct(1, tester)
 
-				_ = SubmitTransactionToCW(t, tester, MethodSettingStruct, secondItem, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodSettingStruct, secondItem, contracts[0], types.Unconfirmed)
 
-				cr := tester.GetContractReader(t)
-				bindings := tester.GetBindings(t)
-				bound := BindingsByName(bindings, AnyContractName)[0] // minimum of one bound contract expected, otherwise panics
+				bound := BindingsByName(contracts, AnyContractName)[0] // minimum of one bound contract expected, otherwise panics
 
-				require.NoError(t, cr.Bind(ctx, bindings))
+				require.NoError(t, cr.Bind(ctx, contracts))
 
 				params := &LatestParams{I: 1}
 				var value values.Value
@@ -491,9 +501,9 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueNoArgumentsAndPrimitiveReturnAsValuesDotValue,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
@@ -512,9 +522,9 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueNoArgumentsAndSliceReturnAsValueDotValue,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
@@ -532,21 +542,21 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValue,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
+				contracts := tester.GetBindings(t)
 				ctx := tests.Context(t)
 				firstItem := CreateTestStruct(0, tester)
 
-				contracts := tester.GetBindings(t)
-				_ = SubmitTransactionToCW(t, tester, MethodSettingStruct, firstItem, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodSettingStruct, firstItem, contracts[0], types.Unconfirmed)
 
 				secondItem := CreateTestStruct(1, tester)
 
-				_ = SubmitTransactionToCW(t, tester, MethodSettingStruct, secondItem, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodSettingStruct, secondItem, contracts[0], types.Unconfirmed)
 
-				cr := tester.GetContractReader(t)
-				bindings := tester.GetBindings(t)
-				bound := BindingsByName(bindings, AnyContractName)[0] // minimum of one bound contract expected, otherwise panics
+				bound := BindingsByName(contracts, AnyContractName)[0] // minimum of one bound contract expected, otherwise panics
 
-				require.NoError(t, cr.Bind(ctx, bindings))
+				require.NoError(t, cr.Bind(ctx, contracts))
 
 				actual := &TestStruct{}
 				params := &LatestParams{I: 1}
@@ -562,9 +572,10 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueWithPrimitiveReturn,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
+
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
@@ -578,9 +589,10 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueBasedOnConfidenceLevel,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 
@@ -593,22 +605,18 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 					ReturnVal:       &returnVal1,
 				}
 
-				contracts := tester.GetBindings(t)
-
-				txID := SubmitTransactionToCW(t, tester, MethodSettingUint64, PrimitiveArgs{Value: 10}, contracts[0], types.Unconfirmed)
+				txID := SubmitTransactionToCW(t, tester, cw, MethodSettingUint64, PrimitiveArgs{Value: 10}, bindings[0], types.Unconfirmed)
 
 				var prim1 uint64
 				bound := BindingsByName(bindings, callArgs.ContractName)[0]
 
-				require.Error(t, cr.GetLatestValue(ctx, bound.ReadIdentifier(callArgs.ReadName), primitives.Finalized, callArgs.Params, &prim1))
-
-				err := WaitForTransactionStatus(t, tester, txID, types.Finalized, mockRun)
+				err := WaitForTransactionStatus(t, tester, cw, txID, types.Finalized, mockRun)
 				require.NoError(t, err)
 
 				require.NoError(t, cr.GetLatestValue(ctx, bound.ReadIdentifier(MethodReturningAlterableUint64), primitives.Finalized, nil, &prim1))
 				assert.Equal(t, uint64(10), prim1)
 
-				_ = SubmitTransactionToCW(t, tester, MethodSettingUint64, PrimitiveArgs{Value: 20}, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodSettingUint64, PrimitiveArgs{Value: 20}, bindings[0], types.Unconfirmed)
 
 				var prim2 uint64
 				require.NoError(t, cr.GetLatestValue(ctx, bound.ReadIdentifier(callArgs.ReadName), callArgs.ConfidenceLevel, callArgs.Params, &prim2))
@@ -618,9 +626,9 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueFromMultipleContractsNamesSameFunction,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 				bound := BindingsByName(bindings, AnySecondContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
@@ -634,9 +642,9 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueNoArgumentsAndSliceReturn,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
@@ -650,15 +658,16 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueWithModifiersUsingOwnMapstrctureOverrides,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				bindings := tester.GetBindings(t)
+
 				ctx := tests.Context(t)
 				testStruct := CreateTestStruct(0, tester)
 				testStruct.BigField = nil
 				testStruct.AccountStruct.Account = nil
 
-				bindings := tester.GetBindings(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
-				cr := tester.GetContractReader(t)
 				require.NoError(t, cr.Bind(ctx, bindings))
 
 				actual := &TestStructWithExtraField{}
@@ -675,19 +684,19 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueGetsLatestForEvent,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
-				contracts := tester.GetBindings(t)
 
 				ts := CreateTestStruct[T](0, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts, bindings[0], types.Unconfirmed)
 
 				ts = CreateTestStruct[T](1, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts, bindings[0], types.Unconfirmed)
 
 				result := &TestStruct{}
 				require.Eventually(t, func() bool {
@@ -699,27 +708,24 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueBasedOnConfidenceLevelForEvent,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				ts1 := CreateTestStruct[T](2, tester)
 
-				txID := SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1, bindings[0], types.Unconfirmed)
+				txID := SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts1, bindings[0], types.Unconfirmed)
 
 				result := &TestStruct{}
-				require.Eventually(t, func() bool {
-					err := cr.GetLatestValue(ctx, bound.ReadIdentifier(EventName), primitives.Finalized, nil, &result)
-					return err != nil && assert.ErrorContains(t, err, types.ErrNotFound.Error())
-				}, tester.MaxWaitTimeForEvents(), time.Millisecond*10)
 
-				err := WaitForTransactionStatus(t, tester, txID, types.Finalized, mockRun)
+				err := WaitForTransactionStatus(t, tester, cw, txID, types.Finalized, mockRun)
 				require.NoError(t, err)
 
 				ts2 := CreateTestStruct[T](3, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2, bindings[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts2, bindings[0], types.Unconfirmed)
 
 				require.Eventually(t, func() bool {
 					err := cr.GetLatestValue(ctx, bound.ReadIdentifier(EventName), primitives.Finalized, nil, &result)
@@ -735,9 +741,9 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueReturnsNotFoundWhenNotTriggeredForEvent,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
@@ -750,18 +756,19 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 		{
 			Name: ContractReaderGetLatestValueWithFilteringForEvent,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
+
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				ts0 := CreateTestStruct(0, tester)
 
-				contracts := tester.GetBindings(t)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts0, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts0, bindings[0], types.Unconfirmed)
 				ts1 := CreateTestStruct(1, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1, contracts[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts1, bindings[0], types.Unconfirmed)
 
 				filterParams := &FilterEventParams{Field: *ts0.Field}
 				assert.Never(t, func() bool {
@@ -779,22 +786,28 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 	}
-	RunTests(t, tester, tests)
+	if parallel {
+		RunTestsInParallel(t, tester, tests)
+	} else {
+		RunTests(t, tester, tests)
+	}
 }
 
-func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], mockRun bool) {
+func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], mockRun bool, parallel bool) {
 	testCases := []Testcase[T]{
 		{
 			Name: ContractReaderBatchGetLatestValue,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
+				bindings := tester.GetBindings(t)
 				// setup test data
 				firstItem := CreateTestStruct(1, tester)
-				bindings := tester.GetBindings(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				batchCallEntry := make(BatchCallEntry)
 				batchCallEntry[bound] = ContractBatchEntry{{Name: MethodTakingLatestParamsReturningTestStruct, ReturnValue: &firstItem}}
-				batchContractWrite(t, tester, batchCallEntry, mockRun)
+				batchContractWrite(t, tester, cw, bindings, batchCallEntry, mockRun)
 
 				// setup call data
 				params, actual := &LatestParams{I: 1}, &TestStruct{}
@@ -808,7 +821,6 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 				}
 
 				ctx := tests.Context(t)
-				cr := tester.GetContractReader(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				result, err := cr.BatchGetLatestValues(ctx, batchGetLatestValueRequest)
@@ -824,10 +836,11 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 		{
 			Name: ContractReaderBatchGetLatestValueNoArgumentsPrimitiveReturn,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				bindings := tester.GetBindings(t)
 				// setup call data
 				var primitiveReturnValue uint64
 				batchGetLatestValuesRequest := make(types.BatchGetLatestValuesRequest)
-				bindings := tester.GetBindings(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				batchGetLatestValuesRequest[bound] = []types.BatchRead{
@@ -839,7 +852,6 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 				}
 
 				ctx := tests.Context(t)
-				cr := tester.GetContractReader(t)
 				require.NoError(t, cr.Bind(ctx, bindings))
 
 				result, err := cr.BatchGetLatestValues(ctx, batchGetLatestValuesRequest)
@@ -855,9 +867,11 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 		{
 			Name: ContractReaderBatchGetLatestValueMultipleContractNamesSameFunction,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				bindings := tester.GetBindings(t)
+
 				var primitiveReturnValueAnyContract, primitiveReturnValueAnySecondContract uint64
 				batchGetLatestValuesRequest := make(types.BatchGetLatestValuesRequest)
-				bindings := tester.GetBindings(t)
 				bound1 := BindingsByName(bindings, AnyContractName)[0]
 				bound2 := BindingsByName(bindings, AnySecondContractName)[0]
 
@@ -865,7 +879,6 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 				batchGetLatestValuesRequest[bound2] = []types.BatchRead{{ReadName: MethodReturningUint64, Params: nil, ReturnVal: &primitiveReturnValueAnySecondContract}}
 
 				ctx := tests.Context(t)
-				cr := tester.GetContractReader(t)
 				require.NoError(t, cr.Bind(ctx, bindings))
 
 				result, err := cr.BatchGetLatestValues(ctx, batchGetLatestValuesRequest)
@@ -885,16 +898,16 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 		{
 			Name: ContractReaderBatchGetLatestValueNoArgumentsWithSliceReturn,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				bindings := tester.GetBindings(t)
 				// setup call data
 				var sliceReturnValue []uint64
 				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
-				bindings := tester.GetBindings(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				batchGetLatestValueRequest[bound] = []types.BatchRead{{ReadName: MethodReturningUint64Slice, Params: nil, ReturnVal: &sliceReturnValue}}
 
 				ctx := tests.Context(t)
-				cr := tester.GetContractReader(t)
 				require.NoError(t, cr.Bind(ctx, bindings))
 				result, err := cr.BatchGetLatestValues(ctx, batchGetLatestValueRequest)
 				require.NoError(t, err)
@@ -909,19 +922,19 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 		{
 			Name: ContractReaderBatchGetLatestValueWithModifiersOwnMapstructureOverride,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				bindings := tester.GetBindings(t)
 				// setup call data
 				testStruct := CreateTestStruct(0, tester)
 				testStruct.BigField = nil
 				testStruct.AccountStruct.Account = nil
 				actual := &TestStructWithExtraField{}
 				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
-				bindings := tester.GetBindings(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				batchGetLatestValueRequest[bound] = []types.BatchRead{{ReadName: MethodReturningSeenStruct, Params: testStruct, ReturnVal: actual}}
 
 				ctx := tests.Context(t)
-				cr := tester.GetContractReader(t)
 				require.NoError(t, cr.Bind(ctx, bindings))
 				result, err := cr.BatchGetLatestValues(ctx, batchGetLatestValueRequest)
 				require.NoError(t, err)
@@ -941,9 +954,11 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 		{
 			Name: ContractReaderBatchGetLatestValueDifferentParamsResultsRetainOrder,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
+				bindings := tester.GetBindings(t)
 				batchCallEntry := make(BatchCallEntry)
 				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
-				bindings := tester.GetBindings(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				for i := 0; i < 10; i++ {
@@ -956,10 +971,9 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 						types.BatchRead{ReadName: MethodTakingLatestParamsReturningTestStruct, Params: &LatestParams{I: 1 + i}, ReturnVal: &TestStruct{}},
 					)
 				}
-				batchContractWrite(t, tester, batchCallEntry, mockRun)
+				batchContractWrite(t, tester, cw, bindings, batchCallEntry, mockRun)
 
 				ctx := tests.Context(t)
-				cr := tester.GetContractReader(t)
 				require.NoError(t, cr.Bind(ctx, bindings))
 
 				result, err := cr.BatchGetLatestValues(ctx, batchGetLatestValueRequest)
@@ -977,9 +991,11 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 		{
 			Name: ContractReaderBatchGetLatestValueDifferentParamsResultsRetainOrderMultipleContracts,
 			Test: func(t T) {
+				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
+				bindings := tester.GetBindings(t)
 				batchCallEntry := make(BatchCallEntry)
 				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
-				bindings := tester.GetBindings(t)
 				bound1 := BindingsByName(bindings, AnyContractName)[0]
 				bound2 := BindingsByName(bindings, AnySecondContractName)[0]
 
@@ -992,10 +1008,9 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 					batchGetLatestValueRequest[bound1] = append(batchGetLatestValueRequest[bound1], types.BatchRead{ReadName: MethodTakingLatestParamsReturningTestStruct, Params: &LatestParams{I: 1 + i}, ReturnVal: &TestStruct{}})
 					batchGetLatestValueRequest[bound2] = append(batchGetLatestValueRequest[bound2], types.BatchRead{ReadName: MethodTakingLatestParamsReturningTestStruct, Params: &LatestParams{I: 1 + i}, ReturnVal: &TestStruct{}})
 				}
-				batchContractWrite(t, tester, batchCallEntry, mockRun)
+				batchContractWrite(t, tester, cw, bindings, batchCallEntry, mockRun)
 
 				ctx := tests.Context(t)
-				cr := tester.GetContractReader(t)
 				require.NoError(t, cr.Bind(ctx, bindings))
 
 				result, err := cr.BatchGetLatestValues(ctx, batchGetLatestValueRequest)
@@ -1026,6 +1041,7 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			Name: ContractReaderBatchGetLatestValueSetsErrorsProperly,
 			Test: func(t T) {
 				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
+				cr := tester.GetContractReader(t)
 				bindings := tester.GetBindings(t)
 				bound1 := BindingsByName(bindings, AnyContractName)[0]
 				bound2 := BindingsByName(bindings, AnySecondContractName)[0]
@@ -1037,7 +1053,6 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 				}
 
 				ctx := tests.Context(t)
-				cr := tester.GetContractReader(t)
 				require.NoError(t, cr.Bind(ctx, bindings))
 
 				result, err := cr.BatchGetLatestValues(ctx, batchGetLatestValueRequest)
@@ -1057,20 +1072,24 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			},
 		},
 	}
-	RunTests(t, tester, testCases)
+	if parallel {
+		RunTestsInParallel(t, tester, testCases)
+	} else {
+		RunTests(t, tester, testCases)
+	}
 }
 
-func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T]) {
+func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], parallel bool) {
 	tests := []Testcase[T]{
 		{
 			Name: ContractReaderQueryKeyNotFound,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
-				require.NoError(t, cr.Bind(ctx, tester.GetBindings(t)))
+				require.NoError(t, cr.Bind(ctx, bindings))
 
 				logs, err := cr.QueryKey(ctx, bound, query.KeyFilter{Key: EventName}, query.LimitAndSort{}, &TestStruct{})
 
@@ -1081,17 +1100,18 @@ func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfa
 		{
 			Name: ContractReaderQueryKeyReturnsData,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				boundContract := BindingsByName(bindings, AnyContractName)[0]
 
 				ts1 := CreateTestStruct[T](0, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts1, boundContract, types.Unconfirmed)
 				ts2 := CreateTestStruct[T](1, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts2, boundContract, types.Unconfirmed)
 
 				ts := &TestStruct{}
 				require.Eventually(t, func() bool {
@@ -1104,17 +1124,18 @@ func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfa
 		{
 			Name: ContractReaderQueryKeyReturnsDataAsValuesDotValue,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				bound := BindingsByName(bindings, AnyContractName)[0]
 
 				ts1 := CreateTestStruct[T](0, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1, bindings[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts1, bindings[0], types.Unconfirmed)
 				ts2 := CreateTestStruct[T](1, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2, bindings[0], types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts2, bindings[0], types.Unconfirmed)
 
 				var value values.Value
 
@@ -1144,19 +1165,20 @@ func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfa
 		{
 			Name: ContractReaderQueryKeyCanFilterWithValueComparator,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				boundContract := BindingsByName(bindings, AnyContractName)[0]
 
 				ts1 := CreateTestStruct[T](0, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts1, boundContract, types.Unconfirmed)
 				ts2 := CreateTestStruct[T](15, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts2, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts2, boundContract, types.Unconfirmed)
 				ts3 := CreateTestStruct[T](35, tester)
-				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts3, boundContract, types.Unconfirmed)
+				_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, ts3, boundContract, types.Unconfirmed)
 
 				ts := &TestStruct{}
 				require.Eventually(t, func() bool {
@@ -1180,9 +1202,10 @@ func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfa
 		{
 			Name: ContractReaderQueryKeyCanLimitResultsWithCursor,
 			Test: func(t T) {
-				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
+				cw := tester.GetContractWriter(t)
 				bindings := tester.GetBindings(t)
+				ctx := tests.Context(t)
 
 				require.NoError(t, cr.Bind(ctx, bindings))
 				boundContract := BindingsByName(bindings, AnyContractName)[0]
@@ -1194,7 +1217,7 @@ func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfa
 				for idx := range testStructs {
 					testStructs[idx] = CreateTestStruct(idx*2, tester)
 
-					_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, testStructs[idx], boundContract, types.Unconfirmed)
+					_ = SubmitTransactionToCW(t, tester, cw, MethodTriggeringEvent, testStructs[idx], boundContract, types.Unconfirmed)
 				}
 
 				require.Eventually(t, func() bool {
@@ -1230,7 +1253,11 @@ func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfa
 		},
 	}
 
-	RunTests(t, tester, tests)
+	if parallel {
+		RunTestsInParallel(t, tester, tests)
+	} else {
+		RunTests(t, tester, tests)
+	}
 }
 
 func BindingsByName(bindings []types.BoundContract, name string) []types.BoundContract {
diff --git a/pkg/types/interfacetests/utils.go b/pkg/types/interfacetests/utils.go
index 5f81cd206..93c35c0fe 100644
--- a/pkg/types/interfacetests/utils.go
+++ b/pkg/types/interfacetests/utils.go
@@ -52,6 +52,7 @@ type TestingT[T any] interface {
 	tests.TestingT
 	Failed() bool
 	Run(name string, f func(t T)) bool
+	Parallel()
 }
 
 // Tests execution utility function that will consider enabled / disabled test cases according to
@@ -69,17 +70,29 @@ func RunTests[T TestingT[T]](t T, tester BasicTester[T], tests []Testcase[T]) {
 	})
 }
 
+func RunTestsInParallel[T TestingT[T]](t T, tester BasicTester[T], tests []Testcase[T]) {
+	// Assumes Setup() called on tester initialization to avoid race conditions on tester setup
+	t.Run(tester.Name(), func(t T) {
+		for _, test := range tests {
+			if !tester.IsDisabled(test.Name) {
+				t.Run(test.Name, func(t T) {
+					t.Parallel()
+					test.Test(t)
+				})
+			}
+		}
+	})
+}
+
 // Batch contract write takes a batch call entry and writes it to the chain using the ContractWriter.
-func batchContractWrite[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], batchCallEntry BatchCallEntry, mockRun bool) {
+func batchContractWrite[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], cw types.ContractWriter, boundContracts []types.BoundContract, batchCallEntry BatchCallEntry, mockRun bool) {
 	// This is necessary because the mock helper function requires the entire batchCallEntry rather than an individual testStruct
 	if mockRun {
-		cw := tester.GetContractWriter(t)
 		err := cw.SubmitTransaction(tests.Context(t), AnyContractName, "batchContractWrite", batchCallEntry, "", "", nil, big.NewInt(0))
 		require.NoError(t, err)
 		return
 	}
 	nameToAddress := make(map[string]string)
-	boundContracts := tester.GetBindings(t)
 	for _, bc := range boundContracts {
 		nameToAddress[bc.Name] = bc.Address
 	}
@@ -92,27 +105,26 @@ func batchContractWrite[T TestingT[T]](t T, tester ChainComponentsInterfaceTeste
 			if !isOk {
 				require.Fail(t, "expected *TestStruct for contract: %s read: %s, but received %T", contract.Name, readEntry.Name, readEntry.ReturnValue)
 			}
-			SubmitTransactionToCW(t, tester, MethodSettingStruct, val, types.BoundContract{Name: contract.Name, Address: nameToAddress[contract.Name]}, types.Unconfirmed)
+			SubmitTransactionToCW(t, tester, cw, MethodSettingStruct, val, types.BoundContract{Name: contract.Name, Address: nameToAddress[contract.Name]}, types.Unconfirmed)
 		}
 	}
 }
 
 // SubmitTransactionToCW submits a transaction to the ContractWriter and waits for it to reach the given status.
-func SubmitTransactionToCW[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], method string, args any, contract types.BoundContract, status types.TransactionStatus) string {
+func SubmitTransactionToCW[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], cw types.ContractWriter, method string, args any, contract types.BoundContract, status types.TransactionStatus) string {
 	tester.DirtyContracts()
 	txID := uuid.New().String()
-	cw := tester.GetContractWriter(t)
 	err := cw.SubmitTransaction(tests.Context(t), contract.Name, method, args, txID, contract.Address, nil, big.NewInt(0))
 	require.NoError(t, err)
 
-	err = WaitForTransactionStatus(t, tester, txID, status, false)
+	err = WaitForTransactionStatus(t, tester, cw, txID, status, false)
 	require.NoError(t, err)
 
 	return txID
 }
 
 // WaitForTransactionStatus waits for a transaction to reach the given status.
-func WaitForTransactionStatus[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], txID string, status types.TransactionStatus, mockRun bool) error {
+func WaitForTransactionStatus[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], cw types.ContractWriter, txID string, status types.TransactionStatus, mockRun bool) error {
 	ctx, cancel := context.WithTimeout(tests.Context(t), 15*time.Minute)
 	defer cancel()
 
@@ -128,7 +140,7 @@ func WaitForTransactionStatus[T TestingT[T]](t T, tester ChainComponentsInterfac
 				tester.GenerateBlocksTillConfidenceLevel(t, "", "", primitives.Finalized)
 				return nil
 			}
-			current, err := tester.GetContractWriter(t).GetTransactionStatus(ctx, txID)
+			current, err := cw.GetTransactionStatus(ctx, txID)
 			if err != nil {
 				return fmt.Errorf("failed to get transaction status: %w", err)
 			}