// Code generated by MockGen. DO NOT EDIT.
// Source: ./chains/evm/calls/transactor/itx/itx.go

// Package mock_itx is a generated GoMock package.
package mock_itx

import (
	context "context"
	big "math/big"
	reflect "reflect"

	transactor "github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor"
	common "github.com/ethereum/go-ethereum/common"
	gomock "github.com/golang/mock/gomock"
)

// MockRelayCaller is a mock of RelayCaller interface.
type MockRelayCaller struct {
	ctrl     *gomock.Controller
	recorder *MockRelayCallerMockRecorder
}

// MockRelayCallerMockRecorder is the mock recorder for MockRelayCaller.
type MockRelayCallerMockRecorder struct {
	mock *MockRelayCaller
}

// NewMockRelayCaller creates a new mock instance.
func NewMockRelayCaller(ctrl *gomock.Controller) *MockRelayCaller {
	mock := &MockRelayCaller{ctrl: ctrl}
	mock.recorder = &MockRelayCallerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRelayCaller) EXPECT() *MockRelayCallerMockRecorder {
	return m.recorder
}

// CallContext mocks base method.
func (m *MockRelayCaller) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, result, method}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CallContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CallContext indicates an expected call of CallContext.
func (mr *MockRelayCallerMockRecorder) CallContext(ctx, result, method interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, result, method}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContext", reflect.TypeOf((*MockRelayCaller)(nil).CallContext), varargs...)
}

// MockForwarder is a mock of Forwarder interface.
type MockForwarder struct {
	ctrl     *gomock.Controller
	recorder *MockForwarderMockRecorder
}

// MockForwarderMockRecorder is the mock recorder for MockForwarder.
type MockForwarderMockRecorder struct {
	mock *MockForwarder
}

// NewMockForwarder creates a new mock instance.
func NewMockForwarder(ctrl *gomock.Controller) *MockForwarder {
	mock := &MockForwarder{ctrl: ctrl}
	mock.recorder = &MockForwarderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockForwarder) EXPECT() *MockForwarderMockRecorder {
	return m.recorder
}

// ChainId mocks base method.
func (m *MockForwarder) ChainId() *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChainId")
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// ChainId indicates an expected call of ChainId.
func (mr *MockForwarderMockRecorder) ChainId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainId", reflect.TypeOf((*MockForwarder)(nil).ChainId))
}

// ForwarderAddress mocks base method.
func (m *MockForwarder) ForwarderAddress() common.Address {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForwarderAddress")
	ret0, _ := ret[0].(common.Address)
	return ret0
}

// ForwarderAddress indicates an expected call of ForwarderAddress.
func (mr *MockForwarderMockRecorder) ForwarderAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForwarderAddress", reflect.TypeOf((*MockForwarder)(nil).ForwarderAddress))
}

// ForwarderData mocks base method.
func (m *MockForwarder) ForwarderData(to *common.Address, data []byte, opts transactor.TransactOptions) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForwarderData", to, data, opts)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForwarderData indicates an expected call of ForwarderData.
func (mr *MockForwarderMockRecorder) ForwarderData(to, data, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForwarderData", reflect.TypeOf((*MockForwarder)(nil).ForwarderData), to, data, opts)
}

// LockNonce mocks base method.
func (m *MockForwarder) LockNonce() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LockNonce")
}

// LockNonce indicates an expected call of LockNonce.
func (mr *MockForwarderMockRecorder) LockNonce() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockNonce", reflect.TypeOf((*MockForwarder)(nil).LockNonce))
}

// UnlockNonce mocks base method.
func (m *MockForwarder) UnlockNonce() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UnlockNonce")
}

// UnlockNonce indicates an expected call of UnlockNonce.
func (mr *MockForwarderMockRecorder) UnlockNonce() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockNonce", reflect.TypeOf((*MockForwarder)(nil).UnlockNonce))
}

// UnsafeIncreaseNonce mocks base method.
func (m *MockForwarder) UnsafeIncreaseNonce() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UnsafeIncreaseNonce")
}

// UnsafeIncreaseNonce indicates an expected call of UnsafeIncreaseNonce.
func (mr *MockForwarderMockRecorder) UnsafeIncreaseNonce() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsafeIncreaseNonce", reflect.TypeOf((*MockForwarder)(nil).UnsafeIncreaseNonce))
}

// UnsafeNonce mocks base method.
func (m *MockForwarder) UnsafeNonce() (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnsafeNonce")
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnsafeNonce indicates an expected call of UnsafeNonce.
func (mr *MockForwarderMockRecorder) UnsafeNonce() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsafeNonce", reflect.TypeOf((*MockForwarder)(nil).UnsafeNonce))
}

// MockSigner is a mock of Signer interface.
type MockSigner struct {
	ctrl     *gomock.Controller
	recorder *MockSignerMockRecorder
}

// MockSignerMockRecorder is the mock recorder for MockSigner.
type MockSignerMockRecorder struct {
	mock *MockSigner
}

// NewMockSigner creates a new mock instance.
func NewMockSigner(ctrl *gomock.Controller) *MockSigner {
	mock := &MockSigner{ctrl: ctrl}
	mock.recorder = &MockSignerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSigner) EXPECT() *MockSignerMockRecorder {
	return m.recorder
}

// CommonAddress mocks base method.
func (m *MockSigner) CommonAddress() common.Address {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommonAddress")
	ret0, _ := ret[0].(common.Address)
	return ret0
}

// CommonAddress indicates an expected call of CommonAddress.
func (mr *MockSignerMockRecorder) CommonAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommonAddress", reflect.TypeOf((*MockSigner)(nil).CommonAddress))
}

// Sign mocks base method.
func (m *MockSigner) Sign(digestHash []byte) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sign", digestHash)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Sign indicates an expected call of Sign.
func (mr *MockSignerMockRecorder) Sign(digestHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sign", reflect.TypeOf((*MockSigner)(nil).Sign), digestHash)
}
