mock_pool.go

// Code generated by MockGen. DO NOT EDIT.
// Source: x/gamm/types/pool.go

// Package mock_types is a generated GoMock package.
package mocks

import (
	reflect "reflect"
	time "time"

	types "github.com/cosmos/cosmos-sdk/types"
	gomock "github.com/golang/mock/gomock"
)

// MockPoolI is a mock of PoolI interface.
type MockPoolI struct {
	ctrl     *gomock.Controller
	recorder *MockPoolIMockRecorder
}

// MockPoolIMockRecorder is the mock recorder for MockPoolI.
type MockPoolIMockRecorder struct {
	mock *MockPoolI
}

// NewMockPoolI creates a new mock instance.
func NewMockPoolI(ctrl *gomock.Controller) *MockPoolI {
	mock := &MockPoolI{ctrl: ctrl}
	mock.recorder = &MockPoolIMockRecorder{mock}
	return mock
}

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

// CalcExitPoolCoinsFromShares mocks base method.
func (m *MockPoolI) CalcExitPoolCoinsFromShares(ctx types.Context, numShares types.Int, exitFee types.Dec) (types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcExitPoolCoinsFromShares", ctx, numShares, exitFee)
	ret0, _ := ret[0].(types.Coins)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcExitPoolCoinsFromShares indicates an expected call of CalcExitPoolCoinsFromShares.
func (mr *MockPoolIMockRecorder) CalcExitPoolCoinsFromShares(ctx, numShares, exitFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcExitPoolCoinsFromShares", reflect.TypeOf((*MockPoolI)(nil).CalcExitPoolCoinsFromShares), ctx, numShares, exitFee)
}

// CalcInAmtGivenOut mocks base method.
func (m *MockPoolI) CalcInAmtGivenOut(ctx types.Context, tokenOut types.Coins, tokenInDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcInAmtGivenOut", ctx, tokenOut, tokenInDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcInAmtGivenOut indicates an expected call of CalcInAmtGivenOut.
func (mr *MockPoolIMockRecorder) CalcInAmtGivenOut(ctx, tokenOut, tokenInDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcInAmtGivenOut", reflect.TypeOf((*MockPoolI)(nil).CalcInAmtGivenOut), ctx, tokenOut, tokenInDenom, swapFee)
}

// CalcJoinPoolNoSwapShares mocks base method.
func (m *MockPoolI) CalcJoinPoolNoSwapShares(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcJoinPoolNoSwapShares", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(types.Coins)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CalcJoinPoolNoSwapShares indicates an expected call of CalcJoinPoolNoSwapShares.
func (mr *MockPoolIMockRecorder) CalcJoinPoolNoSwapShares(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcJoinPoolNoSwapShares", reflect.TypeOf((*MockPoolI)(nil).CalcJoinPoolNoSwapShares), ctx, tokensIn, swapFee)
}

// CalcJoinPoolShares mocks base method.
func (m *MockPoolI) CalcJoinPoolShares(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcJoinPoolShares", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(types.Coins)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CalcJoinPoolShares indicates an expected call of CalcJoinPoolShares.
func (mr *MockPoolIMockRecorder) CalcJoinPoolShares(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcJoinPoolShares", reflect.TypeOf((*MockPoolI)(nil).CalcJoinPoolShares), ctx, tokensIn, swapFee)
}

// CalcOutAmtGivenIn mocks base method.
func (m *MockPoolI) CalcOutAmtGivenIn(ctx types.Context, tokenIn types.Coins, tokenOutDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcOutAmtGivenIn", ctx, tokenIn, tokenOutDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcOutAmtGivenIn indicates an expected call of CalcOutAmtGivenIn.
func (mr *MockPoolIMockRecorder) CalcOutAmtGivenIn(ctx, tokenIn, tokenOutDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcOutAmtGivenIn", reflect.TypeOf((*MockPoolI)(nil).CalcOutAmtGivenIn), ctx, tokenIn, tokenOutDenom, swapFee)
}

// ExitPool mocks base method.
func (m *MockPoolI) ExitPool(ctx types.Context, numShares types.Int, exitFee types.Dec) (types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExitPool", ctx, numShares, exitFee)
	ret0, _ := ret[0].(types.Coins)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExitPool indicates an expected call of ExitPool.
func (mr *MockPoolIMockRecorder) ExitPool(ctx, numShares, exitFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitPool", reflect.TypeOf((*MockPoolI)(nil).ExitPool), ctx, numShares, exitFee)
}

// GetAddress mocks base method.
func (m *MockPoolI) GetAddress() types.AccAddress {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(types.AccAddress)
	return ret0
}

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

// GetExitFee mocks base method.
func (m *MockPoolI) GetExitFee(ctx types.Context) types.Dec {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExitFee", ctx)
	ret0, _ := ret[0].(types.Dec)
	return ret0
}

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

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

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

// GetSwapFee mocks base method.
func (m *MockPoolI) GetSwapFee(ctx types.Context) types.Dec {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSwapFee", ctx)
	ret0, _ := ret[0].(types.Dec)
	return ret0
}

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

// GetTotalPoolLiquidity mocks base method.
func (m *MockPoolI) GetTotalPoolLiquidity(ctx types.Context) types.Coins {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTotalPoolLiquidity", ctx)
	ret0, _ := ret[0].(types.Coins)
	return ret0
}

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

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

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

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

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

// JoinPool mocks base method.
func (m *MockPoolI) JoinPool(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinPool", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JoinPool indicates an expected call of JoinPool.
func (mr *MockPoolIMockRecorder) JoinPool(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinPool", reflect.TypeOf((*MockPoolI)(nil).JoinPool), ctx, tokensIn, swapFee)
}

// JoinPoolNoSwap mocks base method.
func (m *MockPoolI) JoinPoolNoSwap(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinPoolNoSwap", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JoinPoolNoSwap indicates an expected call of JoinPoolNoSwap.
func (mr *MockPoolIMockRecorder) JoinPoolNoSwap(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinPoolNoSwap", reflect.TypeOf((*MockPoolI)(nil).JoinPoolNoSwap), ctx, tokensIn, swapFee)
}

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

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

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

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

// SpotPrice mocks base method.
func (m *MockPoolI) SpotPrice(ctx types.Context, baseAssetDenom, quoteAssetDenom string) (types.Dec, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpotPrice", ctx, baseAssetDenom, quoteAssetDenom)
	ret0, _ := ret[0].(types.Dec)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SpotPrice indicates an expected call of SpotPrice.
func (mr *MockPoolIMockRecorder) SpotPrice(ctx, baseAssetDenom, quoteAssetDenom interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpotPrice", reflect.TypeOf((*MockPoolI)(nil).SpotPrice), ctx, baseAssetDenom, quoteAssetDenom)
}

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

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

// SwapInAmtGivenOut mocks base method.
func (m *MockPoolI) SwapInAmtGivenOut(ctx types.Context, tokenOut types.Coins, tokenInDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SwapInAmtGivenOut", ctx, tokenOut, tokenInDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwapInAmtGivenOut indicates an expected call of SwapInAmtGivenOut.
func (mr *MockPoolIMockRecorder) SwapInAmtGivenOut(ctx, tokenOut, tokenInDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapInAmtGivenOut", reflect.TypeOf((*MockPoolI)(nil).SwapInAmtGivenOut), ctx, tokenOut, tokenInDenom, swapFee)
}

// SwapOutAmtGivenIn mocks base method.
func (m *MockPoolI) SwapOutAmtGivenIn(ctx types.Context, tokenIn types.Coins, tokenOutDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SwapOutAmtGivenIn", ctx, tokenIn, tokenOutDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwapOutAmtGivenIn indicates an expected call of SwapOutAmtGivenIn.
func (mr *MockPoolIMockRecorder) SwapOutAmtGivenIn(ctx, tokenIn, tokenOutDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOutAmtGivenIn", reflect.TypeOf((*MockPoolI)(nil).SwapOutAmtGivenIn), ctx, tokenIn, tokenOutDenom, swapFee)
}

// MockPoolAmountOutExtension is a mock of PoolAmountOutExtension interface.
type MockPoolAmountOutExtension struct {
	ctrl     *gomock.Controller
	recorder *MockPoolAmountOutExtensionMockRecorder
}

// MockPoolAmountOutExtensionMockRecorder is the mock recorder for MockPoolAmountOutExtension.
type MockPoolAmountOutExtensionMockRecorder struct {
	mock *MockPoolAmountOutExtension
}

// NewMockPoolAmountOutExtension creates a new mock instance.
func NewMockPoolAmountOutExtension(ctrl *gomock.Controller) *MockPoolAmountOutExtension {
	mock := &MockPoolAmountOutExtension{ctrl: ctrl}
	mock.recorder = &MockPoolAmountOutExtensionMockRecorder{mock}
	return mock
}

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

// CalcExitPoolCoinsFromShares mocks base method.
func (m *MockPoolAmountOutExtension) CalcExitPoolCoinsFromShares(ctx types.Context, numShares types.Int, exitFee types.Dec) (types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcExitPoolCoinsFromShares", ctx, numShares, exitFee)
	ret0, _ := ret[0].(types.Coins)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcExitPoolCoinsFromShares indicates an expected call of CalcExitPoolCoinsFromShares.
func (mr *MockPoolAmountOutExtensionMockRecorder) CalcExitPoolCoinsFromShares(ctx, numShares, exitFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcExitPoolCoinsFromShares", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).CalcExitPoolCoinsFromShares), ctx, numShares, exitFee)
}

// CalcInAmtGivenOut mocks base method.
func (m *MockPoolAmountOutExtension) CalcInAmtGivenOut(ctx types.Context, tokenOut types.Coins, tokenInDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcInAmtGivenOut", ctx, tokenOut, tokenInDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcInAmtGivenOut indicates an expected call of CalcInAmtGivenOut.
func (mr *MockPoolAmountOutExtensionMockRecorder) CalcInAmtGivenOut(ctx, tokenOut, tokenInDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcInAmtGivenOut", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).CalcInAmtGivenOut), ctx, tokenOut, tokenInDenom, swapFee)
}

// CalcJoinPoolNoSwapShares mocks base method.
func (m *MockPoolAmountOutExtension) CalcJoinPoolNoSwapShares(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcJoinPoolNoSwapShares", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(types.Coins)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CalcJoinPoolNoSwapShares indicates an expected call of CalcJoinPoolNoSwapShares.
func (mr *MockPoolAmountOutExtensionMockRecorder) CalcJoinPoolNoSwapShares(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcJoinPoolNoSwapShares", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).CalcJoinPoolNoSwapShares), ctx, tokensIn, swapFee)
}

// CalcJoinPoolShares mocks base method.
func (m *MockPoolAmountOutExtension) CalcJoinPoolShares(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcJoinPoolShares", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(types.Coins)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CalcJoinPoolShares indicates an expected call of CalcJoinPoolShares.
func (mr *MockPoolAmountOutExtensionMockRecorder) CalcJoinPoolShares(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcJoinPoolShares", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).CalcJoinPoolShares), ctx, tokensIn, swapFee)
}

// CalcOutAmtGivenIn mocks base method.
func (m *MockPoolAmountOutExtension) CalcOutAmtGivenIn(ctx types.Context, tokenIn types.Coins, tokenOutDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcOutAmtGivenIn", ctx, tokenIn, tokenOutDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcOutAmtGivenIn indicates an expected call of CalcOutAmtGivenIn.
func (mr *MockPoolAmountOutExtensionMockRecorder) CalcOutAmtGivenIn(ctx, tokenIn, tokenOutDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcOutAmtGivenIn", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).CalcOutAmtGivenIn), ctx, tokenIn, tokenOutDenom, swapFee)
}

// CalcTokenInShareAmountOut mocks base method.
func (m *MockPoolAmountOutExtension) CalcTokenInShareAmountOut(ctx types.Context, tokenInDenom string, shareOutAmount types.Int, swapFee types.Dec) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcTokenInShareAmountOut", ctx, tokenInDenom, shareOutAmount, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcTokenInShareAmountOut indicates an expected call of CalcTokenInShareAmountOut.
func (mr *MockPoolAmountOutExtensionMockRecorder) CalcTokenInShareAmountOut(ctx, tokenInDenom, shareOutAmount, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcTokenInShareAmountOut", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).CalcTokenInShareAmountOut), ctx, tokenInDenom, shareOutAmount, swapFee)
}

// ExitPool mocks base method.
func (m *MockPoolAmountOutExtension) ExitPool(ctx types.Context, numShares types.Int, exitFee types.Dec) (types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExitPool", ctx, numShares, exitFee)
	ret0, _ := ret[0].(types.Coins)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExitPool indicates an expected call of ExitPool.
func (mr *MockPoolAmountOutExtensionMockRecorder) ExitPool(ctx, numShares, exitFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitPool", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).ExitPool), ctx, numShares, exitFee)
}

// ExitSwapExactAmountOut mocks base method.
func (m *MockPoolAmountOutExtension) ExitSwapExactAmountOut(ctx types.Context, tokenOut types.Coin, shareInMaxAmount types.Int) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExitSwapExactAmountOut", ctx, tokenOut, shareInMaxAmount)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExitSwapExactAmountOut indicates an expected call of ExitSwapExactAmountOut.
func (mr *MockPoolAmountOutExtensionMockRecorder) ExitSwapExactAmountOut(ctx, tokenOut, shareInMaxAmount interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitSwapExactAmountOut", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).ExitSwapExactAmountOut), ctx, tokenOut, shareInMaxAmount)
}

// GetAddress mocks base method.
func (m *MockPoolAmountOutExtension) GetAddress() types.AccAddress {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(types.AccAddress)
	return ret0
}

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

// GetExitFee mocks base method.
func (m *MockPoolAmountOutExtension) GetExitFee(ctx types.Context) types.Dec {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExitFee", ctx)
	ret0, _ := ret[0].(types.Dec)
	return ret0
}

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

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

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

// GetSwapFee mocks base method.
func (m *MockPoolAmountOutExtension) GetSwapFee(ctx types.Context) types.Dec {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSwapFee", ctx)
	ret0, _ := ret[0].(types.Dec)
	return ret0
}

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

// GetTotalPoolLiquidity mocks base method.
func (m *MockPoolAmountOutExtension) GetTotalPoolLiquidity(ctx types.Context) types.Coins {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTotalPoolLiquidity", ctx)
	ret0, _ := ret[0].(types.Coins)
	return ret0
}

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

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

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

// IncreaseLiquidity mocks base method.
func (m *MockPoolAmountOutExtension) IncreaseLiquidity(sharesOut types.Int, coinsIn types.Coins) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncreaseLiquidity", sharesOut, coinsIn)
}

// IncreaseLiquidity indicates an expected call of IncreaseLiquidity.
func (mr *MockPoolAmountOutExtensionMockRecorder) IncreaseLiquidity(sharesOut, coinsIn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncreaseLiquidity", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).IncreaseLiquidity), sharesOut, coinsIn)
}

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

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

// JoinPool mocks base method.
func (m *MockPoolAmountOutExtension) JoinPool(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinPool", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JoinPool indicates an expected call of JoinPool.
func (mr *MockPoolAmountOutExtensionMockRecorder) JoinPool(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinPool", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).JoinPool), ctx, tokensIn, swapFee)
}

// JoinPoolNoSwap mocks base method.
func (m *MockPoolAmountOutExtension) JoinPoolNoSwap(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinPoolNoSwap", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JoinPoolNoSwap indicates an expected call of JoinPoolNoSwap.
func (mr *MockPoolAmountOutExtensionMockRecorder) JoinPoolNoSwap(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinPoolNoSwap", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).JoinPoolNoSwap), ctx, tokensIn, swapFee)
}

// JoinPoolTokenInMaxShareAmountOut mocks base method.
func (m *MockPoolAmountOutExtension) JoinPoolTokenInMaxShareAmountOut(ctx types.Context, tokenInDenom string, shareOutAmount types.Int) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinPoolTokenInMaxShareAmountOut", ctx, tokenInDenom, shareOutAmount)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JoinPoolTokenInMaxShareAmountOut indicates an expected call of JoinPoolTokenInMaxShareAmountOut.
func (mr *MockPoolAmountOutExtensionMockRecorder) JoinPoolTokenInMaxShareAmountOut(ctx, tokenInDenom, shareOutAmount interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinPoolTokenInMaxShareAmountOut", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).JoinPoolTokenInMaxShareAmountOut), ctx, tokenInDenom, shareOutAmount)
}

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

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

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

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

// SpotPrice mocks base method.
func (m *MockPoolAmountOutExtension) SpotPrice(ctx types.Context, baseAssetDenom, quoteAssetDenom string) (types.Dec, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpotPrice", ctx, baseAssetDenom, quoteAssetDenom)
	ret0, _ := ret[0].(types.Dec)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SpotPrice indicates an expected call of SpotPrice.
func (mr *MockPoolAmountOutExtensionMockRecorder) SpotPrice(ctx, baseAssetDenom, quoteAssetDenom interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpotPrice", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).SpotPrice), ctx, baseAssetDenom, quoteAssetDenom)
}

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

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

// SwapInAmtGivenOut mocks base method.
func (m *MockPoolAmountOutExtension) SwapInAmtGivenOut(ctx types.Context, tokenOut types.Coins, tokenInDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SwapInAmtGivenOut", ctx, tokenOut, tokenInDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwapInAmtGivenOut indicates an expected call of SwapInAmtGivenOut.
func (mr *MockPoolAmountOutExtensionMockRecorder) SwapInAmtGivenOut(ctx, tokenOut, tokenInDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapInAmtGivenOut", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).SwapInAmtGivenOut), ctx, tokenOut, tokenInDenom, swapFee)
}

// SwapOutAmtGivenIn mocks base method.
func (m *MockPoolAmountOutExtension) SwapOutAmtGivenIn(ctx types.Context, tokenIn types.Coins, tokenOutDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SwapOutAmtGivenIn", ctx, tokenIn, tokenOutDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwapOutAmtGivenIn indicates an expected call of SwapOutAmtGivenIn.
func (mr *MockPoolAmountOutExtensionMockRecorder) SwapOutAmtGivenIn(ctx, tokenIn, tokenOutDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOutAmtGivenIn", reflect.TypeOf((*MockPoolAmountOutExtension)(nil).SwapOutAmtGivenIn), ctx, tokenIn, tokenOutDenom, swapFee)
}

// MockPokePoolExtension is a mock of PokePoolExtension interface.
type MockPokePoolExtension struct {
	ctrl     *gomock.Controller
	recorder *MockPokePoolExtensionMockRecorder
}

// MockPokePoolExtensionMockRecorder is the mock recorder for MockPokePoolExtension.
type MockPokePoolExtensionMockRecorder struct {
	mock *MockPokePoolExtension
}

// NewMockPokePoolExtension creates a new mock instance.
func NewMockPokePoolExtension(ctrl *gomock.Controller) *MockPokePoolExtension {
	mock := &MockPokePoolExtension{ctrl: ctrl}
	mock.recorder = &MockPokePoolExtensionMockRecorder{mock}
	return mock
}

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

// CalcExitPoolCoinsFromShares mocks base method.
func (m *MockPokePoolExtension) CalcExitPoolCoinsFromShares(ctx types.Context, numShares types.Int, exitFee types.Dec) (types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcExitPoolCoinsFromShares", ctx, numShares, exitFee)
	ret0, _ := ret[0].(types.Coins)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcExitPoolCoinsFromShares indicates an expected call of CalcExitPoolCoinsFromShares.
func (mr *MockPokePoolExtensionMockRecorder) CalcExitPoolCoinsFromShares(ctx, numShares, exitFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcExitPoolCoinsFromShares", reflect.TypeOf((*MockPokePoolExtension)(nil).CalcExitPoolCoinsFromShares), ctx, numShares, exitFee)
}

// CalcInAmtGivenOut mocks base method.
func (m *MockPokePoolExtension) CalcInAmtGivenOut(ctx types.Context, tokenOut types.Coins, tokenInDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcInAmtGivenOut", ctx, tokenOut, tokenInDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcInAmtGivenOut indicates an expected call of CalcInAmtGivenOut.
func (mr *MockPokePoolExtensionMockRecorder) CalcInAmtGivenOut(ctx, tokenOut, tokenInDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcInAmtGivenOut", reflect.TypeOf((*MockPokePoolExtension)(nil).CalcInAmtGivenOut), ctx, tokenOut, tokenInDenom, swapFee)
}

// CalcJoinPoolNoSwapShares mocks base method.
func (m *MockPokePoolExtension) CalcJoinPoolNoSwapShares(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcJoinPoolNoSwapShares", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(types.Coins)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CalcJoinPoolNoSwapShares indicates an expected call of CalcJoinPoolNoSwapShares.
func (mr *MockPokePoolExtensionMockRecorder) CalcJoinPoolNoSwapShares(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcJoinPoolNoSwapShares", reflect.TypeOf((*MockPokePoolExtension)(nil).CalcJoinPoolNoSwapShares), ctx, tokensIn, swapFee)
}

// CalcJoinPoolShares mocks base method.
func (m *MockPokePoolExtension) CalcJoinPoolShares(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcJoinPoolShares", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(types.Coins)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CalcJoinPoolShares indicates an expected call of CalcJoinPoolShares.
func (mr *MockPokePoolExtensionMockRecorder) CalcJoinPoolShares(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcJoinPoolShares", reflect.TypeOf((*MockPokePoolExtension)(nil).CalcJoinPoolShares), ctx, tokensIn, swapFee)
}

// CalcOutAmtGivenIn mocks base method.
func (m *MockPokePoolExtension) CalcOutAmtGivenIn(ctx types.Context, tokenIn types.Coins, tokenOutDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcOutAmtGivenIn", ctx, tokenIn, tokenOutDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcOutAmtGivenIn indicates an expected call of CalcOutAmtGivenIn.
func (mr *MockPokePoolExtensionMockRecorder) CalcOutAmtGivenIn(ctx, tokenIn, tokenOutDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcOutAmtGivenIn", reflect.TypeOf((*MockPokePoolExtension)(nil).CalcOutAmtGivenIn), ctx, tokenIn, tokenOutDenom, swapFee)
}

// ExitPool mocks base method.
func (m *MockPokePoolExtension) ExitPool(ctx types.Context, numShares types.Int, exitFee types.Dec) (types.Coins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExitPool", ctx, numShares, exitFee)
	ret0, _ := ret[0].(types.Coins)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExitPool indicates an expected call of ExitPool.
func (mr *MockPokePoolExtensionMockRecorder) ExitPool(ctx, numShares, exitFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitPool", reflect.TypeOf((*MockPokePoolExtension)(nil).ExitPool), ctx, numShares, exitFee)
}

// GetAddress mocks base method.
func (m *MockPokePoolExtension) GetAddress() types.AccAddress {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(types.AccAddress)
	return ret0
}

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

// GetExitFee mocks base method.
func (m *MockPokePoolExtension) GetExitFee(ctx types.Context) types.Dec {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExitFee", ctx)
	ret0, _ := ret[0].(types.Dec)
	return ret0
}

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

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

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

// GetSwapFee mocks base method.
func (m *MockPokePoolExtension) GetSwapFee(ctx types.Context) types.Dec {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSwapFee", ctx)
	ret0, _ := ret[0].(types.Dec)
	return ret0
}

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

// GetTotalPoolLiquidity mocks base method.
func (m *MockPokePoolExtension) GetTotalPoolLiquidity(ctx types.Context) types.Coins {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTotalPoolLiquidity", ctx)
	ret0, _ := ret[0].(types.Coins)
	return ret0
}

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

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

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

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

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

// JoinPool mocks base method.
func (m *MockPokePoolExtension) JoinPool(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinPool", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JoinPool indicates an expected call of JoinPool.
func (mr *MockPokePoolExtensionMockRecorder) JoinPool(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinPool", reflect.TypeOf((*MockPokePoolExtension)(nil).JoinPool), ctx, tokensIn, swapFee)
}

// JoinPoolNoSwap mocks base method.
func (m *MockPokePoolExtension) JoinPoolNoSwap(ctx types.Context, tokensIn types.Coins, swapFee types.Dec) (types.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinPoolNoSwap", ctx, tokensIn, swapFee)
	ret0, _ := ret[0].(types.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JoinPoolNoSwap indicates an expected call of JoinPoolNoSwap.
func (mr *MockPokePoolExtensionMockRecorder) JoinPoolNoSwap(ctx, tokensIn, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinPoolNoSwap", reflect.TypeOf((*MockPokePoolExtension)(nil).JoinPoolNoSwap), ctx, tokensIn, swapFee)
}

// PokePool mocks base method.
func (m *MockPokePoolExtension) PokePool(blockTime time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PokePool", blockTime)
}

// PokePool indicates an expected call of PokePool.
func (mr *MockPokePoolExtensionMockRecorder) PokePool(blockTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PokePool", reflect.TypeOf((*MockPokePoolExtension)(nil).PokePool), blockTime)
}

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

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

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

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

// SpotPrice mocks base method.
func (m *MockPokePoolExtension) SpotPrice(ctx types.Context, baseAssetDenom, quoteAssetDenom string) (types.Dec, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpotPrice", ctx, baseAssetDenom, quoteAssetDenom)
	ret0, _ := ret[0].(types.Dec)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SpotPrice indicates an expected call of SpotPrice.
func (mr *MockPokePoolExtensionMockRecorder) SpotPrice(ctx, baseAssetDenom, quoteAssetDenom interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpotPrice", reflect.TypeOf((*MockPokePoolExtension)(nil).SpotPrice), ctx, baseAssetDenom, quoteAssetDenom)
}

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

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

// SwapInAmtGivenOut mocks base method.
func (m *MockPokePoolExtension) SwapInAmtGivenOut(ctx types.Context, tokenOut types.Coins, tokenInDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SwapInAmtGivenOut", ctx, tokenOut, tokenInDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwapInAmtGivenOut indicates an expected call of SwapInAmtGivenOut.
func (mr *MockPokePoolExtensionMockRecorder) SwapInAmtGivenOut(ctx, tokenOut, tokenInDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapInAmtGivenOut", reflect.TypeOf((*MockPokePoolExtension)(nil).SwapInAmtGivenOut), ctx, tokenOut, tokenInDenom, swapFee)
}

// SwapOutAmtGivenIn mocks base method.
func (m *MockPokePoolExtension) SwapOutAmtGivenIn(ctx types.Context, tokenIn types.Coins, tokenOutDenom string, swapFee types.Dec) (types.Coin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SwapOutAmtGivenIn", ctx, tokenIn, tokenOutDenom, swapFee)
	ret0, _ := ret[0].(types.Coin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwapOutAmtGivenIn indicates an expected call of SwapOutAmtGivenIn.
func (mr *MockPokePoolExtensionMockRecorder) SwapOutAmtGivenIn(ctx, tokenIn, tokenOutDenom, swapFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOutAmtGivenIn", reflect.TypeOf((*MockPokePoolExtension)(nil).SwapOutAmtGivenIn), ctx, tokenIn, tokenOutDenom, swapFee)
}