// Code generated by MockGen. DO NOT EDIT.
// Source: bitbon/interfaces.go

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

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

	gomock "github.com/golang/mock/gomock"
	contracts "github.com/simcord-llc/bitbon-system-blockchain/bitbon/contracts"
	contract_snapshot "github.com/simcord-llc/bitbon-system-blockchain/bitbon/contracts/contract_snapshot"
	dto "github.com/simcord-llc/bitbon-system-blockchain/bitbon/dto"
	models "github.com/simcord-llc/bitbon-system-blockchain/bitbon/models"
	noncer "github.com/simcord-llc/bitbon-system-blockchain/bitbon/noncer"
	common "github.com/simcord-llc/bitbon-system-blockchain/common"
)

// MockTransferManager is a mock of TransferManager interface.
type MockTransferManager struct {
	ctrl     *gomock.Controller
	recorder *MockTransferManagerMockRecorder
}

// MockTransferManagerMockRecorder is the mock recorder for MockTransferManager.
type MockTransferManagerMockRecorder struct {
	mock *MockTransferManager
}

// NewMockTransferManager creates a new mock instance.
func NewMockTransferManager(ctrl *gomock.Controller) *MockTransferManager {
	mock := &MockTransferManager{ctrl: ctrl}
	mock.recorder = &MockTransferManagerMockRecorder{mock}
	return mock
}

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

// ApproveFullBalanceSafeTransfer mocks base method.
func (m *MockTransferManager) ApproveFullBalanceSafeTransfer(ctx context.Context, transfer *models.ApproveTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveFullBalanceSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApproveFullBalanceSafeTransfer indicates an expected call of ApproveFullBalanceSafeTransfer.
func (mr *MockTransferManagerMockRecorder) ApproveFullBalanceSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveFullBalanceSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).ApproveFullBalanceSafeTransfer), ctx, transfer)
}

// ApproveFullBalanceSafeTransferAsync mocks base method.
func (m *MockTransferManager) ApproveFullBalanceSafeTransferAsync(ctx context.Context, transfer *models.ApproveTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveFullBalanceSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApproveFullBalanceSafeTransferAsync indicates an expected call of ApproveFullBalanceSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) ApproveFullBalanceSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveFullBalanceSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).ApproveFullBalanceSafeTransferAsync), ctx, transfer)
}

// ApproveFullBalanceWPCSafeTransfer mocks base method.
func (m *MockTransferManager) ApproveFullBalanceWPCSafeTransfer(ctx context.Context, transfer *models.ApproveTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveFullBalanceWPCSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApproveFullBalanceWPCSafeTransfer indicates an expected call of ApproveFullBalanceWPCSafeTransfer.
func (mr *MockTransferManagerMockRecorder) ApproveFullBalanceWPCSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveFullBalanceWPCSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).ApproveFullBalanceWPCSafeTransfer), ctx, transfer)
}

// ApproveFullBalanceWPCSafeTransferAsync mocks base method.
func (m *MockTransferManager) ApproveFullBalanceWPCSafeTransferAsync(ctx context.Context, transfer *models.ApproveTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveFullBalanceWPCSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApproveFullBalanceWPCSafeTransferAsync indicates an expected call of ApproveFullBalanceWPCSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) ApproveFullBalanceWPCSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveFullBalanceWPCSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).ApproveFullBalanceWPCSafeTransferAsync), ctx, transfer)
}

// ApproveSafeTransfer mocks base method.
func (m *MockTransferManager) ApproveSafeTransfer(ctx context.Context, transfer *models.ApproveTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApproveSafeTransfer indicates an expected call of ApproveSafeTransfer.
func (mr *MockTransferManagerMockRecorder) ApproveSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).ApproveSafeTransfer), ctx, transfer)
}

// ApproveSafeTransferAsync mocks base method.
func (m *MockTransferManager) ApproveSafeTransferAsync(ctx context.Context, transfer *models.ApproveTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApproveSafeTransferAsync indicates an expected call of ApproveSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) ApproveSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).ApproveSafeTransferAsync), ctx, transfer)
}

// ApproveWPCSafeTransfer mocks base method.
func (m *MockTransferManager) ApproveWPCSafeTransfer(ctx context.Context, transfer *models.ApproveTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveWPCSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApproveWPCSafeTransfer indicates an expected call of ApproveWPCSafeTransfer.
func (mr *MockTransferManagerMockRecorder) ApproveWPCSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveWPCSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).ApproveWPCSafeTransfer), ctx, transfer)
}

// ApproveWPCSafeTransferAsync mocks base method.
func (m *MockTransferManager) ApproveWPCSafeTransferAsync(ctx context.Context, transfer *models.ApproveTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveWPCSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApproveWPCSafeTransferAsync indicates an expected call of ApproveWPCSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) ApproveWPCSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveWPCSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).ApproveWPCSafeTransferAsync), ctx, transfer)
}

// CancelFullBalanceSafeTransfer mocks base method.
func (m *MockTransferManager) CancelFullBalanceSafeTransfer(ctx context.Context, transfer *models.CancelTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelFullBalanceSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelFullBalanceSafeTransfer indicates an expected call of CancelFullBalanceSafeTransfer.
func (mr *MockTransferManagerMockRecorder) CancelFullBalanceSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelFullBalanceSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).CancelFullBalanceSafeTransfer), ctx, transfer)
}

// CancelFullBalanceSafeTransferAsync mocks base method.
func (m *MockTransferManager) CancelFullBalanceSafeTransferAsync(ctx context.Context, transfer *models.CancelTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelFullBalanceSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelFullBalanceSafeTransferAsync indicates an expected call of CancelFullBalanceSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) CancelFullBalanceSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelFullBalanceSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).CancelFullBalanceSafeTransferAsync), ctx, transfer)
}

// CancelFullBalanceWPCSafeTransfer mocks base method.
func (m *MockTransferManager) CancelFullBalanceWPCSafeTransfer(ctx context.Context, transfer *models.CancelTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelFullBalanceWPCSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelFullBalanceWPCSafeTransfer indicates an expected call of CancelFullBalanceWPCSafeTransfer.
func (mr *MockTransferManagerMockRecorder) CancelFullBalanceWPCSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelFullBalanceWPCSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).CancelFullBalanceWPCSafeTransfer), ctx, transfer)
}

// CancelFullBalanceWPCSafeTransferAsync mocks base method.
func (m *MockTransferManager) CancelFullBalanceWPCSafeTransferAsync(ctx context.Context, transfer *models.CancelTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelFullBalanceWPCSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelFullBalanceWPCSafeTransferAsync indicates an expected call of CancelFullBalanceWPCSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) CancelFullBalanceWPCSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelFullBalanceWPCSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).CancelFullBalanceWPCSafeTransferAsync), ctx, transfer)
}

// CancelSafeTransfer mocks base method.
func (m *MockTransferManager) CancelSafeTransfer(ctx context.Context, transfer *models.CancelTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelSafeTransfer indicates an expected call of CancelSafeTransfer.
func (mr *MockTransferManagerMockRecorder) CancelSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).CancelSafeTransfer), ctx, transfer)
}

// CancelSafeTransferAsync mocks base method.
func (m *MockTransferManager) CancelSafeTransferAsync(ctx context.Context, transfer *models.CancelTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelSafeTransferAsync indicates an expected call of CancelSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) CancelSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).CancelSafeTransferAsync), ctx, transfer)
}

// CancelWPCSafeTransfer mocks base method.
func (m *MockTransferManager) CancelWPCSafeTransfer(ctx context.Context, transfer *models.CancelTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelWPCSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelWPCSafeTransfer indicates an expected call of CancelWPCSafeTransfer.
func (mr *MockTransferManagerMockRecorder) CancelWPCSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWPCSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).CancelWPCSafeTransfer), ctx, transfer)
}

// CancelWPCSafeTransferAsync mocks base method.
func (m *MockTransferManager) CancelWPCSafeTransferAsync(ctx context.Context, transfer *models.CancelTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelWPCSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelWPCSafeTransferAsync indicates an expected call of CancelWPCSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) CancelWPCSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWPCSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).CancelWPCSafeTransferAsync), ctx, transfer)
}

// CreateFullBalanceSafeTransfer mocks base method.
func (m *MockTransferManager) CreateFullBalanceSafeTransfer(ctx context.Context, transfer *models.CreateTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFullBalanceSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFullBalanceSafeTransfer indicates an expected call of CreateFullBalanceSafeTransfer.
func (mr *MockTransferManagerMockRecorder) CreateFullBalanceSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullBalanceSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).CreateFullBalanceSafeTransfer), ctx, transfer)
}

// CreateFullBalanceSafeTransferAsync mocks base method.
func (m *MockTransferManager) CreateFullBalanceSafeTransferAsync(ctx context.Context, transfer *models.CreateTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFullBalanceSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFullBalanceSafeTransferAsync indicates an expected call of CreateFullBalanceSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) CreateFullBalanceSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullBalanceSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).CreateFullBalanceSafeTransferAsync), ctx, transfer)
}

// CreateFullBalanceWPCSafeTransfer mocks base method.
func (m *MockTransferManager) CreateFullBalanceWPCSafeTransfer(ctx context.Context, transfer *models.CreateTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFullBalanceWPCSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFullBalanceWPCSafeTransfer indicates an expected call of CreateFullBalanceWPCSafeTransfer.
func (mr *MockTransferManagerMockRecorder) CreateFullBalanceWPCSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullBalanceWPCSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).CreateFullBalanceWPCSafeTransfer), ctx, transfer)
}

// CreateFullBalanceWPCSafeTransferAsync mocks base method.
func (m *MockTransferManager) CreateFullBalanceWPCSafeTransferAsync(ctx context.Context, transfer *models.CreateTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFullBalanceWPCSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFullBalanceWPCSafeTransferAsync indicates an expected call of CreateFullBalanceWPCSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) CreateFullBalanceWPCSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullBalanceWPCSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).CreateFullBalanceWPCSafeTransferAsync), ctx, transfer)
}

// CreateSafeTransfer mocks base method.
func (m *MockTransferManager) CreateSafeTransfer(ctx context.Context, transfer *models.CreateTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSafeTransfer indicates an expected call of CreateSafeTransfer.
func (mr *MockTransferManagerMockRecorder) CreateSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).CreateSafeTransfer), ctx, transfer)
}

// CreateSafeTransferAsync mocks base method.
func (m *MockTransferManager) CreateSafeTransferAsync(ctx context.Context, transfer *models.CreateTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSafeTransferAsync indicates an expected call of CreateSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) CreateSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).CreateSafeTransferAsync), ctx, transfer)
}

// CreateWPCSafeTransfer mocks base method.
func (m *MockTransferManager) CreateWPCSafeTransfer(ctx context.Context, transfer *models.CreateTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWPCSafeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateWPCSafeTransfer indicates an expected call of CreateWPCSafeTransfer.
func (mr *MockTransferManagerMockRecorder) CreateWPCSafeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWPCSafeTransfer", reflect.TypeOf((*MockTransferManager)(nil).CreateWPCSafeTransfer), ctx, transfer)
}

// CreateWPCSafeTransferAsync mocks base method.
func (m *MockTransferManager) CreateWPCSafeTransferAsync(ctx context.Context, transfer *models.CreateTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWPCSafeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateWPCSafeTransferAsync indicates an expected call of CreateWPCSafeTransferAsync.
func (mr *MockTransferManagerMockRecorder) CreateWPCSafeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWPCSafeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).CreateWPCSafeTransferAsync), ctx, transfer)
}

// DirectTransfer mocks base method.
func (m *MockTransferManager) DirectTransfer(ctx context.Context, transfer *models.DirectTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DirectTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DirectTransfer indicates an expected call of DirectTransfer.
func (mr *MockTransferManagerMockRecorder) DirectTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DirectTransfer", reflect.TypeOf((*MockTransferManager)(nil).DirectTransfer), ctx, transfer)
}

// DirectTransferAsync mocks base method.
func (m *MockTransferManager) DirectTransferAsync(ctx context.Context, transfer *models.DirectTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DirectTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DirectTransferAsync indicates an expected call of DirectTransferAsync.
func (mr *MockTransferManagerMockRecorder) DirectTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DirectTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).DirectTransferAsync), ctx, transfer)
}

// ExpireTransfersAsync mocks base method.
func (m *MockTransferManager) ExpireTransfersAsync(ctx context.Context, ids []string) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireTransfersAsync", ctx, ids)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExpireTransfersAsync indicates an expected call of ExpireTransfersAsync.
func (mr *MockTransferManagerMockRecorder) ExpireTransfersAsync(ctx, ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTransfersAsync", reflect.TypeOf((*MockTransferManager)(nil).ExpireTransfersAsync), ctx, ids)
}

// FrameTransfer mocks base method.
func (m *MockTransferManager) FrameTransfer(ctx context.Context, transfer *models.QuickTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FrameTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FrameTransfer indicates an expected call of FrameTransfer.
func (mr *MockTransferManagerMockRecorder) FrameTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FrameTransfer", reflect.TypeOf((*MockTransferManager)(nil).FrameTransfer), ctx, transfer)
}

// FrameTransferAsync mocks base method.
func (m *MockTransferManager) FrameTransferAsync(ctx context.Context, transfer *models.QuickTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FrameTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FrameTransferAsync indicates an expected call of FrameTransferAsync.
func (mr *MockTransferManagerMockRecorder) FrameTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FrameTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).FrameTransferAsync), ctx, transfer)
}

// FullBalanceQuickTransfer mocks base method.
func (m *MockTransferManager) FullBalanceQuickTransfer(ctx context.Context, transfer *models.QuickTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FullBalanceQuickTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FullBalanceQuickTransfer indicates an expected call of FullBalanceQuickTransfer.
func (mr *MockTransferManagerMockRecorder) FullBalanceQuickTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullBalanceQuickTransfer", reflect.TypeOf((*MockTransferManager)(nil).FullBalanceQuickTransfer), ctx, transfer)
}

// FullBalanceQuickTransferAsync mocks base method.
func (m *MockTransferManager) FullBalanceQuickTransferAsync(ctx context.Context, transfer *models.QuickTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FullBalanceQuickTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FullBalanceQuickTransferAsync indicates an expected call of FullBalanceQuickTransferAsync.
func (mr *MockTransferManagerMockRecorder) FullBalanceQuickTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullBalanceQuickTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).FullBalanceQuickTransferAsync), ctx, transfer)
}

// GetTransfer mocks base method.
func (m *MockTransferManager) GetTransfer(ctx context.Context, transferID string) (*contracts.ReceiptTransfer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransfer", ctx, transferID)
	ret0, _ := ret[0].(*contracts.ReceiptTransfer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransfer indicates an expected call of GetTransfer.
func (mr *MockTransferManagerMockRecorder) GetTransfer(ctx, transferID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransfer", reflect.TypeOf((*MockTransferManager)(nil).GetTransfer), ctx, transferID)
}

// GetTransferByIndex mocks base method.
func (m *MockTransferManager) GetTransferByIndex(ctx context.Context, index *big.Int) (*contracts.ReceiptTransfer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransferByIndex", ctx, index)
	ret0, _ := ret[0].(*contracts.ReceiptTransfer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransferByIndex indicates an expected call of GetTransferByIndex.
func (mr *MockTransferManagerMockRecorder) GetTransferByIndex(ctx, index interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferByIndex", reflect.TypeOf((*MockTransferManager)(nil).GetTransferByIndex), ctx, index)
}

// QuickTransfer mocks base method.
func (m *MockTransferManager) QuickTransfer(ctx context.Context, transfer *models.QuickTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuickTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QuickTransfer indicates an expected call of QuickTransfer.
func (mr *MockTransferManagerMockRecorder) QuickTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuickTransfer", reflect.TypeOf((*MockTransferManager)(nil).QuickTransfer), ctx, transfer)
}

// QuickTransferAsync mocks base method.
func (m *MockTransferManager) QuickTransferAsync(ctx context.Context, transfer *models.QuickTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuickTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QuickTransferAsync indicates an expected call of QuickTransferAsync.
func (mr *MockTransferManagerMockRecorder) QuickTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuickTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).QuickTransferAsync), ctx, transfer)
}

// ServiceFeeTransfer mocks base method.
func (m *MockTransferManager) ServiceFeeTransfer(ctx context.Context, transfer *models.ServiceFeeTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServiceFeeTransfer", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceFeeTransfer indicates an expected call of ServiceFeeTransfer.
func (mr *MockTransferManagerMockRecorder) ServiceFeeTransfer(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceFeeTransfer", reflect.TypeOf((*MockTransferManager)(nil).ServiceFeeTransfer), ctx, transfer)
}

// ServiceFeeTransferAsync mocks base method.
func (m *MockTransferManager) ServiceFeeTransferAsync(ctx context.Context, transfer *models.ServiceFeeTransferObj) (*models.TransferResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServiceFeeTransferAsync", ctx, transfer)
	ret0, _ := ret[0].(*models.TransferResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceFeeTransferAsync indicates an expected call of ServiceFeeTransferAsync.
func (mr *MockTransferManagerMockRecorder) ServiceFeeTransferAsync(ctx, transfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceFeeTransferAsync", reflect.TypeOf((*MockTransferManager)(nil).ServiceFeeTransferAsync), ctx, transfer)
}

// Stop mocks base method.
func (m *MockTransferManager) Stop() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stop")
	ret0, _ := ret[0].(error)
	return ret0
}

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

// TransferExists mocks base method.
func (m *MockTransferManager) TransferExists(ctx context.Context, transferID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferExists", ctx, transferID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransferExists indicates an expected call of TransferExists.
func (mr *MockTransferManagerMockRecorder) TransferExists(ctx, transferID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferExists", reflect.TypeOf((*MockTransferManager)(nil).TransferExists), ctx, transferID)
}

// MockAssetboxManager is a mock of AssetboxManager interface.
type MockAssetboxManager struct {
	ctrl     *gomock.Controller
	recorder *MockAssetboxManagerMockRecorder
}

// MockAssetboxManagerMockRecorder is the mock recorder for MockAssetboxManager.
type MockAssetboxManagerMockRecorder struct {
	mock *MockAssetboxManager
}

// NewMockAssetboxManager creates a new mock instance.
func NewMockAssetboxManager(ctrl *gomock.Controller) *MockAssetboxManager {
	mock := &MockAssetboxManager{ctrl: ctrl}
	mock.recorder = &MockAssetboxManagerMockRecorder{mock}
	return mock
}

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

// DeleteAssetbox mocks base method.
func (m *MockAssetboxManager) DeleteAssetbox(ctx context.Context, req *dto.DeleteAssetboxRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAssetbox", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAssetbox indicates an expected call of DeleteAssetbox.
func (mr *MockAssetboxManagerMockRecorder) DeleteAssetbox(ctx, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssetbox", reflect.TypeOf((*MockAssetboxManager)(nil).DeleteAssetbox), ctx, req)
}

// PrepareAssetbox mocks base method.
func (m *MockAssetboxManager) PrepareAssetbox(ctx context.Context) (*models.Assetbox, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrepareAssetbox", ctx)
	ret0, _ := ret[0].(*models.Assetbox)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PrepareAssetbox indicates an expected call of PrepareAssetbox.
func (mr *MockAssetboxManagerMockRecorder) PrepareAssetbox(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareAssetbox", reflect.TypeOf((*MockAssetboxManager)(nil).PrepareAssetbox), ctx)
}

// PrepareAssetboxes mocks base method.
func (m *MockAssetboxManager) PrepareAssetboxes(ctx context.Context, count uint64) ([]*models.Assetbox, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrepareAssetboxes", ctx, count)
	ret0, _ := ret[0].([]*models.Assetbox)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PrepareAssetboxes indicates an expected call of PrepareAssetboxes.
func (mr *MockAssetboxManagerMockRecorder) PrepareAssetboxes(ctx, count interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareAssetboxes", reflect.TypeOf((*MockAssetboxManager)(nil).PrepareAssetboxes), ctx, count)
}

// SetPublicAssetboxInfo mocks base method.
func (m *MockAssetboxManager) SetPublicAssetboxInfo(ctx context.Context, req *dto.SetPublicAssetboxInfoRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPublicAssetboxInfo", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetPublicAssetboxInfo indicates an expected call of SetPublicAssetboxInfo.
func (mr *MockAssetboxManagerMockRecorder) SetPublicAssetboxInfo(ctx, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPublicAssetboxInfo", reflect.TypeOf((*MockAssetboxManager)(nil).SetPublicAssetboxInfo), ctx, req)
}

// SetPublicAssetboxInfos mocks base method.
func (m *MockAssetboxManager) SetPublicAssetboxInfos(ctx context.Context, assetboxes []*contracts.Assetbox) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPublicAssetboxInfos", ctx, assetboxes)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetPublicAssetboxInfos indicates an expected call of SetPublicAssetboxInfos.
func (mr *MockAssetboxManagerMockRecorder) SetPublicAssetboxInfos(ctx, assetboxes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPublicAssetboxInfos", reflect.TypeOf((*MockAssetboxManager)(nil).SetPublicAssetboxInfos), ctx, assetboxes)
}

// MockMiningAgent is a mock of MiningAgent interface.
type MockMiningAgent struct {
	ctrl     *gomock.Controller
	recorder *MockMiningAgentMockRecorder
}

// MockMiningAgentMockRecorder is the mock recorder for MockMiningAgent.
type MockMiningAgentMockRecorder struct {
	mock *MockMiningAgent
}

// NewMockMiningAgent creates a new mock instance.
func NewMockMiningAgent(ctrl *gomock.Controller) *MockMiningAgent {
	mock := &MockMiningAgent{ctrl: ctrl}
	mock.recorder = &MockMiningAgentMockRecorder{mock}
	return mock
}

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

// AddMiningAgent mocks base method.
func (m *MockMiningAgent) AddMiningAgent(ctx context.Context, address common.Address) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddMiningAgent", ctx, address)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddMiningAgent indicates an expected call of AddMiningAgent.
func (mr *MockMiningAgentMockRecorder) AddMiningAgent(ctx, address interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMiningAgent", reflect.TypeOf((*MockMiningAgent)(nil).AddMiningAgent), ctx, address)
}

// GetAllMiningAgents mocks base method.
func (m *MockMiningAgent) GetAllMiningAgents(ctx context.Context) ([]common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllMiningAgents", ctx)
	ret0, _ := ret[0].([]common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllMiningAgents indicates an expected call of GetAllMiningAgents.
func (mr *MockMiningAgentMockRecorder) GetAllMiningAgents(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllMiningAgents", reflect.TypeOf((*MockMiningAgent)(nil).GetAllMiningAgents), ctx)
}

// GetCurrentDistribution mocks base method.
func (m *MockMiningAgent) GetCurrentDistribution(ctx context.Context) (map[string]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentDistribution", ctx)
	ret0, _ := ret[0].(map[string]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentDistribution indicates an expected call of GetCurrentDistribution.
func (mr *MockMiningAgentMockRecorder) GetCurrentDistribution(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentDistribution", reflect.TypeOf((*MockMiningAgent)(nil).GetCurrentDistribution), ctx)
}

// IsMiningAgent mocks base method.
func (m *MockMiningAgent) IsMiningAgent(ctx context.Context, address common.Address) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsMiningAgent", ctx, address)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsMiningAgent indicates an expected call of IsMiningAgent.
func (mr *MockMiningAgentMockRecorder) IsMiningAgent(ctx, address interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsMiningAgent", reflect.TypeOf((*MockMiningAgent)(nil).IsMiningAgent), ctx, address)
}

// ProposeDistribution mocks base method.
func (m *MockMiningAgent) ProposeDistribution(ctx context.Context, req dto.ProposeDistributionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProposeDistribution", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProposeDistribution indicates an expected call of ProposeDistribution.
func (mr *MockMiningAgentMockRecorder) ProposeDistribution(ctx, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeDistribution", reflect.TypeOf((*MockMiningAgent)(nil).ProposeDistribution), ctx, req)
}

// RemoveMiningAgent mocks base method.
func (m *MockMiningAgent) RemoveMiningAgent(ctx context.Context, address common.Address) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveMiningAgent", ctx, address)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveMiningAgent indicates an expected call of RemoveMiningAgent.
func (mr *MockMiningAgentMockRecorder) RemoveMiningAgent(ctx, address interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMiningAgent", reflect.TypeOf((*MockMiningAgent)(nil).RemoveMiningAgent), ctx, address)
}

// MockFeeManager is a mock of FeeManager interface.
type MockFeeManager struct {
	ctrl     *gomock.Controller
	recorder *MockFeeManagerMockRecorder
}

// MockFeeManagerMockRecorder is the mock recorder for MockFeeManager.
type MockFeeManagerMockRecorder struct {
	mock *MockFeeManager
}

// NewMockFeeManager creates a new mock instance.
func NewMockFeeManager(ctrl *gomock.Controller) *MockFeeManager {
	mock := &MockFeeManager{ctrl: ctrl}
	mock.recorder = &MockFeeManagerMockRecorder{mock}
	return mock
}

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

// GetFee mocks base method.
func (m *MockFeeManager) GetFee(ctx context.Context, opType dto.OperationType) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFee", ctx, opType)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFee indicates an expected call of GetFee.
func (mr *MockFeeManagerMockRecorder) GetFee(ctx, opType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFee", reflect.TypeOf((*MockFeeManager)(nil).GetFee), ctx, opType)
}

// GetFeeDistributionAccounts mocks base method.
func (m *MockFeeManager) GetFeeDistributionAccounts(ctx context.Context, operationType *big.Int) ([]common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFeeDistributionAccounts", ctx, operationType)
	ret0, _ := ret[0].([]common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFeeDistributionAccounts indicates an expected call of GetFeeDistributionAccounts.
func (mr *MockFeeManagerMockRecorder) GetFeeDistributionAccounts(ctx, operationType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeDistributionAccounts", reflect.TypeOf((*MockFeeManager)(nil).GetFeeDistributionAccounts), ctx, operationType)
}

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

// GetFeeDistributionAmounts indicates an expected call of GetFeeDistributionAmounts.
func (mr *MockFeeManagerMockRecorder) GetFeeDistributionAmounts(ctx, operationType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeDistributionAmounts", reflect.TypeOf((*MockFeeManager)(nil).GetFeeDistributionAmounts), ctx, operationType)
}

// GetFeeSettings mocks base method.
func (m *MockFeeManager) GetFeeSettings(ctx context.Context) (*models.FeeSettingsResponseObj, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFeeSettings", ctx)
	ret0, _ := ret[0].(*models.FeeSettingsResponseObj)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFeeSettings indicates an expected call of GetFeeSettings.
func (mr *MockFeeManagerMockRecorder) GetFeeSettings(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeSettings", reflect.TypeOf((*MockFeeManager)(nil).GetFeeSettings), ctx)
}

// MockPkEncryptor is a mock of PkEncryptor interface.
type MockPkEncryptor struct {
	ctrl     *gomock.Controller
	recorder *MockPkEncryptorMockRecorder
}

// MockPkEncryptorMockRecorder is the mock recorder for MockPkEncryptor.
type MockPkEncryptorMockRecorder struct {
	mock *MockPkEncryptor
}

// NewMockPkEncryptor creates a new mock instance.
func NewMockPkEncryptor(ctrl *gomock.Controller) *MockPkEncryptor {
	mock := &MockPkEncryptor{ctrl: ctrl}
	mock.recorder = &MockPkEncryptorMockRecorder{mock}
	return mock
}

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

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

// Decrypt indicates an expected call of Decrypt.
func (mr *MockPkEncryptorMockRecorder) Decrypt(data, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decrypt", reflect.TypeOf((*MockPkEncryptor)(nil).Decrypt), data, key)
}

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

// Encrypt indicates an expected call of Encrypt.
func (mr *MockPkEncryptorMockRecorder) Encrypt(data, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encrypt", reflect.TypeOf((*MockPkEncryptor)(nil).Encrypt), data, key)
}

// MockContractManager is a mock of ContractManager interface.
type MockContractManager struct {
	ctrl     *gomock.Controller
	recorder *MockContractManagerMockRecorder
}

// MockContractManagerMockRecorder is the mock recorder for MockContractManager.
type MockContractManagerMockRecorder struct {
	mock *MockContractManager
}

// NewMockContractManager creates a new mock instance.
func NewMockContractManager(ctrl *gomock.Controller) *MockContractManager {
	mock := &MockContractManager{ctrl: ctrl}
	mock.recorder = &MockContractManagerMockRecorder{mock}
	return mock
}

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

// AddMiningAgent mocks base method.
func (m *MockContractManager) AddMiningAgent(ctx context.Context, address common.Address, key *ecdsa.PrivateKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddMiningAgent", ctx, address, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddMiningAgent indicates an expected call of AddMiningAgent.
func (mr *MockContractManagerMockRecorder) AddMiningAgent(ctx, address, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMiningAgent", reflect.TypeOf((*MockContractManager)(nil).AddMiningAgent), ctx, address, key)
}

// ApproveFullBalanceSafeTransfer mocks base method.
func (m *MockContractManager) ApproveFullBalanceSafeTransfer(ctx context.Context, transferID, protectionCode, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveFullBalanceSafeTransfer", ctx, transferID, protectionCode, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ApproveFullBalanceSafeTransfer indicates an expected call of ApproveFullBalanceSafeTransfer.
func (mr *MockContractManagerMockRecorder) ApproveFullBalanceSafeTransfer(ctx, transferID, protectionCode, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveFullBalanceSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).ApproveFullBalanceSafeTransfer), ctx, transferID, protectionCode, extraData, key, async)
}

// ApproveFullBalanceWPCSafeTransfer mocks base method.
func (m *MockContractManager) ApproveFullBalanceWPCSafeTransfer(ctx context.Context, transferID, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveFullBalanceWPCSafeTransfer", ctx, transferID, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ApproveFullBalanceWPCSafeTransfer indicates an expected call of ApproveFullBalanceWPCSafeTransfer.
func (mr *MockContractManagerMockRecorder) ApproveFullBalanceWPCSafeTransfer(ctx, transferID, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveFullBalanceWPCSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).ApproveFullBalanceWPCSafeTransfer), ctx, transferID, extraData, key, async)
}

// ApproveSafeTransfer mocks base method.
func (m *MockContractManager) ApproveSafeTransfer(ctx context.Context, transferID, protectionCode, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveSafeTransfer", ctx, transferID, protectionCode, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ApproveSafeTransfer indicates an expected call of ApproveSafeTransfer.
func (mr *MockContractManagerMockRecorder) ApproveSafeTransfer(ctx, transferID, protectionCode, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).ApproveSafeTransfer), ctx, transferID, protectionCode, extraData, key, async)
}

// ApproveWPCSafeTransfer mocks base method.
func (m *MockContractManager) ApproveWPCSafeTransfer(ctx context.Context, transferID, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApproveWPCSafeTransfer", ctx, transferID, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ApproveWPCSafeTransfer indicates an expected call of ApproveWPCSafeTransfer.
func (mr *MockContractManagerMockRecorder) ApproveWPCSafeTransfer(ctx, transferID, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApproveWPCSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).ApproveWPCSafeTransfer), ctx, transferID, extraData, key, async)
}

// BalanceOfLocked mocks base method.
func (m *MockContractManager) BalanceOfLocked(ctx context.Context, addr common.Address) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BalanceOfLocked", ctx, addr)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BalanceOfLocked indicates an expected call of BalanceOfLocked.
func (mr *MockContractManagerMockRecorder) BalanceOfLocked(ctx, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceOfLocked", reflect.TypeOf((*MockContractManager)(nil).BalanceOfLocked), ctx, addr)
}

// CancelFullBalanceSafeTransfer mocks base method.
func (m *MockContractManager) CancelFullBalanceSafeTransfer(ctx context.Context, transferID, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelFullBalanceSafeTransfer", ctx, transferID, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CancelFullBalanceSafeTransfer indicates an expected call of CancelFullBalanceSafeTransfer.
func (mr *MockContractManagerMockRecorder) CancelFullBalanceSafeTransfer(ctx, transferID, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelFullBalanceSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).CancelFullBalanceSafeTransfer), ctx, transferID, extraData, key, async)
}

// CancelFullBalanceWPCSafeTransfer mocks base method.
func (m *MockContractManager) CancelFullBalanceWPCSafeTransfer(ctx context.Context, transferID, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelFullBalanceWPCSafeTransfer", ctx, transferID, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CancelFullBalanceWPCSafeTransfer indicates an expected call of CancelFullBalanceWPCSafeTransfer.
func (mr *MockContractManagerMockRecorder) CancelFullBalanceWPCSafeTransfer(ctx, transferID, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelFullBalanceWPCSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).CancelFullBalanceWPCSafeTransfer), ctx, transferID, extraData, key, async)
}

// CancelSafeTransfer mocks base method.
func (m *MockContractManager) CancelSafeTransfer(ctx context.Context, transferID, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelSafeTransfer", ctx, transferID, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CancelSafeTransfer indicates an expected call of CancelSafeTransfer.
func (mr *MockContractManagerMockRecorder) CancelSafeTransfer(ctx, transferID, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).CancelSafeTransfer), ctx, transferID, extraData, key, async)
}

// CancelWPCSafeTransfer mocks base method.
func (m *MockContractManager) CancelWPCSafeTransfer(ctx context.Context, transferID, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelWPCSafeTransfer", ctx, transferID, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CancelWPCSafeTransfer indicates an expected call of CancelWPCSafeTransfer.
func (mr *MockContractManagerMockRecorder) CancelWPCSafeTransfer(ctx, transferID, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWPCSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).CancelWPCSafeTransfer), ctx, transferID, extraData, key, async)
}

// CreateFullBalanceSafeTransfer mocks base method.
func (m *MockContractManager) CreateFullBalanceSafeTransfer(ctx context.Context, t *contracts.Transfer, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFullBalanceSafeTransfer", ctx, t, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateFullBalanceSafeTransfer indicates an expected call of CreateFullBalanceSafeTransfer.
func (mr *MockContractManagerMockRecorder) CreateFullBalanceSafeTransfer(ctx, t, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullBalanceSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).CreateFullBalanceSafeTransfer), ctx, t, key, async)
}

// CreateFullBalanceWPCSafeTransfer mocks base method.
func (m *MockContractManager) CreateFullBalanceWPCSafeTransfer(ctx context.Context, t *contracts.Transfer, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFullBalanceWPCSafeTransfer", ctx, t, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateFullBalanceWPCSafeTransfer indicates an expected call of CreateFullBalanceWPCSafeTransfer.
func (mr *MockContractManagerMockRecorder) CreateFullBalanceWPCSafeTransfer(ctx, t, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullBalanceWPCSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).CreateFullBalanceWPCSafeTransfer), ctx, t, key, async)
}

// CreateSafeTransfer mocks base method.
func (m *MockContractManager) CreateSafeTransfer(ctx context.Context, t *contracts.Transfer, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSafeTransfer", ctx, t, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateSafeTransfer indicates an expected call of CreateSafeTransfer.
func (mr *MockContractManagerMockRecorder) CreateSafeTransfer(ctx, t, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).CreateSafeTransfer), ctx, t, key, async)
}

// CreateWPCSafeTransfer mocks base method.
func (m *MockContractManager) CreateWPCSafeTransfer(ctx context.Context, t *contracts.Transfer, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWPCSafeTransfer", ctx, t, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateWPCSafeTransfer indicates an expected call of CreateWPCSafeTransfer.
func (mr *MockContractManagerMockRecorder) CreateWPCSafeTransfer(ctx, t, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWPCSafeTransfer", reflect.TypeOf((*MockContractManager)(nil).CreateWPCSafeTransfer), ctx, t, key, async)
}

// DeleteAssetboxInfo mocks base method.
func (m *MockContractManager) DeleteAssetboxInfo(ctx context.Context, key *ecdsa.PrivateKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAssetboxInfo", ctx, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAssetboxInfo indicates an expected call of DeleteAssetboxInfo.
func (mr *MockContractManagerMockRecorder) DeleteAssetboxInfo(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssetboxInfo", reflect.TypeOf((*MockContractManager)(nil).DeleteAssetboxInfo), ctx, key)
}

// DirectTransfer mocks base method.
func (m *MockContractManager) DirectTransfer(ctx context.Context, from, to common.Address, value *big.Int, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DirectTransfer", ctx, from, to, value, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DirectTransfer indicates an expected call of DirectTransfer.
func (mr *MockContractManagerMockRecorder) DirectTransfer(ctx, from, to, value, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DirectTransfer", reflect.TypeOf((*MockContractManager)(nil).DirectTransfer), ctx, from, to, value, extraData, key, async)
}

// EmitEther mocks base method.
func (m *MockContractManager) EmitEther(ctx context.Context, to common.Address, value *big.Int, nonce *uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EmitEther", ctx, to, value, nonce)
	ret0, _ := ret[0].(error)
	return ret0
}

// EmitEther indicates an expected call of EmitEther.
func (mr *MockContractManagerMockRecorder) EmitEther(ctx, to, value, nonce interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EmitEther", reflect.TypeOf((*MockContractManager)(nil).EmitEther), ctx, to, value, nonce)
}

// ExpireSafeTransfers mocks base method.
func (m *MockContractManager) ExpireSafeTransfers(ctx context.Context, ids [][32]byte, key *ecdsa.PrivateKey) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireSafeTransfers", ctx, ids, key)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ExpireSafeTransfers indicates an expected call of ExpireSafeTransfers.
func (mr *MockContractManagerMockRecorder) ExpireSafeTransfers(ctx, ids, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireSafeTransfers", reflect.TypeOf((*MockContractManager)(nil).ExpireSafeTransfers), ctx, ids, key)
}

// FrameTransfer mocks base method.
func (m *MockContractManager) FrameTransfer(ctx context.Context, to common.Address, value *big.Int, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FrameTransfer", ctx, to, value, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FrameTransfer indicates an expected call of FrameTransfer.
func (mr *MockContractManagerMockRecorder) FrameTransfer(ctx, to, value, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FrameTransfer", reflect.TypeOf((*MockContractManager)(nil).FrameTransfer), ctx, to, value, extraData, key, async)
}

// FullBalanceQuickTransfer mocks base method.
func (m *MockContractManager) FullBalanceQuickTransfer(ctx context.Context, to common.Address, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FullBalanceQuickTransfer", ctx, to, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FullBalanceQuickTransfer indicates an expected call of FullBalanceQuickTransfer.
func (mr *MockContractManagerMockRecorder) FullBalanceQuickTransfer(ctx, to, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullBalanceQuickTransfer", reflect.TypeOf((*MockContractManager)(nil).FullBalanceQuickTransfer), ctx, to, extraData, key, async)
}

// GetAllMiningAgents mocks base method.
func (m *MockContractManager) GetAllMiningAgents(ctx context.Context) ([]common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllMiningAgents", ctx)
	ret0, _ := ret[0].([]common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllMiningAgents indicates an expected call of GetAllMiningAgents.
func (mr *MockContractManagerMockRecorder) GetAllMiningAgents(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllMiningAgents", reflect.TypeOf((*MockContractManager)(nil).GetAllMiningAgents), ctx)
}

// GetAsseboxesMiningState mocks base method.
func (m *MockContractManager) GetAsseboxesMiningState(ctx context.Context, address common.Address) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAsseboxesMiningState", ctx, address)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAsseboxesMiningState indicates an expected call of GetAsseboxesMiningState.
func (mr *MockContractManagerMockRecorder) GetAsseboxesMiningState(ctx, address interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAsseboxesMiningState", reflect.TypeOf((*MockContractManager)(nil).GetAsseboxesMiningState), ctx, address)
}

// GetAssetboxBalance mocks base method.
func (m *MockContractManager) GetAssetboxBalance(ctx context.Context, addr common.Address) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssetboxBalance", ctx, addr)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAssetboxBalance indicates an expected call of GetAssetboxBalance.
func (mr *MockContractManagerMockRecorder) GetAssetboxBalance(ctx, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssetboxBalance", reflect.TypeOf((*MockContractManager)(nil).GetAssetboxBalance), ctx, addr)
}

// GetAssetboxBalances mocks base method.
func (m *MockContractManager) GetAssetboxBalances(ctx context.Context, addresses []common.Address) (map[common.Address]*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssetboxBalances", ctx, addresses)
	ret0, _ := ret[0].(map[common.Address]*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAssetboxBalances indicates an expected call of GetAssetboxBalances.
func (mr *MockContractManagerMockRecorder) GetAssetboxBalances(ctx, addresses interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssetboxBalances", reflect.TypeOf((*MockContractManager)(nil).GetAssetboxBalances), ctx, addresses)
}

// GetAssetboxBalancesSum mocks base method.
func (m *MockContractManager) GetAssetboxBalancesSum(ctx context.Context, addresses []common.Address) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssetboxBalancesSum", ctx, addresses)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAssetboxBalancesSum indicates an expected call of GetAssetboxBalancesSum.
func (mr *MockContractManagerMockRecorder) GetAssetboxBalancesSum(ctx, addresses interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssetboxBalancesSum", reflect.TypeOf((*MockContractManager)(nil).GetAssetboxBalancesSum), ctx, addresses)
}

// GetAssetboxInfo mocks base method.
func (m *MockContractManager) GetAssetboxInfo(ctx context.Context, addr common.Address) (*contracts.Assetbox, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssetboxInfo", ctx, addr)
	ret0, _ := ret[0].(*contracts.Assetbox)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAssetboxInfo indicates an expected call of GetAssetboxInfo.
func (mr *MockContractManagerMockRecorder) GetAssetboxInfo(ctx, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssetboxInfo", reflect.TypeOf((*MockContractManager)(nil).GetAssetboxInfo), ctx, addr)
}

// GetAssetboxInfoByAlias mocks base method.
func (m *MockContractManager) GetAssetboxInfoByAlias(ctx context.Context, alias string) (*contracts.Assetbox, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAssetboxInfoByAlias", ctx, alias)
	ret0, _ := ret[0].(*contracts.Assetbox)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAssetboxInfoByAlias indicates an expected call of GetAssetboxInfoByAlias.
func (mr *MockContractManagerMockRecorder) GetAssetboxInfoByAlias(ctx, alias interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssetboxInfoByAlias", reflect.TypeOf((*MockContractManager)(nil).GetAssetboxInfoByAlias), ctx, alias)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetCurrentContractAbiInfo mocks base method.
func (m *MockContractManager) GetCurrentContractAbiInfo(version dto.ContractVersion) ([]*dto.AbiInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentContractAbiInfo", version)
	ret0, _ := ret[0].([]*dto.AbiInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentContractAbiInfo indicates an expected call of GetCurrentContractAbiInfo.
func (mr *MockContractManagerMockRecorder) GetCurrentContractAbiInfo(version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentContractAbiInfo", reflect.TypeOf((*MockContractManager)(nil).GetCurrentContractAbiInfo), version)
}

// GetCurrentDistribution mocks base method.
func (m *MockContractManager) GetCurrentDistribution(ctx context.Context) (map[string]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentDistribution", ctx)
	ret0, _ := ret[0].(map[string]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentDistribution indicates an expected call of GetCurrentDistribution.
func (mr *MockContractManagerMockRecorder) GetCurrentDistribution(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentDistribution", reflect.TypeOf((*MockContractManager)(nil).GetCurrentDistribution), ctx)
}

// GetEthAPIWrapper mocks base method.
func (m *MockContractManager) GetEthAPIWrapper() *contracts.EthApiWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEthAPIWrapper")
	ret0, _ := ret[0].(*contracts.EthApiWrapper)
	return ret0
}

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

// GetExpiredTransfers mocks base method.
func (m *MockContractManager) GetExpiredTransfers(ctx context.Context, firstTransfer, lastTransfer *big.Int) ([][32]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExpiredTransfers", ctx, firstTransfer, lastTransfer)
	ret0, _ := ret[0].([][32]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExpiredTransfers indicates an expected call of GetExpiredTransfers.
func (mr *MockContractManagerMockRecorder) GetExpiredTransfers(ctx, firstTransfer, lastTransfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExpiredTransfers", reflect.TypeOf((*MockContractManager)(nil).GetExpiredTransfers), ctx, firstTransfer, lastTransfer)
}

// GetFee mocks base method.
func (m *MockContractManager) GetFee(ctx context.Context, opType dto.OperationType) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFee", ctx, opType)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFee indicates an expected call of GetFee.
func (mr *MockContractManagerMockRecorder) GetFee(ctx, opType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFee", reflect.TypeOf((*MockContractManager)(nil).GetFee), ctx, opType)
}

// GetFeeDistributionAccounts mocks base method.
func (m *MockContractManager) GetFeeDistributionAccounts(ctx context.Context, operationType *big.Int) ([]common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFeeDistributionAccounts", ctx, operationType)
	ret0, _ := ret[0].([]common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFeeDistributionAccounts indicates an expected call of GetFeeDistributionAccounts.
func (mr *MockContractManagerMockRecorder) GetFeeDistributionAccounts(ctx, operationType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeDistributionAccounts", reflect.TypeOf((*MockContractManager)(nil).GetFeeDistributionAccounts), ctx, operationType)
}

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

// GetFeeDistributionAmounts indicates an expected call of GetFeeDistributionAmounts.
func (mr *MockContractManagerMockRecorder) GetFeeDistributionAmounts(ctx, operationType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeDistributionAmounts", reflect.TypeOf((*MockContractManager)(nil).GetFeeDistributionAmounts), ctx, operationType)
}

// GetFeeValueSettings mocks base method.
func (m *MockContractManager) GetFeeValueSettings(ctx context.Context) ([]*big.Int, []*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFeeValueSettings", ctx)
	ret0, _ := ret[0].([]*big.Int)
	ret1, _ := ret[1].([]*big.Int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetFeeValueSettings indicates an expected call of GetFeeValueSettings.
func (mr *MockContractManagerMockRecorder) GetFeeValueSettings(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFeeValueSettings", reflect.TypeOf((*MockContractManager)(nil).GetFeeValueSettings), ctx)
}

// GetNoncer mocks base method.
func (m *MockContractManager) GetNoncer() *noncer.Noncer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNoncer")
	ret0, _ := ret[0].(*noncer.Noncer)
	return ret0
}

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

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

// GetOldestPending indicates an expected call of GetOldestPending.
func (mr *MockContractManagerMockRecorder) GetOldestPending(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOldestPending", reflect.TypeOf((*MockContractManager)(nil).GetOldestPending), ctx)
}

// GetTransfer mocks base method.
func (m *MockContractManager) GetTransfer(ctx context.Context, transferID []byte) (*contracts.ReceiptTransfer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransfer", ctx, transferID)
	ret0, _ := ret[0].(*contracts.ReceiptTransfer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransfer indicates an expected call of GetTransfer.
func (mr *MockContractManagerMockRecorder) GetTransfer(ctx, transferID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransfer", reflect.TypeOf((*MockContractManager)(nil).GetTransfer), ctx, transferID)
}

// GetTransferByIndex mocks base method.
func (m *MockContractManager) GetTransferByIndex(ctx context.Context, index *big.Int) (*contracts.ReceiptTransfer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransferByIndex", ctx, index)
	ret0, _ := ret[0].(*contracts.ReceiptTransfer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransferByIndex indicates an expected call of GetTransferByIndex.
func (mr *MockContractManagerMockRecorder) GetTransferByIndex(ctx, index interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferByIndex", reflect.TypeOf((*MockContractManager)(nil).GetTransferByIndex), ctx, index)
}

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

// GetTransferLength indicates an expected call of GetTransferLength.
func (mr *MockContractManagerMockRecorder) GetTransferLength(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferLength", reflect.TypeOf((*MockContractManager)(nil).GetTransferLength), ctx)
}

// GetTransferState mocks base method.
func (m *MockContractManager) GetTransferState(ctx context.Context, transferID []byte) (uint8, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransferState", ctx, transferID)
	ret0, _ := ret[0].(uint8)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTransferState indicates an expected call of GetTransferState.
func (mr *MockContractManagerMockRecorder) GetTransferState(ctx, transferID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferState", reflect.TypeOf((*MockContractManager)(nil).GetTransferState), ctx, transferID)
}

// IsMiningAgent mocks base method.
func (m *MockContractManager) IsMiningAgent(ctx context.Context, address common.Address) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsMiningAgent", ctx, address)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsMiningAgent indicates an expected call of IsMiningAgent.
func (mr *MockContractManagerMockRecorder) IsMiningAgent(ctx, address interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsMiningAgent", reflect.TypeOf((*MockContractManager)(nil).IsMiningAgent), ctx, address)
}

// ProposeDistribution mocks base method.
func (m *MockContractManager) ProposeDistribution(ctx context.Context, distribution map[string]uint64, key *ecdsa.PrivateKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProposeDistribution", ctx, distribution, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProposeDistribution indicates an expected call of ProposeDistribution.
func (mr *MockContractManagerMockRecorder) ProposeDistribution(ctx, distribution, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProposeDistribution", reflect.TypeOf((*MockContractManager)(nil).ProposeDistribution), ctx, distribution, key)
}

// QuickTransfer mocks base method.
func (m *MockContractManager) QuickTransfer(ctx context.Context, to common.Address, value *big.Int, extraData []byte, key *ecdsa.PrivateKey, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuickTransfer", ctx, to, value, extraData, key, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QuickTransfer indicates an expected call of QuickTransfer.
func (mr *MockContractManagerMockRecorder) QuickTransfer(ctx, to, value, extraData, key, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuickTransfer", reflect.TypeOf((*MockContractManager)(nil).QuickTransfer), ctx, to, value, extraData, key, async)
}

// Ready mocks base method.
func (m *MockContractManager) Ready() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ready")
	ret0, _ := ret[0].(bool)
	return ret0
}

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

// RemoveMiningAgent mocks base method.
func (m *MockContractManager) RemoveMiningAgent(ctx context.Context, address common.Address, key *ecdsa.PrivateKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveMiningAgent", ctx, address, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveMiningAgent indicates an expected call of RemoveMiningAgent.
func (mr *MockContractManagerMockRecorder) RemoveMiningAgent(ctx, address, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMiningAgent", reflect.TypeOf((*MockContractManager)(nil).RemoveMiningAgent), ctx, address, key)
}

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

// SaveContractStorageAddress indicates an expected call of SaveContractStorageAddress.
func (mr *MockContractManagerMockRecorder) SaveContractStorageAddress(addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveContractStorageAddress", reflect.TypeOf((*MockContractManager)(nil).SaveContractStorageAddress), addr)
}

// SearchOldestPending mocks base method.
func (m *MockContractManager) SearchOldestPending(ctx context.Context, firstTransfer, lastTransfer *big.Int) (*big.Int, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchOldestPending", ctx, firstTransfer, lastTransfer)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SearchOldestPending indicates an expected call of SearchOldestPending.
func (mr *MockContractManagerMockRecorder) SearchOldestPending(ctx, firstTransfer, lastTransfer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchOldestPending", reflect.TypeOf((*MockContractManager)(nil).SearchOldestPending), ctx, firstTransfer, lastTransfer)
}

// ServiceFeeTransfer mocks base method.
func (m *MockContractManager) ServiceFeeTransfer(ctx context.Context, params dto.ServiceFeeTransferParams, async bool) (uint64, common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServiceFeeTransfer", ctx, params, async)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(common.Hash)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ServiceFeeTransfer indicates an expected call of ServiceFeeTransfer.
func (mr *MockContractManagerMockRecorder) ServiceFeeTransfer(ctx, params, async interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceFeeTransfer", reflect.TypeOf((*MockContractManager)(nil).ServiceFeeTransfer), ctx, params, async)
}

// SetAssetboxInfo mocks base method.
func (m *MockContractManager) SetAssetboxInfo(ctx context.Context, a *contracts.Assetbox, key *ecdsa.PrivateKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAssetboxInfo", ctx, a, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetAssetboxInfo indicates an expected call of SetAssetboxInfo.
func (mr *MockContractManagerMockRecorder) SetAssetboxInfo(ctx, a, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAssetboxInfo", reflect.TypeOf((*MockContractManager)(nil).SetAssetboxInfo), ctx, a, key)
}

// SetAssetboxInfos mocks base method.
func (m *MockContractManager) SetAssetboxInfos(ctx context.Context, a []*contracts.Assetbox, key *ecdsa.PrivateKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAssetboxInfos", ctx, a, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetAssetboxInfos indicates an expected call of SetAssetboxInfos.
func (mr *MockContractManagerMockRecorder) SetAssetboxInfos(ctx, a, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAssetboxInfos", reflect.TypeOf((*MockContractManager)(nil).SetAssetboxInfos), ctx, a, key)
}

// SetOldestPending mocks base method.
func (m *MockContractManager) SetOldestPending(ctx context.Context, pendingIndex *big.Int, key *ecdsa.PrivateKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOldestPending", ctx, pendingIndex, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetOldestPending indicates an expected call of SetOldestPending.
func (mr *MockContractManagerMockRecorder) SetOldestPending(ctx, pendingIndex, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOldestPending", reflect.TypeOf((*MockContractManager)(nil).SetOldestPending), ctx, pendingIndex, key)
}

// Stop mocks base method.
func (m *MockContractManager) Stop() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stop")
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Stopped mocks base method.
func (m *MockContractManager) Stopped() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stopped")
	ret0, _ := ret[0].(bool)
	return ret0
}

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

// TransferExists mocks base method.
func (m *MockContractManager) TransferExists(ctx context.Context, transferID []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferExists", ctx, transferID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransferExists indicates an expected call of TransferExists.
func (mr *MockContractManagerMockRecorder) TransferExists(ctx, transferID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferExists", reflect.TypeOf((*MockContractManager)(nil).TransferExists), ctx, transferID)
}

// WaitReady mocks base method.
func (m *MockContractManager) WaitReady(exit chan struct{}) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitReady", exit)
	ret0, _ := ret[0].(bool)
	return ret0
}

// WaitReady indicates an expected call of WaitReady.
func (mr *MockContractManagerMockRecorder) WaitReady(exit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitReady", reflect.TypeOf((*MockContractManager)(nil).WaitReady), exit)
}

// WatchAssetboxInfoDeleted mocks base method.
func (m *MockContractManager) WatchAssetboxInfoDeleted(sink chan<- *contracts.Assetbox) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchAssetboxInfoDeleted", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchAssetboxInfoDeleted indicates an expected call of WatchAssetboxInfoDeleted.
func (mr *MockContractManagerMockRecorder) WatchAssetboxInfoDeleted(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchAssetboxInfoDeleted", reflect.TypeOf((*MockContractManager)(nil).WatchAssetboxInfoDeleted), sink)
}

// WatchAssetboxInfoSet mocks base method.
func (m *MockContractManager) WatchAssetboxInfoSet(sink chan<- *contracts.Assetbox) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchAssetboxInfoSet", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchAssetboxInfoSet indicates an expected call of WatchAssetboxInfoSet.
func (mr *MockContractManagerMockRecorder) WatchAssetboxInfoSet(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchAssetboxInfoSet", reflect.TypeOf((*MockContractManager)(nil).WatchAssetboxInfoSet), sink)
}

// WatchBitbonBalanceChanged mocks base method.
func (m *MockContractManager) WatchBitbonBalanceChanged(sink chan<- *contracts.Balance) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchBitbonBalanceChanged", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchBitbonBalanceChanged indicates an expected call of WatchBitbonBalanceChanged.
func (mr *MockContractManagerMockRecorder) WatchBitbonBalanceChanged(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchBitbonBalanceChanged", reflect.TypeOf((*MockContractManager)(nil).WatchBitbonBalanceChanged), sink)
}

// WatchBitbonBalanceLocked mocks base method.
func (m *MockContractManager) WatchBitbonBalanceLocked(sink chan<- *contracts.Balance) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchBitbonBalanceLocked", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchBitbonBalanceLocked indicates an expected call of WatchBitbonBalanceLocked.
func (mr *MockContractManagerMockRecorder) WatchBitbonBalanceLocked(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchBitbonBalanceLocked", reflect.TypeOf((*MockContractManager)(nil).WatchBitbonBalanceLocked), sink)
}

// WatchBitbonBalanceUnLocked mocks base method.
func (m *MockContractManager) WatchBitbonBalanceUnLocked(sink chan<- *contracts.Balance) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchBitbonBalanceUnLocked", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchBitbonBalanceUnLocked indicates an expected call of WatchBitbonBalanceUnLocked.
func (mr *MockContractManagerMockRecorder) WatchBitbonBalanceUnLocked(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchBitbonBalanceUnLocked", reflect.TypeOf((*MockContractManager)(nil).WatchBitbonBalanceUnLocked), sink)
}

// WatchExceptionalAccountsChanged mocks base method.
func (m *MockContractManager) WatchExceptionalAccountsChanged(sink chan<- *contracts.ExceptionalAccountsChanged) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchExceptionalAccountsChanged", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchExceptionalAccountsChanged indicates an expected call of WatchExceptionalAccountsChanged.
func (mr *MockContractManagerMockRecorder) WatchExceptionalAccountsChanged(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchExceptionalAccountsChanged", reflect.TypeOf((*MockContractManager)(nil).WatchExceptionalAccountsChanged), sink)
}

// WatchFeeDistributionSettingsChanged mocks base method.
func (m *MockContractManager) WatchFeeDistributionSettingsChanged(sink chan<- *contracts.DistributionSettingsChanged) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchFeeDistributionSettingsChanged", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchFeeDistributionSettingsChanged indicates an expected call of WatchFeeDistributionSettingsChanged.
func (mr *MockContractManagerMockRecorder) WatchFeeDistributionSettingsChanged(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchFeeDistributionSettingsChanged", reflect.TypeOf((*MockContractManager)(nil).WatchFeeDistributionSettingsChanged), sink)
}

// WatchFeeValueChanged mocks base method.
func (m *MockContractManager) WatchFeeValueChanged(sink chan<- *contracts.FeeValueChanged) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchFeeValueChanged", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchFeeValueChanged indicates an expected call of WatchFeeValueChanged.
func (mr *MockContractManagerMockRecorder) WatchFeeValueChanged(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchFeeValueChanged", reflect.TypeOf((*MockContractManager)(nil).WatchFeeValueChanged), sink)
}

// WatchTransferExpired mocks base method.
func (m *MockContractManager) WatchTransferExpired(sink chan<- *contracts.TransferExpired) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchTransferExpired", sink)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchTransferExpired indicates an expected call of WatchTransferExpired.
func (mr *MockContractManagerMockRecorder) WatchTransferExpired(sink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchTransferExpired", reflect.TypeOf((*MockContractManager)(nil).WatchTransferExpired), sink)
}
