all/mocks: regenerate with mockery v3

2 files changed, 283 insertions, 187 deletions

diff --git a/vm/proxyapp/mocks/ProxyAppInterface.go b/vm/proxyapp/mocks/ProxyAppInterface.go
index a79afbb0e..0255990cc 100644
--- a/vm/proxyapp/mocks/ProxyAppInterface.go
+++ b/vm/proxyapp/mocks/ProxyAppInterface.go
@@ -1,12 +1,28 @@
-// Code generated by mockery v2.52.1. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks
 
 import (
-	proxyrpc "github.com/google/syzkaller/vm/proxyapp/proxyrpc"
+	"github.com/google/syzkaller/vm/proxyapp/proxyrpc"
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewProxyAppInterface creates a new instance of ProxyAppInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewProxyAppInterface(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *ProxyAppInterface {
+	mock := &ProxyAppInterface{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // ProxyAppInterface is an autogenerated mock type for the ProxyAppInterface type
 type ProxyAppInterface struct {
 	mock.Mock
@@ -20,21 +36,20 @@ func (_m *ProxyAppInterface) EXPECT() *ProxyAppInterface_Expecter {
 	return &ProxyAppInterface_Expecter{mock: &_m.Mock}
 }
 
-// Close provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) Close(in proxyrpc.CloseParams, out *proxyrpc.CloseReply) error {
-	ret := _m.Called(in, out)
+// Close provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) Close(in proxyrpc.CloseParams, out *proxyrpc.CloseReply) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Close")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.CloseParams, *proxyrpc.CloseReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CloseParams, *proxyrpc.CloseReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -52,36 +67,46 @@ func (_e *ProxyAppInterface_Expecter) Close(in interface{}, out interface{}) *Pr
 
 func (_c *ProxyAppInterface_Close_Call) Run(run func(in proxyrpc.CloseParams, out *proxyrpc.CloseReply)) *ProxyAppInterface_Close_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.CloseParams), args[1].(*proxyrpc.CloseReply))
+		var arg0 proxyrpc.CloseParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.CloseParams)
+		}
+		var arg1 *proxyrpc.CloseReply
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.CloseReply)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_Close_Call) Return(_a0 error) *ProxyAppInterface_Close_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_Close_Call) Return(err error) *ProxyAppInterface_Close_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_Close_Call) RunAndReturn(run func(proxyrpc.CloseParams, *proxyrpc.CloseReply) error) *ProxyAppInterface_Close_Call {
+func (_c *ProxyAppInterface_Close_Call) RunAndReturn(run func(in proxyrpc.CloseParams, out *proxyrpc.CloseReply) error) *ProxyAppInterface_Close_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Copy provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) Copy(in proxyrpc.CopyParams, out *proxyrpc.CopyResult) error {
-	ret := _m.Called(in, out)
+// Copy provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) Copy(in proxyrpc.CopyParams, out *proxyrpc.CopyResult) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Copy")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.CopyParams, *proxyrpc.CopyResult) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CopyParams, *proxyrpc.CopyResult) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -99,36 +124,46 @@ func (_e *ProxyAppInterface_Expecter) Copy(in interface{}, out interface{}) *Pro
 
 func (_c *ProxyAppInterface_Copy_Call) Run(run func(in proxyrpc.CopyParams, out *proxyrpc.CopyResult)) *ProxyAppInterface_Copy_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.CopyParams), args[1].(*proxyrpc.CopyResult))
+		var arg0 proxyrpc.CopyParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.CopyParams)
+		}
+		var arg1 *proxyrpc.CopyResult
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.CopyResult)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_Copy_Call) Return(_a0 error) *ProxyAppInterface_Copy_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_Copy_Call) Return(err error) *ProxyAppInterface_Copy_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_Copy_Call) RunAndReturn(run func(proxyrpc.CopyParams, *proxyrpc.CopyResult) error) *ProxyAppInterface_Copy_Call {
+func (_c *ProxyAppInterface_Copy_Call) RunAndReturn(run func(in proxyrpc.CopyParams, out *proxyrpc.CopyResult) error) *ProxyAppInterface_Copy_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// CreateInstance provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) CreateInstance(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult) error {
-	ret := _m.Called(in, out)
+// CreateInstance provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) CreateInstance(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for CreateInstance")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -146,36 +181,46 @@ func (_e *ProxyAppInterface_Expecter) CreateInstance(in interface{}, out interfa
 
 func (_c *ProxyAppInterface_CreateInstance_Call) Run(run func(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult)) *ProxyAppInterface_CreateInstance_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.CreateInstanceParams), args[1].(*proxyrpc.CreateInstanceResult))
+		var arg0 proxyrpc.CreateInstanceParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.CreateInstanceParams)
+		}
+		var arg1 *proxyrpc.CreateInstanceResult
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.CreateInstanceResult)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_CreateInstance_Call) Return(_a0 error) *ProxyAppInterface_CreateInstance_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_CreateInstance_Call) Return(err error) *ProxyAppInterface_CreateInstance_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_CreateInstance_Call) RunAndReturn(run func(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error) *ProxyAppInterface_CreateInstance_Call {
+func (_c *ProxyAppInterface_CreateInstance_Call) RunAndReturn(run func(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult) error) *ProxyAppInterface_CreateInstance_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// CreatePool provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) CreatePool(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult) error {
-	ret := _m.Called(in, out)
+// CreatePool provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) CreatePool(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for CreatePool")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -193,36 +238,46 @@ func (_e *ProxyAppInterface_Expecter) CreatePool(in interface{}, out interface{}
 
 func (_c *ProxyAppInterface_CreatePool_Call) Run(run func(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult)) *ProxyAppInterface_CreatePool_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.CreatePoolParams), args[1].(*proxyrpc.CreatePoolResult))
+		var arg0 proxyrpc.CreatePoolParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.CreatePoolParams)
+		}
+		var arg1 *proxyrpc.CreatePoolResult
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.CreatePoolResult)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_CreatePool_Call) Return(_a0 error) *ProxyAppInterface_CreatePool_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_CreatePool_Call) Return(err error) *ProxyAppInterface_CreatePool_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_CreatePool_Call) RunAndReturn(run func(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error) *ProxyAppInterface_CreatePool_Call {
+func (_c *ProxyAppInterface_CreatePool_Call) RunAndReturn(run func(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult) error) *ProxyAppInterface_CreatePool_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Diagnose provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) Diagnose(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply) error {
-	ret := _m.Called(in, out)
+// Diagnose provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) Diagnose(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Diagnose")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -240,36 +295,46 @@ func (_e *ProxyAppInterface_Expecter) Diagnose(in interface{}, out interface{})
 
 func (_c *ProxyAppInterface_Diagnose_Call) Run(run func(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply)) *ProxyAppInterface_Diagnose_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.DiagnoseParams), args[1].(*proxyrpc.DiagnoseReply))
+		var arg0 proxyrpc.DiagnoseParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.DiagnoseParams)
+		}
+		var arg1 *proxyrpc.DiagnoseReply
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.DiagnoseReply)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_Diagnose_Call) Return(_a0 error) *ProxyAppInterface_Diagnose_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_Diagnose_Call) Return(err error) *ProxyAppInterface_Diagnose_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_Diagnose_Call) RunAndReturn(run func(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error) *ProxyAppInterface_Diagnose_Call {
+func (_c *ProxyAppInterface_Diagnose_Call) RunAndReturn(run func(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply) error) *ProxyAppInterface_Diagnose_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Forward provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) Forward(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult) error {
-	ret := _m.Called(in, out)
+// Forward provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) Forward(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for Forward")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -287,36 +352,46 @@ func (_e *ProxyAppInterface_Expecter) Forward(in interface{}, out interface{}) *
 
 func (_c *ProxyAppInterface_Forward_Call) Run(run func(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult)) *ProxyAppInterface_Forward_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.ForwardParams), args[1].(*proxyrpc.ForwardResult))
+		var arg0 proxyrpc.ForwardParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.ForwardParams)
+		}
+		var arg1 *proxyrpc.ForwardResult
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.ForwardResult)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_Forward_Call) Return(_a0 error) *ProxyAppInterface_Forward_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_Forward_Call) Return(err error) *ProxyAppInterface_Forward_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_Forward_Call) RunAndReturn(run func(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error) *ProxyAppInterface_Forward_Call {
+func (_c *ProxyAppInterface_Forward_Call) RunAndReturn(run func(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult) error) *ProxyAppInterface_Forward_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// PoolLogs provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) PoolLogs(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply) error {
-	ret := _m.Called(in, out)
+// PoolLogs provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) PoolLogs(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for PoolLogs")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -334,36 +409,46 @@ func (_e *ProxyAppInterface_Expecter) PoolLogs(in interface{}, out interface{})
 
 func (_c *ProxyAppInterface_PoolLogs_Call) Run(run func(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply)) *ProxyAppInterface_PoolLogs_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.PoolLogsParam), args[1].(*proxyrpc.PoolLogsReply))
+		var arg0 proxyrpc.PoolLogsParam
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.PoolLogsParam)
+		}
+		var arg1 *proxyrpc.PoolLogsReply
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.PoolLogsReply)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_PoolLogs_Call) Return(_a0 error) *ProxyAppInterface_PoolLogs_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_PoolLogs_Call) Return(err error) *ProxyAppInterface_PoolLogs_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_PoolLogs_Call) RunAndReturn(run func(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error) *ProxyAppInterface_PoolLogs_Call {
+func (_c *ProxyAppInterface_PoolLogs_Call) RunAndReturn(run func(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply) error) *ProxyAppInterface_PoolLogs_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// RunReadProgress provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) RunReadProgress(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply) error {
-	ret := _m.Called(in, out)
+// RunReadProgress provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) RunReadProgress(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for RunReadProgress")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -381,36 +466,46 @@ func (_e *ProxyAppInterface_Expecter) RunReadProgress(in interface{}, out interf
 
 func (_c *ProxyAppInterface_RunReadProgress_Call) Run(run func(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply)) *ProxyAppInterface_RunReadProgress_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.RunReadProgressParams), args[1].(*proxyrpc.RunReadProgressReply))
+		var arg0 proxyrpc.RunReadProgressParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.RunReadProgressParams)
+		}
+		var arg1 *proxyrpc.RunReadProgressReply
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.RunReadProgressReply)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_RunReadProgress_Call) Return(_a0 error) *ProxyAppInterface_RunReadProgress_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_RunReadProgress_Call) Return(err error) *ProxyAppInterface_RunReadProgress_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_RunReadProgress_Call) RunAndReturn(run func(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error) *ProxyAppInterface_RunReadProgress_Call {
+func (_c *ProxyAppInterface_RunReadProgress_Call) RunAndReturn(run func(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply) error) *ProxyAppInterface_RunReadProgress_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// RunStart provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) RunStart(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply) error {
-	ret := _m.Called(in, out)
+// RunStart provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) RunStart(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for RunStart")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -428,36 +523,46 @@ func (_e *ProxyAppInterface_Expecter) RunStart(in interface{}, out interface{})
 
 func (_c *ProxyAppInterface_RunStart_Call) Run(run func(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply)) *ProxyAppInterface_RunStart_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.RunStartParams), args[1].(*proxyrpc.RunStartReply))
+		var arg0 proxyrpc.RunStartParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.RunStartParams)
+		}
+		var arg1 *proxyrpc.RunStartReply
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.RunStartReply)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_RunStart_Call) Return(_a0 error) *ProxyAppInterface_RunStart_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_RunStart_Call) Return(err error) *ProxyAppInterface_RunStart_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_RunStart_Call) RunAndReturn(run func(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error) *ProxyAppInterface_RunStart_Call {
+func (_c *ProxyAppInterface_RunStart_Call) RunAndReturn(run func(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply) error) *ProxyAppInterface_RunStart_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// RunStop provides a mock function with given fields: in, out
-func (_m *ProxyAppInterface) RunStop(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error {
-	ret := _m.Called(in, out)
+// RunStop provides a mock function for the type ProxyAppInterface
+func (_mock *ProxyAppInterface) RunStop(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error {
+	ret := _mock.Called(in, out)
 
 	if len(ret) == 0 {
 		panic("no return value specified for RunStop")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error); ok {
-		r0 = rf(in, out)
+	if returnFunc, ok := ret.Get(0).(func(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error); ok {
+		r0 = returnFunc(in, out)
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -475,31 +580,28 @@ func (_e *ProxyAppInterface_Expecter) RunStop(in interface{}, out interface{}) *
 
 func (_c *ProxyAppInterface_RunStop_Call) Run(run func(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply)) *ProxyAppInterface_RunStop_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(proxyrpc.RunStopParams), args[1].(*proxyrpc.RunStopReply))
+		var arg0 proxyrpc.RunStopParams
+		if args[0] != nil {
+			arg0 = args[0].(proxyrpc.RunStopParams)
+		}
+		var arg1 *proxyrpc.RunStopReply
+		if args[1] != nil {
+			arg1 = args[1].(*proxyrpc.RunStopReply)
+		}
+		run(
+			arg0,
+			arg1,
+		)
 	})
 	return _c
 }
 
-func (_c *ProxyAppInterface_RunStop_Call) Return(_a0 error) *ProxyAppInterface_RunStop_Call {
-	_c.Call.Return(_a0)
+func (_c *ProxyAppInterface_RunStop_Call) Return(err error) *ProxyAppInterface_RunStop_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *ProxyAppInterface_RunStop_Call) RunAndReturn(run func(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error) *ProxyAppInterface_RunStop_Call {
+func (_c *ProxyAppInterface_RunStop_Call) RunAndReturn(run func(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error) *ProxyAppInterface_RunStop_Call {
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewProxyAppInterface creates a new instance of ProxyAppInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewProxyAppInterface(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *ProxyAppInterface {
-	mock := &ProxyAppInterface{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/vm/proxyapp/mocks/subProcessCmd.go b/vm/proxyapp/mocks/subProcessCmd.go
index 50961fe0d..aea349fa9 100644
--- a/vm/proxyapp/mocks/subProcessCmd.go
+++ b/vm/proxyapp/mocks/subProcessCmd.go
@@ -1,13 +1,29 @@
-// Code generated by mockery v2.52.1. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks
 
 import (
-	io "io"
+	"io"
 
 	mock "github.com/stretchr/testify/mock"
 )
 
+// NewSubProcessCmd creates a new instance of SubProcessCmd. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSubProcessCmd(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SubProcessCmd {
+	mock := &SubProcessCmd{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
 // SubProcessCmd is an autogenerated mock type for the subProcessCmd type
 type SubProcessCmd struct {
 	mock.Mock
@@ -21,21 +37,20 @@ func (_m *SubProcessCmd) EXPECT() *SubProcessCmd_Expecter {
 	return &SubProcessCmd_Expecter{mock: &_m.Mock}
 }
 
-// Start provides a mock function with no fields
-func (_m *SubProcessCmd) Start() error {
-	ret := _m.Called()
+// Start provides a mock function for the type SubProcessCmd
+func (_mock *SubProcessCmd) Start() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Start")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -56,8 +71,8 @@ func (_c *SubProcessCmd_Start_Call) Run(run func()) *SubProcessCmd_Start_Call {
 	return _c
 }
 
-func (_c *SubProcessCmd_Start_Call) Return(_a0 error) *SubProcessCmd_Start_Call {
-	_c.Call.Return(_a0)
+func (_c *SubProcessCmd_Start_Call) Return(err error) *SubProcessCmd_Start_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -66,9 +81,9 @@ func (_c *SubProcessCmd_Start_Call) RunAndReturn(run func() error) *SubProcessCm
 	return _c
 }
 
-// StderrPipe provides a mock function with no fields
-func (_m *SubProcessCmd) StderrPipe() (io.ReadCloser, error) {
-	ret := _m.Called()
+// StderrPipe provides a mock function for the type SubProcessCmd
+func (_mock *SubProcessCmd) StderrPipe() (io.ReadCloser, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for StderrPipe")
@@ -76,23 +91,21 @@ func (_m *SubProcessCmd) StderrPipe() (io.ReadCloser, error) {
 
 	var r0 io.ReadCloser
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (io.ReadCloser, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (io.ReadCloser, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() io.ReadCloser); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() io.ReadCloser); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(io.ReadCloser)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -113,8 +126,8 @@ func (_c *SubProcessCmd_StderrPipe_Call) Run(run func()) *SubProcessCmd_StderrPi
 	return _c
 }
 
-func (_c *SubProcessCmd_StderrPipe_Call) Return(_a0 io.ReadCloser, _a1 error) *SubProcessCmd_StderrPipe_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *SubProcessCmd_StderrPipe_Call) Return(readCloser io.ReadCloser, err error) *SubProcessCmd_StderrPipe_Call {
+	_c.Call.Return(readCloser, err)
 	return _c
 }
 
@@ -123,9 +136,9 @@ func (_c *SubProcessCmd_StderrPipe_Call) RunAndReturn(run func() (io.ReadCloser,
 	return _c
 }
 
-// StdinPipe provides a mock function with no fields
-func (_m *SubProcessCmd) StdinPipe() (io.WriteCloser, error) {
-	ret := _m.Called()
+// StdinPipe provides a mock function for the type SubProcessCmd
+func (_mock *SubProcessCmd) StdinPipe() (io.WriteCloser, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for StdinPipe")
@@ -133,23 +146,21 @@ func (_m *SubProcessCmd) StdinPipe() (io.WriteCloser, error) {
 
 	var r0 io.WriteCloser
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (io.WriteCloser, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (io.WriteCloser, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() io.WriteCloser); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() io.WriteCloser); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(io.WriteCloser)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -170,8 +181,8 @@ func (_c *SubProcessCmd_StdinPipe_Call) Run(run func()) *SubProcessCmd_StdinPipe
 	return _c
 }
 
-func (_c *SubProcessCmd_StdinPipe_Call) Return(_a0 io.WriteCloser, _a1 error) *SubProcessCmd_StdinPipe_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *SubProcessCmd_StdinPipe_Call) Return(writeCloser io.WriteCloser, err error) *SubProcessCmd_StdinPipe_Call {
+	_c.Call.Return(writeCloser, err)
 	return _c
 }
 
@@ -180,9 +191,9 @@ func (_c *SubProcessCmd_StdinPipe_Call) RunAndReturn(run func() (io.WriteCloser,
 	return _c
 }
 
-// StdoutPipe provides a mock function with no fields
-func (_m *SubProcessCmd) StdoutPipe() (io.ReadCloser, error) {
-	ret := _m.Called()
+// StdoutPipe provides a mock function for the type SubProcessCmd
+func (_mock *SubProcessCmd) StdoutPipe() (io.ReadCloser, error) {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for StdoutPipe")
@@ -190,23 +201,21 @@ func (_m *SubProcessCmd) StdoutPipe() (io.ReadCloser, error) {
 
 	var r0 io.ReadCloser
 	var r1 error
-	if rf, ok := ret.Get(0).(func() (io.ReadCloser, error)); ok {
-		return rf()
+	if returnFunc, ok := ret.Get(0).(func() (io.ReadCloser, error)); ok {
+		return returnFunc()
 	}
-	if rf, ok := ret.Get(0).(func() io.ReadCloser); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() io.ReadCloser); ok {
+		r0 = returnFunc()
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(io.ReadCloser)
 		}
 	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if returnFunc, ok := ret.Get(1).(func() error); ok {
+		r1 = returnFunc()
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
@@ -227,8 +236,8 @@ func (_c *SubProcessCmd_StdoutPipe_Call) Run(run func()) *SubProcessCmd_StdoutPi
 	return _c
 }
 
-func (_c *SubProcessCmd_StdoutPipe_Call) Return(_a0 io.ReadCloser, _a1 error) *SubProcessCmd_StdoutPipe_Call {
-	_c.Call.Return(_a0, _a1)
+func (_c *SubProcessCmd_StdoutPipe_Call) Return(readCloser io.ReadCloser, err error) *SubProcessCmd_StdoutPipe_Call {
+	_c.Call.Return(readCloser, err)
 	return _c
 }
 
@@ -237,21 +246,20 @@ func (_c *SubProcessCmd_StdoutPipe_Call) RunAndReturn(run func() (io.ReadCloser,
 	return _c
 }
 
-// Wait provides a mock function with no fields
-func (_m *SubProcessCmd) Wait() error {
-	ret := _m.Called()
+// Wait provides a mock function for the type SubProcessCmd
+func (_mock *SubProcessCmd) Wait() error {
+	ret := _mock.Called()
 
 	if len(ret) == 0 {
 		panic("no return value specified for Wait")
 	}
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
+	if returnFunc, ok := ret.Get(0).(func() error); ok {
+		r0 = returnFunc()
 	} else {
 		r0 = ret.Error(0)
 	}
-
 	return r0
 }
 
@@ -272,8 +280,8 @@ func (_c *SubProcessCmd_Wait_Call) Run(run func()) *SubProcessCmd_Wait_Call {
 	return _c
 }
 
-func (_c *SubProcessCmd_Wait_Call) Return(_a0 error) *SubProcessCmd_Wait_Call {
-	_c.Call.Return(_a0)
+func (_c *SubProcessCmd_Wait_Call) Return(err error) *SubProcessCmd_Wait_Call {
+	_c.Call.Return(err)
 	return _c
 }
 
@@ -281,17 +289,3 @@ func (_c *SubProcessCmd_Wait_Call) RunAndReturn(run func() error) *SubProcessCmd
 	_c.Call.Return(run)
 	return _c
 }
-
-// NewSubProcessCmd creates a new instance of SubProcessCmd. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewSubProcessCmd(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *SubProcessCmd {
-	mock := &SubProcessCmd{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}