From 56f12aaa43849fb39548b6f396f3ac3bdc32d52b Mon Sep 17 00:00:00 2001
From: toteki <63419657+toteki@users.noreply.github.com>
Date: Wed, 26 Jul 2023 18:01:21 -0600
Subject: [PATCH 1/6] add module-based supply and withdraw to leverage module

---
 CHANGELOG.md                  |   1 +
 x/leverage/keeper/keeper.go   | 108 ++++++++++++++++++++++++++++------
 x/metoken/expected_keepers.go |   4 +-
 x/metoken/keeper/redeem.go    |   6 +-
 x/metoken/keeper/swap.go      |   6 +-
 5 files changed, 100 insertions(+), 25 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f65ca0e898..441db7fbc8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -55,6 +55,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 - [2159](https://github.com/umee-network/umee/pull/2159) Add hard market cap for token emission.
 - [2155](https://github.com/umee-network/umee/pull/2155) `bpmath`: basis points math package.
 - [2166](https://github.com/umee-network/umee/pull/2166) Basis Points: `MulDec`
+- [21XX](https://github.com/umee-network/umee/pull/21XX) Add SupplyFromModule and WithdrawToModule to leverage keeper.
 
 ### Improvements
 
diff --git a/x/leverage/keeper/keeper.go b/x/leverage/keeper/keeper.go
index 6b064042f2..abbfa0d954 100644
--- a/x/leverage/keeper/keeper.go
+++ b/x/leverage/keeper/keeper.go
@@ -12,7 +12,6 @@ import (
 
 	"github.com/umee-network/umee/v5/util/coin"
 	"github.com/umee-network/umee/v5/x/leverage/types"
-	"github.com/umee-network/umee/v5/x/metoken"
 )
 
 type Keeper struct {
@@ -82,6 +81,47 @@ func (k Keeper) ModuleBalance(ctx sdk.Context, denom string) sdk.Coin {
 	return sdk.NewCoin(denom, amount)
 }
 
+// SupplyFromModule attempts to deposit assets into the leverage module account in
+// exchange for uTokens on behalf of another module. In addition to the regular error
+// return, also returns a boolean which indicates whether the error was recoverable.
+// A recoverable = true error means SupplyFromModule was aborted without harming state.
+func (k Keeper) SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Coin) (sdk.Coin, error, bool) {
+	if err := k.validateSupply(ctx, coin); err != nil {
+		return sdk.Coin{}, err, true
+	}
+
+	// determine uToken amount to mint
+	uToken, err := k.ExchangeToken(ctx, coin)
+	if err != nil {
+		return sdk.Coin{}, err, true
+	}
+
+	// All errors past this point are considered non-recoverable
+
+	// send token balance to leverage module account
+	err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, fromModule, types.ModuleName, sdk.NewCoins(coin))
+	if err != nil {
+		return sdk.Coin{}, err, false
+	}
+
+	// mint uToken and set new total uToken supply
+	uTokens := sdk.NewCoins(uToken)
+	if err = k.bankKeeper.MintCoins(ctx, types.ModuleName, uTokens); err != nil {
+		return sdk.Coin{}, err, false
+	}
+	if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Add(uToken)); err != nil {
+		return sdk.Coin{}, err, false
+	}
+
+	// The uTokens are sent to supplier module
+	if err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, fromModule, uTokens); err != nil {
+		return sdk.Coin{}, err, false
+	}
+
+	// On nil error, recoverable is set to true
+	return uToken, nil, true
+}
+
 // Supply attempts to deposit assets into the leverage module account in
 // exchange for uTokens. If asset type is invalid or account balance is
 // insufficient, we return an error. Returns the amount of uTokens minted.
@@ -112,14 +152,7 @@ func (k Keeper) Supply(ctx sdk.Context, supplierAddr sdk.AccAddress, coin sdk.Co
 	}
 
 	// The uTokens are sent to supplier address
-	// Only base accounts and x/metoken module account are supported.
-	if supplierAddr.Equals(k.meTokenAddr) {
-		err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, metoken.ModuleName, uTokens)
-	} else {
-		err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, uTokens)
-	}
-
-	if err != nil {
+	if err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, uTokens); err != nil {
 		return sdk.Coin{}, err
 	}
 
@@ -193,15 +226,8 @@ func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sd
 	}
 
 	// send the base assets to supplier
-	// Only base accounts and x/metoken module account are supported.
 	tokens := sdk.NewCoins(token)
-	if supplierAddr.Equals(k.meTokenAddr) {
-		err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, metoken.ModuleName, tokens)
-	} else {
-		err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, tokens)
-	}
-
-	if err != nil {
+	if err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, tokens); err != nil {
 		return sdk.Coin{}, isFromCollateral, err
 	}
 
@@ -216,6 +242,54 @@ func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sd
 	return token, isFromCollateral, nil
 }
 
+// WithdrawToModule attempts to redeem uTokens from the leverage module in exchange for base tokens.
+// This is done on behalf of another module, not by a user account. Modules do not have collateral.
+// If the uToken denom is invalid or balances are insufficient to withdraw the amount requested,
+// returns an error. Returns the amount of base tokens received. In addition to the regular error
+// return, also returns a boolean which indicates whether the error was recoverable.
+// A recoverable = true error means WithdrawToModule was aborted without harming state.
+func (k Keeper) WithdrawToModule(ctx sdk.Context, toModule string, uToken sdk.Coin) (sdk.Coin, error, bool) {
+	if err := validateUToken(uToken); err != nil {
+		return sdk.Coin{}, err, true
+	}
+
+	// calculate base asset amount to withdraw
+	token, err := k.ExchangeUToken(ctx, uToken)
+	if err != nil {
+		return sdk.Coin{}, err, true
+	}
+
+	// Ensure leverage module account has sufficient unreserved tokens to withdraw
+	availableAmount := k.AvailableLiquidity(ctx, token.Denom)
+	if token.Amount.GT(availableAmount) {
+		return sdk.Coin{}, types.ErrLendingPoolInsufficient.Wrap(token.String()), true
+	}
+
+	// All errors past this point are considered non-recoverable
+
+	// transfer uTokens to the leverage module account
+	if err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, toModule, types.ModuleName, sdk.NewCoins(uToken)); err != nil {
+		return sdk.Coin{}, err, false
+	}
+
+	// send the base assets to withdrawing module
+	tokens := sdk.NewCoins(token)
+	if err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, toModule, tokens); err != nil {
+		return sdk.Coin{}, err, false
+	}
+
+	// burn the uTokens and set the new total uToken supply
+	if err = k.bankKeeper.BurnCoins(ctx, types.ModuleName, sdk.NewCoins(uToken)); err != nil {
+		return sdk.Coin{}, err, false
+	}
+	if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Sub(uToken)); err != nil {
+		return sdk.Coin{}, err, false
+	}
+
+	// On nil error, recoverable is set to true
+	return token, nil, true
+}
+
 // Borrow attempts to borrow tokens from the leverage module account using
 // collateral uTokens. If asset type is invalid,  or module balance is insufficient,
 // we return an error.
diff --git a/x/metoken/expected_keepers.go b/x/metoken/expected_keepers.go
index 768e627f71..0a8ebf21b3 100644
--- a/x/metoken/expected_keepers.go
+++ b/x/metoken/expected_keepers.go
@@ -24,8 +24,8 @@ type LeverageKeeper interface {
 	GetTokenSettings(ctx sdk.Context, denom string) (ltypes.Token, error)
 	ExchangeToken(ctx sdk.Context, token sdk.Coin) (sdk.Coin, error)
 	ExchangeUToken(ctx sdk.Context, uToken sdk.Coin) (sdk.Coin, error)
-	Supply(ctx sdk.Context, supplierAddr sdk.AccAddress, coin sdk.Coin) (sdk.Coin, error)
-	Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sdk.Coin) (sdk.Coin, bool, error)
+	SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Coin) (sdk.Coin, error, bool)
+	WithdrawToModule(ctx sdk.Context, toModule string, uToken sdk.Coin) (sdk.Coin, error, bool)
 	ModuleMaxWithdraw(ctx sdk.Context, spendableUTokens sdk.Coin) (sdkmath.Int, error)
 	GetTotalSupply(ctx sdk.Context, denom string) (sdk.Coin, error)
 	GetAllSupplied(ctx sdk.Context, supplierAddr sdk.AccAddress) (sdk.Coins, error)
diff --git a/x/metoken/keeper/redeem.go b/x/metoken/keeper/redeem.go
index fb09f2cc49..3118c83933 100644
--- a/x/metoken/keeper/redeem.go
+++ b/x/metoken/keeper/redeem.go
@@ -164,13 +164,13 @@ func (k Keeper) withdrawFromLeverage(tokensToWithdraw sdk.Coin) (sdk.Coin, error
 		return coin.Zero(tokensToWithdraw.Denom), nil
 	}
 
-	tokensWithdrawn, _, err := k.leverageKeeper.Withdraw(
+	tokensWithdrawn, err, recoverable := k.leverageKeeper.WithdrawToModule(
 		*k.ctx,
-		ModuleAddr(),
+		metoken.ModuleName,
 		sdk.NewCoin(uTokensFromLeverage.Denom, sdk.MinInt(availableUTokensFromLeverage, uTokensFromLeverage.Amount)),
 	)
 	if err != nil {
-		return sdk.Coin{}, errors.Wrap(err, false)
+		return sdk.Coin{}, errors.Wrap(err, recoverable)
 	}
 
 	return tokensWithdrawn, nil
diff --git a/x/metoken/keeper/swap.go b/x/metoken/keeper/swap.go
index 6f51512a37..fa70b0efd6 100644
--- a/x/metoken/keeper/swap.go
+++ b/x/metoken/keeper/swap.go
@@ -141,12 +141,12 @@ func (k Keeper) supplyToLeverage(tokensToSupply sdk.Coin) (sdkmath.Int, error) {
 		}
 	}
 
-	if _, err = k.leverageKeeper.Supply(
+	if _, err, recoverable := k.leverageKeeper.SupplyFromModule(
 		*k.ctx,
-		ModuleAddr(),
+		metoken.ModuleName,
 		tokensToSupply,
 	); err != nil {
-		return sdkmath.Int{}, errors.Wrap(err, false)
+		return sdkmath.Int{}, errors.Wrap(err, recoverable)
 	}
 
 	return tokensToSupply.Amount, nil

From c3a203315f47caf608940f6058de61bc7a4e0679 Mon Sep 17 00:00:00 2001
From: toteki <63419657+toteki@users.noreply.github.com>
Date: Wed, 26 Jul 2023 18:03:54 -0600
Subject: [PATCH 2/6] cl++

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 441db7fbc8..5f10c2f590 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -55,7 +55,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 - [2159](https://github.com/umee-network/umee/pull/2159) Add hard market cap for token emission.
 - [2155](https://github.com/umee-network/umee/pull/2155) `bpmath`: basis points math package.
 - [2166](https://github.com/umee-network/umee/pull/2166) Basis Points: `MulDec`
-- [21XX](https://github.com/umee-network/umee/pull/21XX) Add SupplyFromModule and WithdrawToModule to leverage keeper.
+- [2170](https://github.com/umee-network/umee/pull/2170) Add SupplyFromModule and WithdrawToModule to leverage keeper.
 
 ### Improvements
 

From 767eac3dc5a8d98a0fcb5be99ba87e9672986e81 Mon Sep 17 00:00:00 2001
From: toteki <63419657+toteki@users.noreply.github.com>
Date: Thu, 27 Jul 2023 07:06:48 -0600
Subject: [PATCH 3/6] change return order

---
 x/leverage/keeper/keeper.go   | 34 +++++++++++++++++-----------------
 x/metoken/expected_keepers.go |  4 ++--
 x/metoken/keeper/redeem.go    |  2 +-
 x/metoken/keeper/swap.go      |  2 +-
 4 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/x/leverage/keeper/keeper.go b/x/leverage/keeper/keeper.go
index abbfa0d954..26c5156d78 100644
--- a/x/leverage/keeper/keeper.go
+++ b/x/leverage/keeper/keeper.go
@@ -85,15 +85,15 @@ func (k Keeper) ModuleBalance(ctx sdk.Context, denom string) sdk.Coin {
 // exchange for uTokens on behalf of another module. In addition to the regular error
 // return, also returns a boolean which indicates whether the error was recoverable.
 // A recoverable = true error means SupplyFromModule was aborted without harming state.
-func (k Keeper) SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Coin) (sdk.Coin, error, bool) {
+func (k Keeper) SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Coin) (sdk.Coin, bool, error) {
 	if err := k.validateSupply(ctx, coin); err != nil {
-		return sdk.Coin{}, err, true
+		return sdk.Coin{}, true, err
 	}
 
 	// determine uToken amount to mint
 	uToken, err := k.ExchangeToken(ctx, coin)
 	if err != nil {
-		return sdk.Coin{}, err, true
+		return sdk.Coin{}, true, err
 	}
 
 	// All errors past this point are considered non-recoverable
@@ -101,25 +101,25 @@ func (k Keeper) SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Co
 	// send token balance to leverage module account
 	err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, fromModule, types.ModuleName, sdk.NewCoins(coin))
 	if err != nil {
-		return sdk.Coin{}, err, false
+		return sdk.Coin{}, false, err
 	}
 
 	// mint uToken and set new total uToken supply
 	uTokens := sdk.NewCoins(uToken)
 	if err = k.bankKeeper.MintCoins(ctx, types.ModuleName, uTokens); err != nil {
-		return sdk.Coin{}, err, false
+		return sdk.Coin{}, false, err
 	}
 	if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Add(uToken)); err != nil {
-		return sdk.Coin{}, err, false
+		return sdk.Coin{}, false, err
 	}
 
 	// The uTokens are sent to supplier module
 	if err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, fromModule, uTokens); err != nil {
-		return sdk.Coin{}, err, false
+		return sdk.Coin{}, false, err
 	}
 
 	// On nil error, recoverable is set to true
-	return uToken, nil, true
+	return uToken, true, nil
 }
 
 // Supply attempts to deposit assets into the leverage module account in
@@ -248,46 +248,46 @@ func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sd
 // returns an error. Returns the amount of base tokens received. In addition to the regular error
 // return, also returns a boolean which indicates whether the error was recoverable.
 // A recoverable = true error means WithdrawToModule was aborted without harming state.
-func (k Keeper) WithdrawToModule(ctx sdk.Context, toModule string, uToken sdk.Coin) (sdk.Coin, error, bool) {
+func (k Keeper) WithdrawToModule(ctx sdk.Context, toModule string, uToken sdk.Coin) (sdk.Coin, bool, error) {
 	if err := validateUToken(uToken); err != nil {
-		return sdk.Coin{}, err, true
+		return sdk.Coin{}, true, err
 	}
 
 	// calculate base asset amount to withdraw
 	token, err := k.ExchangeUToken(ctx, uToken)
 	if err != nil {
-		return sdk.Coin{}, err, true
+		return sdk.Coin{}, true, err
 	}
 
 	// Ensure leverage module account has sufficient unreserved tokens to withdraw
 	availableAmount := k.AvailableLiquidity(ctx, token.Denom)
 	if token.Amount.GT(availableAmount) {
-		return sdk.Coin{}, types.ErrLendingPoolInsufficient.Wrap(token.String()), true
+		return sdk.Coin{}, true, types.ErrLendingPoolInsufficient.Wrap(token.String())
 	}
 
 	// All errors past this point are considered non-recoverable
 
 	// transfer uTokens to the leverage module account
 	if err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, toModule, types.ModuleName, sdk.NewCoins(uToken)); err != nil {
-		return sdk.Coin{}, err, false
+		return sdk.Coin{}, false, err
 	}
 
 	// send the base assets to withdrawing module
 	tokens := sdk.NewCoins(token)
 	if err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, toModule, tokens); err != nil {
-		return sdk.Coin{}, err, false
+		return sdk.Coin{}, false, err
 	}
 
 	// burn the uTokens and set the new total uToken supply
 	if err = k.bankKeeper.BurnCoins(ctx, types.ModuleName, sdk.NewCoins(uToken)); err != nil {
-		return sdk.Coin{}, err, false
+		return sdk.Coin{}, false, err
 	}
 	if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Sub(uToken)); err != nil {
-		return sdk.Coin{}, err, false
+		return sdk.Coin{}, false, err
 	}
 
 	// On nil error, recoverable is set to true
-	return token, nil, true
+	return token, true, nil
 }
 
 // Borrow attempts to borrow tokens from the leverage module account using
diff --git a/x/metoken/expected_keepers.go b/x/metoken/expected_keepers.go
index 0a8ebf21b3..0db126576b 100644
--- a/x/metoken/expected_keepers.go
+++ b/x/metoken/expected_keepers.go
@@ -24,8 +24,8 @@ type LeverageKeeper interface {
 	GetTokenSettings(ctx sdk.Context, denom string) (ltypes.Token, error)
 	ExchangeToken(ctx sdk.Context, token sdk.Coin) (sdk.Coin, error)
 	ExchangeUToken(ctx sdk.Context, uToken sdk.Coin) (sdk.Coin, error)
-	SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Coin) (sdk.Coin, error, bool)
-	WithdrawToModule(ctx sdk.Context, toModule string, uToken sdk.Coin) (sdk.Coin, error, bool)
+	SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Coin) (sdk.Coin, bool, error)
+	WithdrawToModule(ctx sdk.Context, toModule string, uToken sdk.Coin) (sdk.Coin, bool, error)
 	ModuleMaxWithdraw(ctx sdk.Context, spendableUTokens sdk.Coin) (sdkmath.Int, error)
 	GetTotalSupply(ctx sdk.Context, denom string) (sdk.Coin, error)
 	GetAllSupplied(ctx sdk.Context, supplierAddr sdk.AccAddress) (sdk.Coins, error)
diff --git a/x/metoken/keeper/redeem.go b/x/metoken/keeper/redeem.go
index 3118c83933..a56bd7ee55 100644
--- a/x/metoken/keeper/redeem.go
+++ b/x/metoken/keeper/redeem.go
@@ -164,7 +164,7 @@ func (k Keeper) withdrawFromLeverage(tokensToWithdraw sdk.Coin) (sdk.Coin, error
 		return coin.Zero(tokensToWithdraw.Denom), nil
 	}
 
-	tokensWithdrawn, err, recoverable := k.leverageKeeper.WithdrawToModule(
+	tokensWithdrawn, recoverable, err := k.leverageKeeper.WithdrawToModule(
 		*k.ctx,
 		metoken.ModuleName,
 		sdk.NewCoin(uTokensFromLeverage.Denom, sdk.MinInt(availableUTokensFromLeverage, uTokensFromLeverage.Amount)),
diff --git a/x/metoken/keeper/swap.go b/x/metoken/keeper/swap.go
index fa70b0efd6..837b96a7e7 100644
--- a/x/metoken/keeper/swap.go
+++ b/x/metoken/keeper/swap.go
@@ -141,7 +141,7 @@ func (k Keeper) supplyToLeverage(tokensToSupply sdk.Coin) (sdkmath.Int, error) {
 		}
 	}
 
-	if _, err, recoverable := k.leverageKeeper.SupplyFromModule(
+	if _, recoverable, err := k.leverageKeeper.SupplyFromModule(
 		*k.ctx,
 		metoken.ModuleName,
 		tokensToSupply,

From 45f7590c532707e63830a8127c59cf0417e523ab Mon Sep 17 00:00:00 2001
From: toteki <63419657+toteki@users.noreply.github.com>
Date: Thu, 27 Jul 2023 07:35:58 -0600
Subject: [PATCH 4/6] godoc++ and function order

---
 x/leverage/keeper/keeper.go | 66 +++++++++++++++++++------------------
 1 file changed, 34 insertions(+), 32 deletions(-)

diff --git a/x/leverage/keeper/keeper.go b/x/leverage/keeper/keeper.go
index 26c5156d78..d3713b18dd 100644
--- a/x/leverage/keeper/keeper.go
+++ b/x/leverage/keeper/keeper.go
@@ -81,82 +81,83 @@ func (k Keeper) ModuleBalance(ctx sdk.Context, denom string) sdk.Coin {
 	return sdk.NewCoin(denom, amount)
 }
 
-// SupplyFromModule attempts to deposit assets into the leverage module account in
-// exchange for uTokens on behalf of another module. In addition to the regular error
-// return, also returns a boolean which indicates whether the error was recoverable.
-// A recoverable = true error means SupplyFromModule was aborted without harming state.
-func (k Keeper) SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Coin) (sdk.Coin, bool, error) {
+// Supply attempts to deposit assets into the leverage module account in
+// exchange for uTokens. If asset type is invalid or account balance is
+// insufficient, we return an error. Returns the amount of uTokens minted.
+// Note: For supplying from a module account instead of a user, use SupplyFromModule.
+func (k Keeper) Supply(ctx sdk.Context, supplierAddr sdk.AccAddress, coin sdk.Coin) (sdk.Coin, error) {
 	if err := k.validateSupply(ctx, coin); err != nil {
-		return sdk.Coin{}, true, err
+		return sdk.Coin{}, err
 	}
 
 	// determine uToken amount to mint
 	uToken, err := k.ExchangeToken(ctx, coin)
 	if err != nil {
-		return sdk.Coin{}, true, err
+		return sdk.Coin{}, err
 	}
 
-	// All errors past this point are considered non-recoverable
-
 	// send token balance to leverage module account
-	err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, fromModule, types.ModuleName, sdk.NewCoins(coin))
+	err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, supplierAddr, types.ModuleName, sdk.NewCoins(coin))
 	if err != nil {
-		return sdk.Coin{}, false, err
+		return sdk.Coin{}, err
 	}
 
 	// mint uToken and set new total uToken supply
 	uTokens := sdk.NewCoins(uToken)
 	if err = k.bankKeeper.MintCoins(ctx, types.ModuleName, uTokens); err != nil {
-		return sdk.Coin{}, false, err
+		return sdk.Coin{}, err
 	}
 	if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Add(uToken)); err != nil {
-		return sdk.Coin{}, false, err
+		return sdk.Coin{}, err
 	}
 
-	// The uTokens are sent to supplier module
-	if err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, fromModule, uTokens); err != nil {
-		return sdk.Coin{}, false, err
+	// The uTokens are sent to supplier address
+	if err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, uTokens); err != nil {
+		return sdk.Coin{}, err
 	}
 
-	// On nil error, recoverable is set to true
-	return uToken, true, nil
+	return uToken, nil
 }
 
-// Supply attempts to deposit assets into the leverage module account in
-// exchange for uTokens. If asset type is invalid or account balance is
-// insufficient, we return an error. Returns the amount of uTokens minted.
-func (k Keeper) Supply(ctx sdk.Context, supplierAddr sdk.AccAddress, coin sdk.Coin) (sdk.Coin, error) {
+// SupplyFromModule attempts to deposit assets into the leverage module account in
+// exchange for uTokens on behalf of another module. In addition to the regular error
+// return, also returns a boolean which indicates whether the error was recoverable.
+// A recoverable = true error means SupplyFromModule was aborted without harming state.
+func (k Keeper) SupplyFromModule(ctx sdk.Context, fromModule string, coin sdk.Coin) (sdk.Coin, bool, error) {
 	if err := k.validateSupply(ctx, coin); err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, true, err
 	}
 
 	// determine uToken amount to mint
 	uToken, err := k.ExchangeToken(ctx, coin)
 	if err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, true, err
 	}
 
+	// All errors past this point are considered non-recoverable
+
 	// send token balance to leverage module account
-	err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, supplierAddr, types.ModuleName, sdk.NewCoins(coin))
+	err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, fromModule, types.ModuleName, sdk.NewCoins(coin))
 	if err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, false, err
 	}
 
 	// mint uToken and set new total uToken supply
 	uTokens := sdk.NewCoins(uToken)
 	if err = k.bankKeeper.MintCoins(ctx, types.ModuleName, uTokens); err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, false, err
 	}
 	if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Add(uToken)); err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, false, err
 	}
 
-	// The uTokens are sent to supplier address
-	if err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, uTokens); err != nil {
-		return sdk.Coin{}, err
+	// The uTokens are sent to supplier module
+	if err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, fromModule, uTokens); err != nil {
+		return sdk.Coin{}, false, err
 	}
 
-	return uToken, nil
+	// On nil error, recoverable is set to true
+	return uToken, true, nil
 }
 
 // Withdraw attempts to redeem uTokens from the leverage module in exchange for base tokens.
@@ -166,6 +167,7 @@ func (k Keeper) Supply(ctx sdk.Context, supplierAddr sdk.AccAddress, coin sdk.Co
 // This function does NOT check that a borrower remains under their borrow limit or that
 // collateral liquidity remains healthy - those assertions have been moved to MsgServer.
 // Returns a boolean which is true if some or all of the withdrawn uTokens were from collateral.
+// Note: For withdrawing to a module account instead of a user, use WithdrawToModule.
 func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sdk.Coin) (sdk.Coin, bool, error) {
 	isFromCollateral := false
 

From d00489b72e79f39374fa76463819ca1617df743e Mon Sep 17 00:00:00 2001
From: Egor Kostetskiy <kosegor@gmail.com>
Date: Thu, 27 Jul 2023 10:38:10 -0300
Subject: [PATCH 5/6] mocks

---
 x/metoken/mocks/keepers.go | 199 +++++++++++++++++++------------------
 1 file changed, 103 insertions(+), 96 deletions(-)

diff --git a/x/metoken/mocks/keepers.go b/x/metoken/mocks/keepers.go
index 5ed6732ffe..bdb38ee925 100644
--- a/x/metoken/mocks/keepers.go
+++ b/x/metoken/mocks/keepers.go
@@ -573,12 +573,12 @@ type MockLeverageKeeper struct {
 	// ModuleMaxWithdrawFunc is an instance of a mock function object
 	// controlling the behavior of the method ModuleMaxWithdraw.
 	ModuleMaxWithdrawFunc *LeverageKeeperModuleMaxWithdrawFunc
-	// SupplyFunc is an instance of a mock function object controlling the
-	// behavior of the method Supply.
-	SupplyFunc *LeverageKeeperSupplyFunc
-	// WithdrawFunc is an instance of a mock function object controlling the
-	// behavior of the method Withdraw.
-	WithdrawFunc *LeverageKeeperWithdrawFunc
+	// SupplyFromModuleFunc is an instance of a mock function object
+	// controlling the behavior of the method SupplyFromModule.
+	SupplyFromModuleFunc *LeverageKeeperSupplyFromModuleFunc
+	// WithdrawToModuleFunc is an instance of a mock function object
+	// controlling the behavior of the method WithdrawToModule.
+	WithdrawToModuleFunc *LeverageKeeperWithdrawToModuleFunc
 }
 
 // NewMockLeverageKeeper creates a new mock of the LeverageKeeper interface.
@@ -615,13 +615,13 @@ func NewMockLeverageKeeper() *MockLeverageKeeper {
 				return
 			},
 		},
-		SupplyFunc: &LeverageKeeperSupplyFunc{
-			defaultHook: func(types.Context, types.AccAddress, types.Coin) (r0 types.Coin, r1 error) {
+		SupplyFromModuleFunc: &LeverageKeeperSupplyFromModuleFunc{
+			defaultHook: func(types.Context, string, types.Coin) (r0 types.Coin, r1 error, r2 bool) {
 				return
 			},
 		},
-		WithdrawFunc: &LeverageKeeperWithdrawFunc{
-			defaultHook: func(types.Context, types.AccAddress, types.Coin) (r0 types.Coin, r1 bool, r2 error) {
+		WithdrawToModuleFunc: &LeverageKeeperWithdrawToModuleFunc{
+			defaultHook: func(types.Context, string, types.Coin) (r0 types.Coin, r1 error, r2 bool) {
 				return
 			},
 		},
@@ -662,14 +662,14 @@ func NewStrictMockLeverageKeeper() *MockLeverageKeeper {
 				panic("unexpected invocation of MockLeverageKeeper.ModuleMaxWithdraw")
 			},
 		},
-		SupplyFunc: &LeverageKeeperSupplyFunc{
-			defaultHook: func(types.Context, types.AccAddress, types.Coin) (types.Coin, error) {
-				panic("unexpected invocation of MockLeverageKeeper.Supply")
+		SupplyFromModuleFunc: &LeverageKeeperSupplyFromModuleFunc{
+			defaultHook: func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+				panic("unexpected invocation of MockLeverageKeeper.SupplyFromModule")
 			},
 		},
-		WithdrawFunc: &LeverageKeeperWithdrawFunc{
-			defaultHook: func(types.Context, types.AccAddress, types.Coin) (types.Coin, bool, error) {
-				panic("unexpected invocation of MockLeverageKeeper.Withdraw")
+		WithdrawToModuleFunc: &LeverageKeeperWithdrawToModuleFunc{
+			defaultHook: func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+				panic("unexpected invocation of MockLeverageKeeper.WithdrawToModule")
 			},
 		},
 	}
@@ -698,11 +698,11 @@ func NewMockLeverageKeeperFrom(i metoken.LeverageKeeper) *MockLeverageKeeper {
 		ModuleMaxWithdrawFunc: &LeverageKeeperModuleMaxWithdrawFunc{
 			defaultHook: i.ModuleMaxWithdraw,
 		},
-		SupplyFunc: &LeverageKeeperSupplyFunc{
-			defaultHook: i.Supply,
+		SupplyFromModuleFunc: &LeverageKeeperSupplyFromModuleFunc{
+			defaultHook: i.SupplyFromModule,
 		},
-		WithdrawFunc: &LeverageKeeperWithdrawFunc{
-			defaultHook: i.Withdraw,
+		WithdrawToModuleFunc: &LeverageKeeperWithdrawToModuleFunc{
+			defaultHook: i.WithdrawToModule,
 		},
 	}
 }
@@ -1364,35 +1364,36 @@ func (c LeverageKeeperModuleMaxWithdrawFuncCall) Results() []interface{} {
 	return []interface{}{c.Result0, c.Result1}
 }
 
-// LeverageKeeperSupplyFunc describes the behavior when the Supply method of
-// the parent MockLeverageKeeper instance is invoked.
-type LeverageKeeperSupplyFunc struct {
-	defaultHook func(types.Context, types.AccAddress, types.Coin) (types.Coin, error)
-	hooks       []func(types.Context, types.AccAddress, types.Coin) (types.Coin, error)
-	history     []LeverageKeeperSupplyFuncCall
+// LeverageKeeperSupplyFromModuleFunc describes the behavior when the
+// SupplyFromModule method of the parent MockLeverageKeeper instance is
+// invoked.
+type LeverageKeeperSupplyFromModuleFunc struct {
+	defaultHook func(types.Context, string, types.Coin) (types.Coin, error, bool)
+	hooks       []func(types.Context, string, types.Coin) (types.Coin, error, bool)
+	history     []LeverageKeeperSupplyFromModuleFuncCall
 	mutex       sync.Mutex
 }
 
-// Supply delegates to the next hook function in the queue and stores the
-// parameter and result values of this invocation.
-func (m *MockLeverageKeeper) Supply(v0 types.Context, v1 types.AccAddress, v2 types.Coin) (types.Coin, error) {
-	r0, r1 := m.SupplyFunc.nextHook()(v0, v1, v2)
-	m.SupplyFunc.appendCall(LeverageKeeperSupplyFuncCall{v0, v1, v2, r0, r1})
-	return r0, r1
+// SupplyFromModule delegates to the next hook function in the queue and
+// stores the parameter and result values of this invocation.
+func (m *MockLeverageKeeper) SupplyFromModule(v0 types.Context, v1 string, v2 types.Coin) (types.Coin, error, bool) {
+	r0, r1, r2 := m.SupplyFromModuleFunc.nextHook()(v0, v1, v2)
+	m.SupplyFromModuleFunc.appendCall(LeverageKeeperSupplyFromModuleFuncCall{v0, v1, v2, r0, r1, r2})
+	return r0, r1, r2
 }
 
-// SetDefaultHook sets function that is called when the Supply method of the
-// parent MockLeverageKeeper instance is invoked and the hook queue is
-// empty.
-func (f *LeverageKeeperSupplyFunc) SetDefaultHook(hook func(types.Context, types.AccAddress, types.Coin) (types.Coin, error)) {
+// SetDefaultHook sets function that is called when the SupplyFromModule
+// method of the parent MockLeverageKeeper instance is invoked and the hook
+// queue is empty.
+func (f *LeverageKeeperSupplyFromModuleFunc) SetDefaultHook(hook func(types.Context, string, types.Coin) (types.Coin, error, bool)) {
 	f.defaultHook = hook
 }
 
 // PushHook adds a function to the end of hook queue. Each invocation of the
-// Supply method of the parent MockLeverageKeeper instance invokes the hook
-// at the front of the queue and discards it. After the queue is empty, the
-// default hook function is invoked for any future action.
-func (f *LeverageKeeperSupplyFunc) PushHook(hook func(types.Context, types.AccAddress, types.Coin) (types.Coin, error)) {
+// SupplyFromModule method of the parent MockLeverageKeeper instance invokes
+// the hook at the front of the queue and discards it. After the queue is
+// empty, the default hook function is invoked for any future action.
+func (f *LeverageKeeperSupplyFromModuleFunc) PushHook(hook func(types.Context, string, types.Coin) (types.Coin, error, bool)) {
 	f.mutex.Lock()
 	f.hooks = append(f.hooks, hook)
 	f.mutex.Unlock()
@@ -1400,20 +1401,20 @@ func (f *LeverageKeeperSupplyFunc) PushHook(hook func(types.Context, types.AccAd
 
 // SetDefaultReturn calls SetDefaultHook with a function that returns the
 // given values.
-func (f *LeverageKeeperSupplyFunc) SetDefaultReturn(r0 types.Coin, r1 error) {
-	f.SetDefaultHook(func(types.Context, types.AccAddress, types.Coin) (types.Coin, error) {
-		return r0, r1
+func (f *LeverageKeeperSupplyFromModuleFunc) SetDefaultReturn(r0 types.Coin, r1 error, r2 bool) {
+	f.SetDefaultHook(func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+		return r0, r1, r2
 	})
 }
 
 // PushReturn calls PushHook with a function that returns the given values.
-func (f *LeverageKeeperSupplyFunc) PushReturn(r0 types.Coin, r1 error) {
-	f.PushHook(func(types.Context, types.AccAddress, types.Coin) (types.Coin, error) {
-		return r0, r1
+func (f *LeverageKeeperSupplyFromModuleFunc) PushReturn(r0 types.Coin, r1 error, r2 bool) {
+	f.PushHook(func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+		return r0, r1, r2
 	})
 }
 
-func (f *LeverageKeeperSupplyFunc) nextHook() func(types.Context, types.AccAddress, types.Coin) (types.Coin, error) {
+func (f *LeverageKeeperSupplyFromModuleFunc) nextHook() func(types.Context, string, types.Coin) (types.Coin, error, bool) {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
 
@@ -1426,32 +1427,33 @@ func (f *LeverageKeeperSupplyFunc) nextHook() func(types.Context, types.AccAddre
 	return hook
 }
 
-func (f *LeverageKeeperSupplyFunc) appendCall(r0 LeverageKeeperSupplyFuncCall) {
+func (f *LeverageKeeperSupplyFromModuleFunc) appendCall(r0 LeverageKeeperSupplyFromModuleFuncCall) {
 	f.mutex.Lock()
 	f.history = append(f.history, r0)
 	f.mutex.Unlock()
 }
 
-// History returns a sequence of LeverageKeeperSupplyFuncCall objects
-// describing the invocations of this function.
-func (f *LeverageKeeperSupplyFunc) History() []LeverageKeeperSupplyFuncCall {
+// History returns a sequence of LeverageKeeperSupplyFromModuleFuncCall
+// objects describing the invocations of this function.
+func (f *LeverageKeeperSupplyFromModuleFunc) History() []LeverageKeeperSupplyFromModuleFuncCall {
 	f.mutex.Lock()
-	history := make([]LeverageKeeperSupplyFuncCall, len(f.history))
+	history := make([]LeverageKeeperSupplyFromModuleFuncCall, len(f.history))
 	copy(history, f.history)
 	f.mutex.Unlock()
 
 	return history
 }
 
-// LeverageKeeperSupplyFuncCall is an object that describes an invocation of
-// method Supply on an instance of MockLeverageKeeper.
-type LeverageKeeperSupplyFuncCall struct {
+// LeverageKeeperSupplyFromModuleFuncCall is an object that describes an
+// invocation of method SupplyFromModule on an instance of
+// MockLeverageKeeper.
+type LeverageKeeperSupplyFromModuleFuncCall struct {
 	// Arg0 is the value of the 1st argument passed to this method
 	// invocation.
 	Arg0 types.Context
 	// Arg1 is the value of the 2nd argument passed to this method
 	// invocation.
-	Arg1 types.AccAddress
+	Arg1 string
 	// Arg2 is the value of the 3rd argument passed to this method
 	// invocation.
 	Arg2 types.Coin
@@ -1461,49 +1463,53 @@ type LeverageKeeperSupplyFuncCall struct {
 	// Result1 is the value of the 2nd result returned from this method
 	// invocation.
 	Result1 error
+	// Result2 is the value of the 3rd result returned from this method
+	// invocation.
+	Result2 bool
 }
 
 // Args returns an interface slice containing the arguments of this
 // invocation.
-func (c LeverageKeeperSupplyFuncCall) Args() []interface{} {
+func (c LeverageKeeperSupplyFromModuleFuncCall) Args() []interface{} {
 	return []interface{}{c.Arg0, c.Arg1, c.Arg2}
 }
 
 // Results returns an interface slice containing the results of this
 // invocation.
-func (c LeverageKeeperSupplyFuncCall) Results() []interface{} {
-	return []interface{}{c.Result0, c.Result1}
+func (c LeverageKeeperSupplyFromModuleFuncCall) Results() []interface{} {
+	return []interface{}{c.Result0, c.Result1, c.Result2}
 }
 
-// LeverageKeeperWithdrawFunc describes the behavior when the Withdraw
-// method of the parent MockLeverageKeeper instance is invoked.
-type LeverageKeeperWithdrawFunc struct {
-	defaultHook func(types.Context, types.AccAddress, types.Coin) (types.Coin, bool, error)
-	hooks       []func(types.Context, types.AccAddress, types.Coin) (types.Coin, bool, error)
-	history     []LeverageKeeperWithdrawFuncCall
+// LeverageKeeperWithdrawToModuleFunc describes the behavior when the
+// WithdrawToModule method of the parent MockLeverageKeeper instance is
+// invoked.
+type LeverageKeeperWithdrawToModuleFunc struct {
+	defaultHook func(types.Context, string, types.Coin) (types.Coin, error, bool)
+	hooks       []func(types.Context, string, types.Coin) (types.Coin, error, bool)
+	history     []LeverageKeeperWithdrawToModuleFuncCall
 	mutex       sync.Mutex
 }
 
-// Withdraw delegates to the next hook function in the queue and stores the
-// parameter and result values of this invocation.
-func (m *MockLeverageKeeper) Withdraw(v0 types.Context, v1 types.AccAddress, v2 types.Coin) (types.Coin, bool, error) {
-	r0, r1, r2 := m.WithdrawFunc.nextHook()(v0, v1, v2)
-	m.WithdrawFunc.appendCall(LeverageKeeperWithdrawFuncCall{v0, v1, v2, r0, r1, r2})
+// WithdrawToModule delegates to the next hook function in the queue and
+// stores the parameter and result values of this invocation.
+func (m *MockLeverageKeeper) WithdrawToModule(v0 types.Context, v1 string, v2 types.Coin) (types.Coin, error, bool) {
+	r0, r1, r2 := m.WithdrawToModuleFunc.nextHook()(v0, v1, v2)
+	m.WithdrawToModuleFunc.appendCall(LeverageKeeperWithdrawToModuleFuncCall{v0, v1, v2, r0, r1, r2})
 	return r0, r1, r2
 }
 
-// SetDefaultHook sets function that is called when the Withdraw method of
-// the parent MockLeverageKeeper instance is invoked and the hook queue is
-// empty.
-func (f *LeverageKeeperWithdrawFunc) SetDefaultHook(hook func(types.Context, types.AccAddress, types.Coin) (types.Coin, bool, error)) {
+// SetDefaultHook sets function that is called when the WithdrawToModule
+// method of the parent MockLeverageKeeper instance is invoked and the hook
+// queue is empty.
+func (f *LeverageKeeperWithdrawToModuleFunc) SetDefaultHook(hook func(types.Context, string, types.Coin) (types.Coin, error, bool)) {
 	f.defaultHook = hook
 }
 
 // PushHook adds a function to the end of hook queue. Each invocation of the
-// Withdraw method of the parent MockLeverageKeeper instance invokes the
-// hook at the front of the queue and discards it. After the queue is empty,
-// the default hook function is invoked for any future action.
-func (f *LeverageKeeperWithdrawFunc) PushHook(hook func(types.Context, types.AccAddress, types.Coin) (types.Coin, bool, error)) {
+// WithdrawToModule method of the parent MockLeverageKeeper instance invokes
+// the hook at the front of the queue and discards it. After the queue is
+// empty, the default hook function is invoked for any future action.
+func (f *LeverageKeeperWithdrawToModuleFunc) PushHook(hook func(types.Context, string, types.Coin) (types.Coin, error, bool)) {
 	f.mutex.Lock()
 	f.hooks = append(f.hooks, hook)
 	f.mutex.Unlock()
@@ -1511,20 +1517,20 @@ func (f *LeverageKeeperWithdrawFunc) PushHook(hook func(types.Context, types.Acc
 
 // SetDefaultReturn calls SetDefaultHook with a function that returns the
 // given values.
-func (f *LeverageKeeperWithdrawFunc) SetDefaultReturn(r0 types.Coin, r1 bool, r2 error) {
-	f.SetDefaultHook(func(types.Context, types.AccAddress, types.Coin) (types.Coin, bool, error) {
+func (f *LeverageKeeperWithdrawToModuleFunc) SetDefaultReturn(r0 types.Coin, r1 error, r2 bool) {
+	f.SetDefaultHook(func(types.Context, string, types.Coin) (types.Coin, error, bool) {
 		return r0, r1, r2
 	})
 }
 
 // PushReturn calls PushHook with a function that returns the given values.
-func (f *LeverageKeeperWithdrawFunc) PushReturn(r0 types.Coin, r1 bool, r2 error) {
-	f.PushHook(func(types.Context, types.AccAddress, types.Coin) (types.Coin, bool, error) {
+func (f *LeverageKeeperWithdrawToModuleFunc) PushReturn(r0 types.Coin, r1 error, r2 bool) {
+	f.PushHook(func(types.Context, string, types.Coin) (types.Coin, error, bool) {
 		return r0, r1, r2
 	})
 }
 
-func (f *LeverageKeeperWithdrawFunc) nextHook() func(types.Context, types.AccAddress, types.Coin) (types.Coin, bool, error) {
+func (f *LeverageKeeperWithdrawToModuleFunc) nextHook() func(types.Context, string, types.Coin) (types.Coin, error, bool) {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
 
@@ -1537,32 +1543,33 @@ func (f *LeverageKeeperWithdrawFunc) nextHook() func(types.Context, types.AccAdd
 	return hook
 }
 
-func (f *LeverageKeeperWithdrawFunc) appendCall(r0 LeverageKeeperWithdrawFuncCall) {
+func (f *LeverageKeeperWithdrawToModuleFunc) appendCall(r0 LeverageKeeperWithdrawToModuleFuncCall) {
 	f.mutex.Lock()
 	f.history = append(f.history, r0)
 	f.mutex.Unlock()
 }
 
-// History returns a sequence of LeverageKeeperWithdrawFuncCall objects
-// describing the invocations of this function.
-func (f *LeverageKeeperWithdrawFunc) History() []LeverageKeeperWithdrawFuncCall {
+// History returns a sequence of LeverageKeeperWithdrawToModuleFuncCall
+// objects describing the invocations of this function.
+func (f *LeverageKeeperWithdrawToModuleFunc) History() []LeverageKeeperWithdrawToModuleFuncCall {
 	f.mutex.Lock()
-	history := make([]LeverageKeeperWithdrawFuncCall, len(f.history))
+	history := make([]LeverageKeeperWithdrawToModuleFuncCall, len(f.history))
 	copy(history, f.history)
 	f.mutex.Unlock()
 
 	return history
 }
 
-// LeverageKeeperWithdrawFuncCall is an object that describes an invocation
-// of method Withdraw on an instance of MockLeverageKeeper.
-type LeverageKeeperWithdrawFuncCall struct {
+// LeverageKeeperWithdrawToModuleFuncCall is an object that describes an
+// invocation of method WithdrawToModule on an instance of
+// MockLeverageKeeper.
+type LeverageKeeperWithdrawToModuleFuncCall struct {
 	// Arg0 is the value of the 1st argument passed to this method
 	// invocation.
 	Arg0 types.Context
 	// Arg1 is the value of the 2nd argument passed to this method
 	// invocation.
-	Arg1 types.AccAddress
+	Arg1 string
 	// Arg2 is the value of the 3rd argument passed to this method
 	// invocation.
 	Arg2 types.Coin
@@ -1571,21 +1578,21 @@ type LeverageKeeperWithdrawFuncCall struct {
 	Result0 types.Coin
 	// Result1 is the value of the 2nd result returned from this method
 	// invocation.
-	Result1 bool
+	Result1 error
 	// Result2 is the value of the 3rd result returned from this method
 	// invocation.
-	Result2 error
+	Result2 bool
 }
 
 // Args returns an interface slice containing the arguments of this
 // invocation.
-func (c LeverageKeeperWithdrawFuncCall) Args() []interface{} {
+func (c LeverageKeeperWithdrawToModuleFuncCall) Args() []interface{} {
 	return []interface{}{c.Arg0, c.Arg1, c.Arg2}
 }
 
 // Results returns an interface slice containing the results of this
 // invocation.
-func (c LeverageKeeperWithdrawFuncCall) Results() []interface{} {
+func (c LeverageKeeperWithdrawToModuleFuncCall) Results() []interface{} {
 	return []interface{}{c.Result0, c.Result1, c.Result2}
 }
 

From a11a1562addc806ff7846a848555bd42ac2432be Mon Sep 17 00:00:00 2001
From: Egor Kostetskiy <kosegor@gmail.com>
Date: Thu, 27 Jul 2023 10:39:41 -0300
Subject: [PATCH 6/6] mocks

---
 x/metoken/mocks/keepers.go | 56 +++++++++++++++++++-------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/x/metoken/mocks/keepers.go b/x/metoken/mocks/keepers.go
index bdb38ee925..8db05124a0 100644
--- a/x/metoken/mocks/keepers.go
+++ b/x/metoken/mocks/keepers.go
@@ -616,12 +616,12 @@ func NewMockLeverageKeeper() *MockLeverageKeeper {
 			},
 		},
 		SupplyFromModuleFunc: &LeverageKeeperSupplyFromModuleFunc{
-			defaultHook: func(types.Context, string, types.Coin) (r0 types.Coin, r1 error, r2 bool) {
+			defaultHook: func(types.Context, string, types.Coin) (r0 types.Coin, r1 bool, r2 error) {
 				return
 			},
 		},
 		WithdrawToModuleFunc: &LeverageKeeperWithdrawToModuleFunc{
-			defaultHook: func(types.Context, string, types.Coin) (r0 types.Coin, r1 error, r2 bool) {
+			defaultHook: func(types.Context, string, types.Coin) (r0 types.Coin, r1 bool, r2 error) {
 				return
 			},
 		},
@@ -663,12 +663,12 @@ func NewStrictMockLeverageKeeper() *MockLeverageKeeper {
 			},
 		},
 		SupplyFromModuleFunc: &LeverageKeeperSupplyFromModuleFunc{
-			defaultHook: func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+			defaultHook: func(types.Context, string, types.Coin) (types.Coin, bool, error) {
 				panic("unexpected invocation of MockLeverageKeeper.SupplyFromModule")
 			},
 		},
 		WithdrawToModuleFunc: &LeverageKeeperWithdrawToModuleFunc{
-			defaultHook: func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+			defaultHook: func(types.Context, string, types.Coin) (types.Coin, bool, error) {
 				panic("unexpected invocation of MockLeverageKeeper.WithdrawToModule")
 			},
 		},
@@ -1368,15 +1368,15 @@ func (c LeverageKeeperModuleMaxWithdrawFuncCall) Results() []interface{} {
 // SupplyFromModule method of the parent MockLeverageKeeper instance is
 // invoked.
 type LeverageKeeperSupplyFromModuleFunc struct {
-	defaultHook func(types.Context, string, types.Coin) (types.Coin, error, bool)
-	hooks       []func(types.Context, string, types.Coin) (types.Coin, error, bool)
+	defaultHook func(types.Context, string, types.Coin) (types.Coin, bool, error)
+	hooks       []func(types.Context, string, types.Coin) (types.Coin, bool, error)
 	history     []LeverageKeeperSupplyFromModuleFuncCall
 	mutex       sync.Mutex
 }
 
 // SupplyFromModule delegates to the next hook function in the queue and
 // stores the parameter and result values of this invocation.
-func (m *MockLeverageKeeper) SupplyFromModule(v0 types.Context, v1 string, v2 types.Coin) (types.Coin, error, bool) {
+func (m *MockLeverageKeeper) SupplyFromModule(v0 types.Context, v1 string, v2 types.Coin) (types.Coin, bool, error) {
 	r0, r1, r2 := m.SupplyFromModuleFunc.nextHook()(v0, v1, v2)
 	m.SupplyFromModuleFunc.appendCall(LeverageKeeperSupplyFromModuleFuncCall{v0, v1, v2, r0, r1, r2})
 	return r0, r1, r2
@@ -1385,7 +1385,7 @@ func (m *MockLeverageKeeper) SupplyFromModule(v0 types.Context, v1 string, v2 ty
 // SetDefaultHook sets function that is called when the SupplyFromModule
 // method of the parent MockLeverageKeeper instance is invoked and the hook
 // queue is empty.
-func (f *LeverageKeeperSupplyFromModuleFunc) SetDefaultHook(hook func(types.Context, string, types.Coin) (types.Coin, error, bool)) {
+func (f *LeverageKeeperSupplyFromModuleFunc) SetDefaultHook(hook func(types.Context, string, types.Coin) (types.Coin, bool, error)) {
 	f.defaultHook = hook
 }
 
@@ -1393,7 +1393,7 @@ func (f *LeverageKeeperSupplyFromModuleFunc) SetDefaultHook(hook func(types.Cont
 // SupplyFromModule method of the parent MockLeverageKeeper instance invokes
 // the hook at the front of the queue and discards it. After the queue is
 // empty, the default hook function is invoked for any future action.
-func (f *LeverageKeeperSupplyFromModuleFunc) PushHook(hook func(types.Context, string, types.Coin) (types.Coin, error, bool)) {
+func (f *LeverageKeeperSupplyFromModuleFunc) PushHook(hook func(types.Context, string, types.Coin) (types.Coin, bool, error)) {
 	f.mutex.Lock()
 	f.hooks = append(f.hooks, hook)
 	f.mutex.Unlock()
@@ -1401,20 +1401,20 @@ func (f *LeverageKeeperSupplyFromModuleFunc) PushHook(hook func(types.Context, s
 
 // SetDefaultReturn calls SetDefaultHook with a function that returns the
 // given values.
-func (f *LeverageKeeperSupplyFromModuleFunc) SetDefaultReturn(r0 types.Coin, r1 error, r2 bool) {
-	f.SetDefaultHook(func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+func (f *LeverageKeeperSupplyFromModuleFunc) SetDefaultReturn(r0 types.Coin, r1 bool, r2 error) {
+	f.SetDefaultHook(func(types.Context, string, types.Coin) (types.Coin, bool, error) {
 		return r0, r1, r2
 	})
 }
 
 // PushReturn calls PushHook with a function that returns the given values.
-func (f *LeverageKeeperSupplyFromModuleFunc) PushReturn(r0 types.Coin, r1 error, r2 bool) {
-	f.PushHook(func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+func (f *LeverageKeeperSupplyFromModuleFunc) PushReturn(r0 types.Coin, r1 bool, r2 error) {
+	f.PushHook(func(types.Context, string, types.Coin) (types.Coin, bool, error) {
 		return r0, r1, r2
 	})
 }
 
-func (f *LeverageKeeperSupplyFromModuleFunc) nextHook() func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+func (f *LeverageKeeperSupplyFromModuleFunc) nextHook() func(types.Context, string, types.Coin) (types.Coin, bool, error) {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
 
@@ -1462,10 +1462,10 @@ type LeverageKeeperSupplyFromModuleFuncCall struct {
 	Result0 types.Coin
 	// Result1 is the value of the 2nd result returned from this method
 	// invocation.
-	Result1 error
+	Result1 bool
 	// Result2 is the value of the 3rd result returned from this method
 	// invocation.
-	Result2 bool
+	Result2 error
 }
 
 // Args returns an interface slice containing the arguments of this
@@ -1484,15 +1484,15 @@ func (c LeverageKeeperSupplyFromModuleFuncCall) Results() []interface{} {
 // WithdrawToModule method of the parent MockLeverageKeeper instance is
 // invoked.
 type LeverageKeeperWithdrawToModuleFunc struct {
-	defaultHook func(types.Context, string, types.Coin) (types.Coin, error, bool)
-	hooks       []func(types.Context, string, types.Coin) (types.Coin, error, bool)
+	defaultHook func(types.Context, string, types.Coin) (types.Coin, bool, error)
+	hooks       []func(types.Context, string, types.Coin) (types.Coin, bool, error)
 	history     []LeverageKeeperWithdrawToModuleFuncCall
 	mutex       sync.Mutex
 }
 
 // WithdrawToModule delegates to the next hook function in the queue and
 // stores the parameter and result values of this invocation.
-func (m *MockLeverageKeeper) WithdrawToModule(v0 types.Context, v1 string, v2 types.Coin) (types.Coin, error, bool) {
+func (m *MockLeverageKeeper) WithdrawToModule(v0 types.Context, v1 string, v2 types.Coin) (types.Coin, bool, error) {
 	r0, r1, r2 := m.WithdrawToModuleFunc.nextHook()(v0, v1, v2)
 	m.WithdrawToModuleFunc.appendCall(LeverageKeeperWithdrawToModuleFuncCall{v0, v1, v2, r0, r1, r2})
 	return r0, r1, r2
@@ -1501,7 +1501,7 @@ func (m *MockLeverageKeeper) WithdrawToModule(v0 types.Context, v1 string, v2 ty
 // SetDefaultHook sets function that is called when the WithdrawToModule
 // method of the parent MockLeverageKeeper instance is invoked and the hook
 // queue is empty.
-func (f *LeverageKeeperWithdrawToModuleFunc) SetDefaultHook(hook func(types.Context, string, types.Coin) (types.Coin, error, bool)) {
+func (f *LeverageKeeperWithdrawToModuleFunc) SetDefaultHook(hook func(types.Context, string, types.Coin) (types.Coin, bool, error)) {
 	f.defaultHook = hook
 }
 
@@ -1509,7 +1509,7 @@ func (f *LeverageKeeperWithdrawToModuleFunc) SetDefaultHook(hook func(types.Cont
 // WithdrawToModule method of the parent MockLeverageKeeper instance invokes
 // the hook at the front of the queue and discards it. After the queue is
 // empty, the default hook function is invoked for any future action.
-func (f *LeverageKeeperWithdrawToModuleFunc) PushHook(hook func(types.Context, string, types.Coin) (types.Coin, error, bool)) {
+func (f *LeverageKeeperWithdrawToModuleFunc) PushHook(hook func(types.Context, string, types.Coin) (types.Coin, bool, error)) {
 	f.mutex.Lock()
 	f.hooks = append(f.hooks, hook)
 	f.mutex.Unlock()
@@ -1517,20 +1517,20 @@ func (f *LeverageKeeperWithdrawToModuleFunc) PushHook(hook func(types.Context, s
 
 // SetDefaultReturn calls SetDefaultHook with a function that returns the
 // given values.
-func (f *LeverageKeeperWithdrawToModuleFunc) SetDefaultReturn(r0 types.Coin, r1 error, r2 bool) {
-	f.SetDefaultHook(func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+func (f *LeverageKeeperWithdrawToModuleFunc) SetDefaultReturn(r0 types.Coin, r1 bool, r2 error) {
+	f.SetDefaultHook(func(types.Context, string, types.Coin) (types.Coin, bool, error) {
 		return r0, r1, r2
 	})
 }
 
 // PushReturn calls PushHook with a function that returns the given values.
-func (f *LeverageKeeperWithdrawToModuleFunc) PushReturn(r0 types.Coin, r1 error, r2 bool) {
-	f.PushHook(func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+func (f *LeverageKeeperWithdrawToModuleFunc) PushReturn(r0 types.Coin, r1 bool, r2 error) {
+	f.PushHook(func(types.Context, string, types.Coin) (types.Coin, bool, error) {
 		return r0, r1, r2
 	})
 }
 
-func (f *LeverageKeeperWithdrawToModuleFunc) nextHook() func(types.Context, string, types.Coin) (types.Coin, error, bool) {
+func (f *LeverageKeeperWithdrawToModuleFunc) nextHook() func(types.Context, string, types.Coin) (types.Coin, bool, error) {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
 
@@ -1578,10 +1578,10 @@ type LeverageKeeperWithdrawToModuleFuncCall struct {
 	Result0 types.Coin
 	// Result1 is the value of the 2nd result returned from this method
 	// invocation.
-	Result1 error
+	Result1 bool
 	// Result2 is the value of the 3rd result returned from this method
 	// invocation.
-	Result2 bool
+	Result2 error
 }
 
 // Args returns an interface slice containing the arguments of this