platformvm/state/mock_state.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/luxfi/node/vms/platformvm/state (interfaces: State)
//
// Generated by this command:
//
//	mockgen -package=state -destination=mock_state.go . State
//

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

import (
	context "context"
	reflect "reflect"
	sync "sync"
	time "time"

	validators "github.com/luxfi/validators"
	database "github.com/luxfi/database"
	ids "github.com/luxfi/ids"
	"github.com/luxfi/log"
	gas "github.com/luxfi/node/vms/components/gas"
	lux "github.com/luxfi/utxo"
	block "github.com/luxfi/node/vms/platformvm/block"
	status "github.com/luxfi/node/vms/platformvm/status"
	txs "github.com/luxfi/node/vms/platformvm/txs"
	iterator "github.com/luxfi/container/iterator"
	fx "github.com/luxfi/node/vms/platformvm/fx"
	gomock "go.uber.org/mock/gomock"
)

// MockState is a mock of State interface.
type MockState struct {
	ctrl     *gomock.Controller
	recorder *MockStateMockRecorder
	isgomock struct{}
}

// MockStateMockRecorder is the mock recorder for MockState.
type MockStateMockRecorder struct {
	mock *MockState
}

// NewMockState creates a new mock instance.
func NewMockState(ctrl *gomock.Controller) *MockState {
	mock := &MockState{ctrl: ctrl}
	mock.recorder = &MockStateMockRecorder{mock}
	return mock
}

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

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

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

// AddChain mocks base method.
func (m *MockState) AddChain(createChainTx *txs.Tx) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddChain", createChainTx)
}

// AddChain indicates an expected call of AddChain.
func (mr *MockStateMockRecorder) AddChain(createChainTx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddChain", reflect.TypeOf((*MockState)(nil).AddChain), createChainTx)
}

// AddNet mocks base method.
func (m *MockState) AddNet(netID ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddNet", netID)
}

// AddNet indicates an expected call of AddNet.
func (mr *MockStateMockRecorder) AddNet(netID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNet", reflect.TypeOf((*MockState)(nil).AddNet), netID)
}

// AddNetTransformation mocks base method.
func (m *MockState) AddNetTransformation(transformNetTx *txs.Tx) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddNetTransformation", transformNetTx)
}

// AddNetTransformation indicates an expected call of AddNetTransformation.
func (mr *MockStateMockRecorder) AddNetTransformation(transformNetTx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetTransformation", reflect.TypeOf((*MockState)(nil).AddNetTransformation), transformNetTx)
}

// AddRewardUTXO mocks base method.
func (m *MockState) AddRewardUTXO(txID ids.ID, utxo *lux.UTXO) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddRewardUTXO", txID, utxo)
}

// AddRewardUTXO indicates an expected call of AddRewardUTXO.
func (mr *MockStateMockRecorder) AddRewardUTXO(txID, utxo any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRewardUTXO", reflect.TypeOf((*MockState)(nil).AddRewardUTXO), txID, utxo)
}

// AddStatelessBlock mocks base method.
func (m *MockState) AddStatelessBlock(arg0 block.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddStatelessBlock", arg0)
}

// AddStatelessBlock indicates an expected call of AddStatelessBlock.
func (mr *MockStateMockRecorder) AddStatelessBlock(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStatelessBlock", reflect.TypeOf((*MockState)(nil).AddStatelessBlock), arg0)
}

// AddTx mocks base method.
func (m *MockState) AddTx(tx *txs.Tx, arg1 status.Status) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddTx", tx, arg1)
}

// AddTx indicates an expected call of AddTx.
func (mr *MockStateMockRecorder) AddTx(tx, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTx", reflect.TypeOf((*MockState)(nil).AddTx), tx, arg1)
}

// AddUTXO mocks base method.
func (m *MockState) AddUTXO(utxo *lux.UTXO) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddUTXO", utxo)
}

// AddUTXO indicates an expected call of AddUTXO.
func (mr *MockStateMockRecorder) AddUTXO(utxo any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUTXO", reflect.TypeOf((*MockState)(nil).AddUTXO), utxo)
}

// ApplyValidatorPublicKeyDiffs mocks base method.
func (m *MockState) ApplyValidatorPublicKeyDiffs(ctx context.Context, arg1 map[ids.NodeID]*validators.GetValidatorOutput, startHeight, endHeight uint64, chainID ids.ID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyValidatorPublicKeyDiffs", ctx, arg1, startHeight, endHeight, chainID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyValidatorPublicKeyDiffs indicates an expected call of ApplyValidatorPublicKeyDiffs.
func (mr *MockStateMockRecorder) ApplyValidatorPublicKeyDiffs(ctx, arg1, startHeight, endHeight, chainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyValidatorPublicKeyDiffs", reflect.TypeOf((*MockState)(nil).ApplyValidatorPublicKeyDiffs), ctx, arg1, startHeight, endHeight, chainID)
}

// ApplyValidatorWeightDiffs mocks base method.
func (m *MockState) ApplyValidatorWeightDiffs(ctx context.Context, arg1 map[ids.NodeID]*validators.GetValidatorOutput, startHeight, endHeight uint64, netID ids.ID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyValidatorWeightDiffs", ctx, arg1, startHeight, endHeight, netID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyValidatorWeightDiffs indicates an expected call of ApplyValidatorWeightDiffs.
func (mr *MockStateMockRecorder) ApplyValidatorWeightDiffs(ctx, arg1, startHeight, endHeight, netID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyValidatorWeightDiffs", reflect.TypeOf((*MockState)(nil).ApplyValidatorWeightDiffs), ctx, arg1, startHeight, endHeight, netID)
}

// Checksum mocks base method.
func (m *MockState) Checksum() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Checksum")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

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

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

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

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

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

// CommitBatch mocks base method.
func (m *MockState) CommitBatch() (database.Batch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitBatch")
	ret0, _ := ret[0].(database.Batch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCurrentDelegator mocks base method.
func (m *MockState) DeleteCurrentDelegator(staker *Staker) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeleteCurrentDelegator", staker)
}

// DeleteCurrentDelegator indicates an expected call of DeleteCurrentDelegator.
func (mr *MockStateMockRecorder) DeleteCurrentDelegator(staker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentDelegator", reflect.TypeOf((*MockState)(nil).DeleteCurrentDelegator), staker)
}

// DeleteCurrentValidator mocks base method.
func (m *MockState) DeleteCurrentValidator(staker *Staker) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeleteCurrentValidator", staker)
}

// DeleteCurrentValidator indicates an expected call of DeleteCurrentValidator.
func (mr *MockStateMockRecorder) DeleteCurrentValidator(staker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentValidator", reflect.TypeOf((*MockState)(nil).DeleteCurrentValidator), staker)
}

// DeleteExpiry mocks base method.
func (m *MockState) DeleteExpiry(arg0 ExpiryEntry) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeleteExpiry", arg0)
}

// DeleteExpiry indicates an expected call of DeleteExpiry.
func (mr *MockStateMockRecorder) DeleteExpiry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpiry", reflect.TypeOf((*MockState)(nil).DeleteExpiry), arg0)
}

// DeletePendingDelegator mocks base method.
func (m *MockState) DeletePendingDelegator(staker *Staker) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeletePendingDelegator", staker)
}

// DeletePendingDelegator indicates an expected call of DeletePendingDelegator.
func (mr *MockStateMockRecorder) DeletePendingDelegator(staker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePendingDelegator", reflect.TypeOf((*MockState)(nil).DeletePendingDelegator), staker)
}

// DeletePendingValidator mocks base method.
func (m *MockState) DeletePendingValidator(staker *Staker) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeletePendingValidator", staker)
}

// DeletePendingValidator indicates an expected call of DeletePendingValidator.
func (mr *MockStateMockRecorder) DeletePendingValidator(staker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePendingValidator", reflect.TypeOf((*MockState)(nil).DeletePendingValidator), staker)
}

// DeleteUTXO mocks base method.
func (m *MockState) DeleteUTXO(utxoID ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeleteUTXO", utxoID)
}

// DeleteUTXO indicates an expected call of DeleteUTXO.
func (mr *MockStateMockRecorder) DeleteUTXO(utxoID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUTXO", reflect.TypeOf((*MockState)(nil).DeleteUTXO), utxoID)
}

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

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

// GetActiveL1ValidatorsIterator mocks base method.
func (m *MockState) GetActiveL1ValidatorsIterator() (iterator.Iterator[L1Validator], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveL1ValidatorsIterator")
	ret0, _ := ret[0].(iterator.Iterator[L1Validator])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBlockIDAtHeight mocks base method.
func (m *MockState) GetBlockIDAtHeight(height uint64) (ids.ID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockIDAtHeight", height)
	ret0, _ := ret[0].(ids.ID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockIDAtHeight indicates an expected call of GetBlockIDAtHeight.
func (mr *MockStateMockRecorder) GetBlockIDAtHeight(height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockIDAtHeight", reflect.TypeOf((*MockState)(nil).GetBlockIDAtHeight), height)
}

// GetChainIDByName mocks base method.
func (m *MockState) GetChainIDByName(name string) (ids.ID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChainIDByName", name)
	ret0, _ := ret[0].(ids.ID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChainIDByName indicates an expected call of GetChainIDByName.
func (mr *MockStateMockRecorder) GetChainIDByName(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChainIDByName", reflect.TypeOf((*MockState)(nil).GetChainIDByName), name)
}

// GetChainIDs mocks base method.
func (m *MockState) GetChainIDs() ([]ids.ID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChainIDs")
	ret0, _ := ret[0].([]ids.ID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChains mocks base method.
func (m *MockState) GetChains(netID ids.ID) ([]*txs.Tx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChains", netID)
	ret0, _ := ret[0].([]*txs.Tx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChains indicates an expected call of GetChains.
func (mr *MockStateMockRecorder) GetChains(netID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChains", reflect.TypeOf((*MockState)(nil).GetChains), netID)
}

// GetCurrentDelegatorIterator mocks base method.
func (m *MockState) GetCurrentDelegatorIterator(chainID ids.ID, nodeID ids.NodeID) (iterator.Iterator[*Staker], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentDelegatorIterator", chainID, nodeID)
	ret0, _ := ret[0].(iterator.Iterator[*Staker])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentDelegatorIterator indicates an expected call of GetCurrentDelegatorIterator.
func (mr *MockStateMockRecorder) GetCurrentDelegatorIterator(chainID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentDelegatorIterator", reflect.TypeOf((*MockState)(nil).GetCurrentDelegatorIterator), chainID, nodeID)
}

// GetCurrentStakerIterator mocks base method.
func (m *MockState) GetCurrentStakerIterator() (iterator.Iterator[*Staker], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentStakerIterator")
	ret0, _ := ret[0].(iterator.Iterator[*Staker])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCurrentSupply mocks base method.
func (m *MockState) GetCurrentSupply(chainID ids.ID) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentSupply", chainID)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentSupply indicates an expected call of GetCurrentSupply.
func (mr *MockStateMockRecorder) GetCurrentSupply(chainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentSupply", reflect.TypeOf((*MockState)(nil).GetCurrentSupply), chainID)
}

// GetCurrentValidator mocks base method.
func (m *MockState) GetCurrentValidator(netID ids.ID, nodeID ids.NodeID) (*Staker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentValidator", netID, nodeID)
	ret0, _ := ret[0].(*Staker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentValidator indicates an expected call of GetCurrentValidator.
func (mr *MockStateMockRecorder) GetCurrentValidator(netID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentValidator", reflect.TypeOf((*MockState)(nil).GetCurrentValidator), netID, nodeID)
}

// GetCurrentValidators mocks base method.
func (m *MockState) GetCurrentValidators(ctx context.Context, chainID ids.ID) ([]*Staker, []L1Validator, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentValidators", ctx, chainID)
	ret0, _ := ret[0].([]*Staker)
	ret1, _ := ret[1].([]L1Validator)
	ret2, _ := ret[2].(uint64)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// GetCurrentValidators indicates an expected call of GetCurrentValidators.
func (mr *MockStateMockRecorder) GetCurrentValidators(ctx, chainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentValidators", reflect.TypeOf((*MockState)(nil).GetCurrentValidators), ctx, chainID)
}

// GetDelegateeReward mocks base method.
func (m *MockState) GetDelegateeReward(netID ids.ID, nodeID ids.NodeID) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDelegateeReward", netID, nodeID)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDelegateeReward indicates an expected call of GetDelegateeReward.
func (mr *MockStateMockRecorder) GetDelegateeReward(netID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDelegateeReward", reflect.TypeOf((*MockState)(nil).GetDelegateeReward), netID, nodeID)
}

// GetExpiryIterator mocks base method.
func (m *MockState) GetExpiryIterator() (iterator.Iterator[ExpiryEntry], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExpiryIterator")
	ret0, _ := ret[0].(iterator.Iterator[ExpiryEntry])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFeeState mocks base method.
func (m *MockState) GetFeeState() gas.State {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFeeState")
	ret0, _ := ret[0].(gas.State)
	return ret0
}

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

// GetL1Validator mocks base method.
func (m *MockState) GetL1Validator(validationID ids.ID) (L1Validator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetL1Validator", validationID)
	ret0, _ := ret[0].(L1Validator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetL1Validator indicates an expected call of GetL1Validator.
func (mr *MockStateMockRecorder) GetL1Validator(validationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetL1Validator", reflect.TypeOf((*MockState)(nil).GetL1Validator), validationID)
}

// GetL1ValidatorExcess mocks base method.
func (m *MockState) GetL1ValidatorExcess() gas.Gas {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetL1ValidatorExcess")
	ret0, _ := ret[0].(gas.Gas)
	return ret0
}

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

// GetLastAccepted mocks base method.
func (m *MockState) GetLastAccepted() ids.ID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastAccepted")
	ret0, _ := ret[0].(ids.ID)
	return ret0
}

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

// GetNetOwner mocks base method.
func (m *MockState) GetNetOwner(netID ids.ID) (fx.Owner, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetOwner", netID)
	ret0, _ := ret[0].(fx.Owner)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetOwner indicates an expected call of GetNetOwner.
func (mr *MockStateMockRecorder) GetNetOwner(netID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetOwner", reflect.TypeOf((*MockState)(nil).GetNetOwner), netID)
}

// GetNetToL1Conversion mocks base method.
func (m *MockState) GetNetToL1Conversion(chainID ids.ID) (NetToL1Conversion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetToL1Conversion", chainID)
	ret0, _ := ret[0].(NetToL1Conversion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetToL1Conversion indicates an expected call of GetNetToL1Conversion.
func (mr *MockStateMockRecorder) GetNetToL1Conversion(chainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetToL1Conversion", reflect.TypeOf((*MockState)(nil).GetNetToL1Conversion), chainID)
}

// GetNetTransformation mocks base method.
func (m *MockState) GetNetTransformation(chainID ids.ID) (*txs.Tx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetTransformation", chainID)
	ret0, _ := ret[0].(*txs.Tx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetTransformation indicates an expected call of GetNetTransformation.
func (mr *MockStateMockRecorder) GetNetTransformation(chainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetTransformation", reflect.TypeOf((*MockState)(nil).GetNetTransformation), chainID)
}

// GetPendingDelegatorIterator mocks base method.
func (m *MockState) GetPendingDelegatorIterator(chainID ids.ID, nodeID ids.NodeID) (iterator.Iterator[*Staker], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPendingDelegatorIterator", chainID, nodeID)
	ret0, _ := ret[0].(iterator.Iterator[*Staker])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPendingDelegatorIterator indicates an expected call of GetPendingDelegatorIterator.
func (mr *MockStateMockRecorder) GetPendingDelegatorIterator(chainID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingDelegatorIterator", reflect.TypeOf((*MockState)(nil).GetPendingDelegatorIterator), chainID, nodeID)
}

// GetPendingStakerIterator mocks base method.
func (m *MockState) GetPendingStakerIterator() (iterator.Iterator[*Staker], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPendingStakerIterator")
	ret0, _ := ret[0].(iterator.Iterator[*Staker])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPendingValidator mocks base method.
func (m *MockState) GetPendingValidator(netID ids.ID, nodeID ids.NodeID) (*Staker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPendingValidator", netID, nodeID)
	ret0, _ := ret[0].(*Staker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPendingValidator indicates an expected call of GetPendingValidator.
func (mr *MockStateMockRecorder) GetPendingValidator(netID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingValidator", reflect.TypeOf((*MockState)(nil).GetPendingValidator), netID, nodeID)
}

// GetRewardUTXOs mocks base method.
func (m *MockState) GetRewardUTXOs(txID ids.ID) ([]*lux.UTXO, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRewardUTXOs", txID)
	ret0, _ := ret[0].([]*lux.UTXO)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRewardUTXOs indicates an expected call of GetRewardUTXOs.
func (mr *MockStateMockRecorder) GetRewardUTXOs(txID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRewardUTXOs", reflect.TypeOf((*MockState)(nil).GetRewardUTXOs), txID)
}

// GetStartTime mocks base method.
func (m *MockState) GetStartTime(nodeID ids.NodeID, netID ids.ID) (time.Time, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStartTime", nodeID, netID)
	ret0, _ := ret[0].(time.Time)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStartTime indicates an expected call of GetStartTime.
func (mr *MockStateMockRecorder) GetStartTime(nodeID, netID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStartTime", reflect.TypeOf((*MockState)(nil).GetStartTime), nodeID, netID)
}

// GetStatelessBlock mocks base method.
func (m *MockState) GetStatelessBlock(blockID ids.ID) (block.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatelessBlock", blockID)
	ret0, _ := ret[0].(block.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatelessBlock indicates an expected call of GetStatelessBlock.
func (mr *MockStateMockRecorder) GetStatelessBlock(blockID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatelessBlock", reflect.TypeOf((*MockState)(nil).GetStatelessBlock), blockID)
}

// GetTimestamp mocks base method.
func (m *MockState) GetTimestamp() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimestamp")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

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

// GetTx mocks base method.
func (m *MockState) GetTx(txID ids.ID) (*txs.Tx, status.Status, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTx", txID)
	ret0, _ := ret[0].(*txs.Tx)
	ret1, _ := ret[1].(status.Status)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetTx indicates an expected call of GetTx.
func (mr *MockStateMockRecorder) GetTx(txID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTx", reflect.TypeOf((*MockState)(nil).GetTx), txID)
}

// GetUTXO mocks base method.
func (m *MockState) GetUTXO(utxoID ids.ID) (*lux.UTXO, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUTXO", utxoID)
	ret0, _ := ret[0].(*lux.UTXO)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUTXO indicates an expected call of GetUTXO.
func (mr *MockStateMockRecorder) GetUTXO(utxoID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUTXO", reflect.TypeOf((*MockState)(nil).GetUTXO), utxoID)
}

// GetUptime mocks base method.
func (m *MockState) GetUptime(nodeID ids.NodeID, netID ids.ID) (time.Duration, time.Duration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUptime", nodeID, netID)
	ret0, _ := ret[0].(time.Duration)
	ret1, _ := ret[1].(time.Duration)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetUptime indicates an expected call of GetUptime.
func (mr *MockStateMockRecorder) GetUptime(nodeID, netID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUptime", reflect.TypeOf((*MockState)(nil).GetUptime), nodeID, netID)
}

// HasExpiry mocks base method.
func (m *MockState) HasExpiry(arg0 ExpiryEntry) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasExpiry", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasExpiry indicates an expected call of HasExpiry.
func (mr *MockStateMockRecorder) HasExpiry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasExpiry", reflect.TypeOf((*MockState)(nil).HasExpiry), arg0)
}

// HasL1Validator mocks base method.
func (m *MockState) HasL1Validator(chainID ids.ID, nodeID ids.NodeID) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasL1Validator", chainID, nodeID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasL1Validator indicates an expected call of HasL1Validator.
func (mr *MockStateMockRecorder) HasL1Validator(chainID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasL1Validator", reflect.TypeOf((*MockState)(nil).HasL1Validator), chainID, nodeID)
}

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

// IsChainNameTaken indicates an expected call of IsChainNameTaken.
func (mr *MockStateMockRecorder) IsChainNameTaken(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsChainNameTaken", reflect.TypeOf((*MockState)(nil).IsChainNameTaken), name)
}

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

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

// PutCurrentDelegator mocks base method.
func (m *MockState) PutCurrentDelegator(staker *Staker) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PutCurrentDelegator", staker)
}

// PutCurrentDelegator indicates an expected call of PutCurrentDelegator.
func (mr *MockStateMockRecorder) PutCurrentDelegator(staker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutCurrentDelegator", reflect.TypeOf((*MockState)(nil).PutCurrentDelegator), staker)
}

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

// PutCurrentValidator indicates an expected call of PutCurrentValidator.
func (mr *MockStateMockRecorder) PutCurrentValidator(staker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutCurrentValidator", reflect.TypeOf((*MockState)(nil).PutCurrentValidator), staker)
}

// PutExpiry mocks base method.
func (m *MockState) PutExpiry(arg0 ExpiryEntry) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PutExpiry", arg0)
}

// PutExpiry indicates an expected call of PutExpiry.
func (mr *MockStateMockRecorder) PutExpiry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutExpiry", reflect.TypeOf((*MockState)(nil).PutExpiry), arg0)
}

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

// PutL1Validator indicates an expected call of PutL1Validator.
func (mr *MockStateMockRecorder) PutL1Validator(validator any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutL1Validator", reflect.TypeOf((*MockState)(nil).PutL1Validator), validator)
}

// PutPendingDelegator mocks base method.
func (m *MockState) PutPendingDelegator(staker *Staker) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PutPendingDelegator", staker)
}

// PutPendingDelegator indicates an expected call of PutPendingDelegator.
func (mr *MockStateMockRecorder) PutPendingDelegator(staker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPendingDelegator", reflect.TypeOf((*MockState)(nil).PutPendingDelegator), staker)
}

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

// PutPendingValidator indicates an expected call of PutPendingValidator.
func (mr *MockStateMockRecorder) PutPendingValidator(staker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPendingValidator", reflect.TypeOf((*MockState)(nil).PutPendingValidator), staker)
}

// ReindexBlocks mocks base method.
func (m *MockState) ReindexBlocks(lock sync.Locker, arg1 log.Logger) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReindexBlocks", lock, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReindexBlocks indicates an expected call of ReindexBlocks.
func (mr *MockStateMockRecorder) ReindexBlocks(lock, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReindexBlocks", reflect.TypeOf((*MockState)(nil).ReindexBlocks), lock, arg1)
}

// SetAccruedFees mocks base method.
func (m *MockState) SetAccruedFees(f uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAccruedFees", f)
}

// SetAccruedFees indicates an expected call of SetAccruedFees.
func (mr *MockStateMockRecorder) SetAccruedFees(f any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccruedFees", reflect.TypeOf((*MockState)(nil).SetAccruedFees), f)
}

// SetCurrentSupply mocks base method.
func (m *MockState) SetCurrentSupply(chainID ids.ID, cs uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCurrentSupply", chainID, cs)
}

// SetCurrentSupply indicates an expected call of SetCurrentSupply.
func (mr *MockStateMockRecorder) SetCurrentSupply(chainID, cs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentSupply", reflect.TypeOf((*MockState)(nil).SetCurrentSupply), chainID, cs)
}

// SetDelegateeReward mocks base method.
func (m *MockState) SetDelegateeReward(netID ids.ID, nodeID ids.NodeID, amount uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDelegateeReward", netID, nodeID, amount)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetDelegateeReward indicates an expected call of SetDelegateeReward.
func (mr *MockStateMockRecorder) SetDelegateeReward(netID, nodeID, amount any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDelegateeReward", reflect.TypeOf((*MockState)(nil).SetDelegateeReward), netID, nodeID, amount)
}

// SetFeeState mocks base method.
func (m *MockState) SetFeeState(f gas.State) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFeeState", f)
}

// SetFeeState indicates an expected call of SetFeeState.
func (mr *MockStateMockRecorder) SetFeeState(f any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFeeState", reflect.TypeOf((*MockState)(nil).SetFeeState), f)
}

// SetHeight mocks base method.
func (m *MockState) SetHeight(height uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHeight", height)
}

// SetHeight indicates an expected call of SetHeight.
func (mr *MockStateMockRecorder) SetHeight(height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeight", reflect.TypeOf((*MockState)(nil).SetHeight), height)
}

// SetL1ValidatorExcess mocks base method.
func (m *MockState) SetL1ValidatorExcess(e gas.Gas) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetL1ValidatorExcess", e)
}

// SetL1ValidatorExcess indicates an expected call of SetL1ValidatorExcess.
func (mr *MockStateMockRecorder) SetL1ValidatorExcess(e any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetL1ValidatorExcess", reflect.TypeOf((*MockState)(nil).SetL1ValidatorExcess), e)
}

// SetLastAccepted mocks base method.
func (m *MockState) SetLastAccepted(blkID ids.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLastAccepted", blkID)
}

// SetLastAccepted indicates an expected call of SetLastAccepted.
func (mr *MockStateMockRecorder) SetLastAccepted(blkID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastAccepted", reflect.TypeOf((*MockState)(nil).SetLastAccepted), blkID)
}

// SetNetOwner mocks base method.
func (m *MockState) SetNetOwner(netID ids.ID, owner fx.Owner) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNetOwner", netID, owner)
}

// SetNetOwner indicates an expected call of SetNetOwner.
func (mr *MockStateMockRecorder) SetNetOwner(netID, owner any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNetOwner", reflect.TypeOf((*MockState)(nil).SetNetOwner), netID, owner)
}

// SetNetToL1Conversion mocks base method.
func (m *MockState) SetNetToL1Conversion(chainID ids.ID, c NetToL1Conversion) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNetToL1Conversion", chainID, c)
}

// SetNetToL1Conversion indicates an expected call of SetNetToL1Conversion.
func (mr *MockStateMockRecorder) SetNetToL1Conversion(chainID, c any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNetToL1Conversion", reflect.TypeOf((*MockState)(nil).SetNetToL1Conversion), chainID, c)
}

// SetTimestamp mocks base method.
func (m *MockState) SetTimestamp(tm time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimestamp", tm)
}

// SetTimestamp indicates an expected call of SetTimestamp.
func (mr *MockStateMockRecorder) SetTimestamp(tm any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimestamp", reflect.TypeOf((*MockState)(nil).SetTimestamp), tm)
}

// SetUptime mocks base method.
func (m *MockState) SetUptime(nodeID ids.NodeID, netID ids.ID, uptime time.Duration, lastUpdated time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUptime", nodeID, netID, uptime, lastUpdated)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetUptime indicates an expected call of SetUptime.
func (mr *MockStateMockRecorder) SetUptime(nodeID, netID, uptime, lastUpdated any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUptime", reflect.TypeOf((*MockState)(nil).SetUptime), nodeID, netID, uptime, lastUpdated)
}

// UTXOIDs mocks base method.
func (m *MockState) UTXOIDs(addr []byte, previous ids.ID, limit int) ([]ids.ID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UTXOIDs", addr, previous, limit)
	ret0, _ := ret[0].([]ids.ID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UTXOIDs indicates an expected call of UTXOIDs.
func (mr *MockStateMockRecorder) UTXOIDs(addr, previous, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UTXOIDs", reflect.TypeOf((*MockState)(nil).UTXOIDs), addr, previous, limit)
}

// WeightOfL1Validators mocks base method.
func (m *MockState) WeightOfL1Validators(chainID ids.ID) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WeightOfL1Validators", chainID)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WeightOfL1Validators indicates an expected call of WeightOfL1Validators.
func (mr *MockStateMockRecorder) WeightOfL1Validators(chainID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeightOfL1Validators", reflect.TypeOf((*MockState)(nil).WeightOfL1Validators), chainID)
}