diff --git a/CHANGELOG.md b/CHANGELOG.md index 0182d32852..b4602b61e7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -61,6 +61,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ - [1140](https://github.com/umee-network/umee/pull/1140) Rename MarketSize query to TotalSuppliedValue, and TokenMarketSize to TotalSupplied. - [1188](https://github.com/umee-network/umee/pull/1188) Remove all individual queries which duplicate market_summary fields. - [1199](https://github.com/umee-network/umee/pull/1199) Move all queries which require address input (e.g. `supplied`, `collateral_value`, `borrow_limit`) into aggregate queries `acccount_summary` or `account_balances`. +- [1236](https://github.com/umee-network/umee/pull/1236) Add more response fields to leverage messages. - [1222](https://github.com/umee-network/umee/pull/1222) Add leverage parameter DirectLiquidationFee. ### Features @@ -86,21 +87,19 @@ Ref: https://keepachangelog.com/en/1.0.0/ ### Improvements - [935](https://github.com/umee-network/umee/pull/935) Fix protobuf linting +- [940](https://github.com/umee-network/umee/pull/940)(x/leverage) Renamed `Keeper.DeriveBorrowUtilization` to `SupplyUtilization` (see #926) - [959](https://github.com/umee-network/umee/pull/959) Improve ModuleBalance calculation - [962](https://github.com/umee-network/umee/pull/962) Streamline AccrueAllInterest - [967](https://github.com/umee-network/umee/pull/962) Use taylor series of e^x for more accurate interest at high APY. - [987](https://github.com/umee-network/umee/pull/987) Streamline x/leverage CLI tests - [1012](https://github.com/umee-network/umee/pull/1012) Improve negative time elapsed error message +- [1236](https://github.com/umee-network/umee/pull/1236) Improve leverage event fields. ### Bug Fixes - [1018](https://github.com/umee-network/umee/pull/1018) Return nil if negative time elapsed from the last block happens. - [1156](https://github.com/umee-network/umee/pull/1156) Propagate context correctly. -### API Breaking - -- [926](https://github.com/umee-network/umee/pull/926)(x/leverage) Renamed `Keeper.DeriveBorrowUtilization` to `SupplyUtilization`. - ## [v2.0.2](https://github.com/umee-network/umee/releases/tag/v2.0.2) - 2022-05-13 ### Features diff --git a/Makefile b/Makefile index 07d2ff1ce0..74e1e10300 100644 --- a/Makefile +++ b/Makefile @@ -200,8 +200,8 @@ containerProtoGen=$(PROJECT_NAME)-proto-gen-$(containerProtoVer) containerProtoFmt=$(PROJECT_NAME)-proto-fmt-$(containerProtoVer) containerProtoGenSwagger=$(PROJECT_NAME)-proto-gen-swagger-$(containerProtoVer) -proto-all: proto-gen proto-lint proto-check-breaking proto-format -.PHONY: proto-all proto-gen proto-lint proto-check-breaking proto-format +proto-all: proto-format proto-lint proto-gen proto-swagger-gen +.PHONY: proto-all proto-gen proto-lint proto-check-breaking proto-format proto-swagger-gen proto-gen: @echo "Generating Protobuf files" diff --git a/proto/umee/leverage/v1/tx.proto b/proto/umee/leverage/v1/tx.proto index 7cea5ea869..0fb9e6372d 100644 --- a/proto/umee/leverage/v1/tx.proto +++ b/proto/umee/leverage/v1/tx.proto @@ -36,7 +36,7 @@ service Msg { rpc Liquidate(MsgLiquidate) returns (MsgLiquidateResponse); } -// MsgSupply is the request structure for the Supply RPC. +// MsgSupply represents a user's request to supply assets to the module. message MsgSupply { // Supplier is the account address supplying assets and the signer of the message. string supplier = 1; @@ -56,7 +56,7 @@ message MsgWithdraw { message MsgCollateralize { // Borrower is the account address adding collateral and the signer of the message. string borrower = 1; - cosmos.base.v1beta1.Coin coin = 2 [(gogoproto.nullable) = false]; + cosmos.base.v1beta1.Coin asset = 2 [(gogoproto.nullable) = false]; } // MsgDecollateralize represents a user's request to disable selected @@ -64,7 +64,7 @@ message MsgCollateralize { message MsgDecollateralize { // Borrower is the account address removing collateral and the signer of the message. string borrower = 1; - cosmos.base.v1beta1.Coin coin = 2 [(gogoproto.nullable) = false]; + cosmos.base.v1beta1.Coin asset = 2 [(gogoproto.nullable) = false]; } // MsgBorrow represents a user's request to borrow a base asset type @@ -104,10 +104,16 @@ message MsgLiquidate { } // MsgSupplyResponse defines the Msg/Supply response type. -message MsgSupplyResponse {} +message MsgSupplyResponse { + // Received is the amount of uTokens received. + cosmos.base.v1beta1.Coin received = 1 [(gogoproto.nullable) = false]; +} // MsgWithdrawResponse defines the Msg/Withdraw response type. -message MsgWithdrawResponse {} +message MsgWithdrawResponse { + // Received is the amount of base tokens received. + cosmos.base.v1beta1.Coin received = 1 [(gogoproto.nullable) = false]; +} // MsgCollateralizeResponse defines the Msg/Collateralize response type. message MsgCollateralizeResponse {} @@ -120,18 +126,17 @@ message MsgBorrowResponse {} // MsgRepayResponse defines the Msg/Repay response type. message MsgRepayResponse { - // Repaid is the amount of debt, in base tokens, that was repaid to the - // module by the borrower. + // Repaid is the amount of base tokens repaid to the module. cosmos.base.v1beta1.Coin repaid = 1 [(gogoproto.nullable) = false]; } // MsgLiquidateResponse defines the Msg/Liquidate response type. message MsgLiquidateResponse { - // Repaid is the amount of debt, in base tokens, that liquidator repaid + // Repaid is the amount of borrowed base tokens that the liquidator repaid // to the module on behalf of the borrower. cosmos.base.v1beta1.Coin repaid = 1 [(gogoproto.nullable) = false]; // Collateral is the amount of the borrower's uToken collateral that - // was converted to the reward tokens as a result of liquidation. + // was liquidated. cosmos.base.v1beta1.Coin collateral = 2 [(gogoproto.nullable) = false]; // Reward is the amount of base tokens that the liquidator received from // the module as reward for the liquidation. diff --git a/x/leverage/keeper/keeper.go b/x/leverage/keeper/keeper.go index 3ca72dac81..b3645e2e85 100644 --- a/x/leverage/keeper/keeper.go +++ b/x/leverage/keeper/keeper.go @@ -75,64 +75,65 @@ func (k Keeper) ModuleBalance(ctx sdk.Context, denom string) sdk.Int { // 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. -func (k Keeper) Supply(ctx sdk.Context, supplierAddr sdk.AccAddress, loan sdk.Coin) error { - if err := k.validateSupply(ctx, loan); err != nil { - return err +// 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) { + if err := k.validateSupply(ctx, coin); err != nil { + return sdk.Coin{}, err } // determine uToken amount to mint - uToken, err := k.ExchangeToken(ctx, loan) + uToken, err := k.ExchangeToken(ctx, coin) if err != nil { - return err + return sdk.Coin{}, err } // send token balance to leverage module account - loanTokens := sdk.NewCoins(loan) - if err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, supplierAddr, types.ModuleName, loanTokens); err != nil { - return err + err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, supplierAddr, types.ModuleName, sdk.NewCoins(coin)) + if err != nil { + 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 err + return sdk.Coin{}, err } if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Add(uToken)); err != nil { - return err + return sdk.Coin{}, err } // The uTokens are sent to supplier address if err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, uTokens); err != nil { - return err + return sdk.Coin{}, err } - return nil + return uToken, nil } // Withdraw attempts to deposit uTokens into the leverage module in exchange for base tokens. // If there are not enough uTokens in balance, Withdraw will attempt to withdraw uToken collateral // to make up the difference (as long as borrow limit allows). If the uToken denom is invalid or // balances are insufficient to withdraw the full amount requested, returns an error. -func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sdk.Coin) error { +// Returns the amount of base tokens received. +func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sdk.Coin) (sdk.Coin, error) { if err := uToken.Validate(); err != nil { - return err + return sdk.Coin{}, err } if !types.HasUTokenPrefix(uToken.Denom) { - return types.ErrNotUToken.Wrap(uToken.Denom) + return sdk.Coin{}, types.ErrNotUToken.Wrap(uToken.Denom) } // calculate base asset amount to withdraw token, err := k.ExchangeUToken(ctx, uToken) if err != nil { - return err + return sdk.Coin{}, err } // Ensure module account has sufficient unreserved tokens to withdraw reservedAmount := k.GetReserveAmount(ctx, token.Denom) availableAmount := k.ModuleBalance(ctx, token.Denom) if token.Amount.GT(availableAmount.Sub(reservedAmount)) { - return sdkerrors.Wrap(types.ErrLendingPoolInsufficient, token.String()) + return sdk.Coin{}, sdkerrors.Wrap(types.ErrLendingPoolInsufficient, token.String()) } // Withdraw will first attempt to use any uTokens in the supplier's wallet @@ -145,59 +146,58 @@ func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sd borrowed := k.GetBorrowerBorrows(ctx, supplierAddr) borrowedValue, err := k.TotalTokenValue(ctx, borrowed) if err != nil { - return err + return sdk.Coin{}, err } // Check for sufficient collateral collateral := k.GetBorrowerCollateral(ctx, supplierAddr) if collateral.AmountOf(uToken.Denom).LT(amountFromCollateral) { - return types.ErrInsufficientBalance.Wrapf("%s uToken balance + %s from collateral is less than %s to withdraw", - amountFromWallet.String(), - collateral.AmountOf(uToken.Denom).String(), - uToken.String()) + return sdk.Coin{}, types.ErrInsufficientBalance.Wrapf( + "%s uToken balance + %s from collateral is less than %s to withdraw", + amountFromWallet, collateral.AmountOf(uToken.Denom), uToken) } // Calculate what borrow limit will be AFTER this withdrawal collateralToWithdraw := sdk.NewCoins(sdk.NewCoin(uToken.Denom, amountFromCollateral)) newBorrowLimit, err := k.CalculateBorrowLimit(ctx, collateral.Sub(collateralToWithdraw)) if err != nil { - return err + return sdk.Coin{}, err } // Return error if borrow limit would drop below borrowed value if borrowedValue.GT(newBorrowLimit) { - return types.ErrUndercollaterized.Wrapf( + return sdk.Coin{}, types.ErrUndercollaterized.Wrapf( "withdraw would decrease borrow limit to %s, below the current borrowed value %s", newBorrowLimit, borrowedValue) } // reduce the supplier's collateral by amountFromCollateral newCollateral := sdk.NewCoin(uToken.Denom, collateral.AmountOf(uToken.Denom).Sub(amountFromCollateral)) if err = k.setCollateralAmount(ctx, supplierAddr, newCollateral); err != nil { - return err + return sdk.Coin{}, err } } // transfer amountFromWallet uTokens to the module account uTokens := sdk.NewCoins(sdk.NewCoin(uToken.Denom, amountFromWallet)) if err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, supplierAddr, types.ModuleName, uTokens); err != nil { - return err + return sdk.Coin{}, err } // send the base assets to supplier tokens := sdk.NewCoins(token) if err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, tokens); err != nil { - return err + return sdk.Coin{}, 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 err + return sdk.Coin{}, err } if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Sub(uToken)); err != nil { - return err + return sdk.Coin{}, err } - return nil + return token, nil } // Borrow attempts to borrow tokens from the leverage module account using @@ -255,15 +255,15 @@ func (k Keeper) Borrow(ctx sdk.Context, borrowerAddr sdk.AccAddress, borrow sdk. // Additionally, if the amount provided is greater than the full repayment amount, only the // necessary amount is transferred. Because amount repaid may be less than the repayment attempted, // Repay returns the actual amount repaid. -func (k Keeper) Repay(ctx sdk.Context, borrowerAddr sdk.AccAddress, payment sdk.Coin) (sdk.Int, error) { +func (k Keeper) Repay(ctx sdk.Context, borrowerAddr sdk.AccAddress, payment sdk.Coin) (sdk.Coin, error) { if err := payment.Validate(); err != nil { - return sdk.ZeroInt(), err + return sdk.Coin{}, err } // determine amount of selected denom currently owed owed := k.GetBorrow(ctx, borrowerAddr, payment.Denom) if owed.IsZero() { - return sdk.ZeroInt(), types.ErrInvalidRepayment.Wrapf("No %s borrowed ", payment.Denom) + return sdk.Coin{}, types.ErrInvalidRepayment.Wrapf("No %s borrowed ", payment.Denom) } // prevent overpaying @@ -271,9 +271,9 @@ func (k Keeper) Repay(ctx sdk.Context, borrowerAddr sdk.AccAddress, payment sdk. // send payment to leverage module account if err := k.repayBorrow(ctx, borrowerAddr, borrowerAddr, payment); err != nil { - return sdk.ZeroInt(), err + return sdk.Coin{}, err } - return payment.Amount, nil + return payment, nil } // Collateralize enables selected uTokens for use as collateral by a single borrower. diff --git a/x/leverage/keeper/keeper_test.go b/x/leverage/keeper/keeper_test.go index 9e0b3c50c3..6370536dad 100644 --- a/x/leverage/keeper/keeper_test.go +++ b/x/leverage/keeper/keeper_test.go @@ -109,8 +109,9 @@ func (s *IntegrationTestSuite) setupAccount(denom string, mintAmount, supplyAmou if supplyAmount > 0 { // account supplies supplyAmount tokens and receives uTokens - err := s.app.LeverageKeeper.Supply(s.ctx, addr, sdk.NewInt64Coin(denom, supplyAmount)) + uTokens, err := s.app.LeverageKeeper.Supply(s.ctx, addr, sdk.NewInt64Coin(denom, supplyAmount)) s.Require().NoError(err) + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(denom), supplyAmount), uTokens) } if collateral { @@ -145,8 +146,9 @@ func (s *IntegrationTestSuite) TestSupply_InvalidAsset() { s.Require().NoError(s.app.BankKeeper.SendCoinsFromModuleToAccount(s.ctx, minttypes.ModuleName, addr, invalidCoins)) // supplying should fail as we have not registered token "uabcd" - err := s.app.LeverageKeeper.Supply(s.ctx, addr, invalidCoin) + uTokens, err := s.app.LeverageKeeper.Supply(s.ctx, addr, invalidCoin) s.Require().Error(err) + s.Require().Equal(sdk.Coin{}, uTokens) } func (s *IntegrationTestSuite) TestSupply_Valid() { @@ -161,11 +163,12 @@ func (s *IntegrationTestSuite) TestSupply_Valid() { s.Require().NoError(app.BankKeeper.SendCoinsFromModuleToAccount(ctx, minttypes.ModuleName, addr, initCoins)) // supply asset - err := s.app.LeverageKeeper.Supply(ctx, addr, sdk.NewInt64Coin(umeeapp.BondDenom, 1000000000)) // 1k umee + uTokenDenom := types.ToUTokenDenom(umeeapp.BondDenom) + uToken, err := s.app.LeverageKeeper.Supply(ctx, addr, sdk.NewInt64Coin(umeeapp.BondDenom, 1000000000)) // 1k umee s.Require().NoError(err) + s.Require().Equal(sdk.NewInt64Coin(uTokenDenom, 1000000000), uToken) // 1k u/umee // verify the total supply of the minted uToken - uTokenDenom := types.ToUTokenDenom(umeeapp.BondDenom) supply := s.app.LeverageKeeper.GetUTokenSupply(ctx, uTokenDenom) expected := sdk.NewInt64Coin(uTokenDenom, 1000000000) // 1k u/umee s.Require().Equal(expected, supply) @@ -190,7 +193,7 @@ func (s *IntegrationTestSuite) TestWithdraw_Valid() { s.Require().NoError(app.BankKeeper.SendCoinsFromModuleToAccount(ctx, minttypes.ModuleName, addr, initCoins)) // supply asset - err := s.app.LeverageKeeper.Supply(ctx, addr, sdk.NewInt64Coin(umeeapp.BondDenom, 1000000000)) // 1k umee + _, err := s.app.LeverageKeeper.Supply(ctx, addr, sdk.NewInt64Coin(umeeapp.BondDenom, 1000000000)) // 1k umee s.Require().NoError(err) // verify the total supply of the minted uToken @@ -201,8 +204,9 @@ func (s *IntegrationTestSuite) TestWithdraw_Valid() { // withdraw the total amount of assets supplied uToken := expected - err = s.app.LeverageKeeper.Withdraw(ctx, addr, uToken) + withdrawn, err := s.app.LeverageKeeper.Withdraw(ctx, addr, uToken) s.Require().NoError(err) + s.Require().Equal(sdk.NewInt64Coin(umeeapp.BondDenom, 1000000000), withdrawn) // 1k umee // verify total supply of the uTokens supply = s.app.LeverageKeeper.GetUTokenSupply(ctx, uTokenDenom) @@ -277,7 +281,7 @@ func (s *IntegrationTestSuite) initBorrowScenario() (supplier, bum sdk.AccAddres // supplier supplies 1000 umee and receives 1k u/umee supplyCoin := sdk.NewInt64Coin(umeeapp.BondDenom, 1000000000) - err := s.app.LeverageKeeper.Supply(ctx, supplierAddr, supplyCoin) + _, err := s.app.LeverageKeeper.Supply(ctx, supplierAddr, supplyCoin) s.Require().NoError(err) // supplier enables u/umee as collateral @@ -305,7 +309,7 @@ func (s *IntegrationTestSuite) mintAndSupplyAtom(mintTo sdk.AccAddress, amountTo // user supplies amountToSupply atom and receives amountToSupply u/atom supplyCoin := sdk.NewInt64Coin(atomIBCDenom, amountToSupply) - err := s.app.LeverageKeeper.Supply(ctx, mintTo, supplyCoin) + _, err := s.app.LeverageKeeper.Supply(ctx, mintTo, supplyCoin) s.Require().NoError(err) // user enables u/atom as collateral @@ -419,7 +423,7 @@ func (s *IntegrationTestSuite) TestBorrow_BorrowLimit() { s.Require().Error(err) // user tries to withdraw all its u/umee, fails due to borrow limit - err = s.app.LeverageKeeper.Withdraw(s.ctx, addr, sdk.NewCoin(uDenom, collateral.Amount)) + _, err = s.app.LeverageKeeper.Withdraw(s.ctx, addr, sdk.NewCoin(uDenom, collateral.Amount)) s.Require().Error(err) } @@ -462,7 +466,7 @@ func (s *IntegrationTestSuite) TestRepay_Valid() { // user repays 8 umee repaid, err := s.app.LeverageKeeper.Repay(ctx, addr, sdk.NewInt64Coin(umeeapp.BondDenom, 8000000)) s.Require().NoError(err) - s.Require().Equal(sdk.NewInt(8000000), repaid) + s.Require().Equal(sdk.NewInt64Coin(umeeDenom, 8000000), repaid) // verify user's new loan amount (12 umee) loanBalance := s.app.LeverageKeeper.GetBorrow(ctx, addr, umeeapp.BondDenom) @@ -483,7 +487,7 @@ func (s *IntegrationTestSuite) TestRepay_Valid() { // user repays 12 umee (loan repaid in full) repaid, err = s.app.LeverageKeeper.Repay(ctx, addr, sdk.NewInt64Coin(umeeapp.BondDenom, 12000000)) s.Require().NoError(err) - s.Require().Equal(sdk.NewInt(12000000), repaid) + s.Require().Equal(sdk.NewInt64Coin(umeeDenom, 12000000), repaid) // verify user's new loan amount in the correct denom (zero) loanBalance = s.app.LeverageKeeper.GetBorrow(ctx, addr, umeeapp.BondDenom) @@ -516,7 +520,7 @@ func (s *IntegrationTestSuite) TestRepay_Overpay() { coinToRepay := sdk.NewInt64Coin(umeeapp.BondDenom, 30000000) repaid, err := s.app.LeverageKeeper.Repay(ctx, addr, coinToRepay) s.Require().NoError(err) - s.Require().Equal(sdk.NewInt(20000000), repaid) + s.Require().Equal(sdk.NewInt64Coin(umeeDenom, 20000000), repaid) // verify that coinToRepay has not been modified s.Require().Equal(sdk.NewInt(30000000), coinToRepay.Amount) @@ -858,7 +862,7 @@ func (s *IntegrationTestSuite) TestCollateralAmountInvariant() { uTokenDenom := types.ToUTokenDenom(umeeapp.BondDenom) // withdraw the supplyed umee in the initBorrowScenario - err := s.app.LeverageKeeper.Withdraw(s.ctx, addr, sdk.NewInt64Coin(uTokenDenom, 1000000000)) + _, err := s.app.LeverageKeeper.Withdraw(s.ctx, addr, sdk.NewInt64Coin(uTokenDenom, 1000000000)) s.Require().NoError(err) // check invariant @@ -906,10 +910,12 @@ func (s *IntegrationTestSuite) TestWithdraw_InsufficientCollateral() { // withdraw more collateral than available uToken := collateral.Add(sdk.NewInt64Coin(uTokenDenom, 1)) - err := s.app.LeverageKeeper.Withdraw(s.ctx, supplierAddr, uToken) + + withdrawn, err := s.app.LeverageKeeper.Withdraw(s.ctx, supplierAddr, uToken) s.Require().EqualError(err, "0 uToken balance + 1000000 from collateral is less than 1000001u/uumee to withdraw: insufficient balance", ) + s.Require().Equal(sdk.Coin{}, withdrawn) } func (s *IntegrationTestSuite) TestTotalCollateral() { @@ -925,3 +931,121 @@ func (s *IntegrationTestSuite) TestTotalCollateral() { collateral = s.app.LeverageKeeper.GetTotalCollateral(s.ctx, uDenom) s.Require().Equal(sdk.NewInt(1000000000), collateral) } + +func (s *IntegrationTestSuite) TestLiqudateBorrow() { + addr, _ := s.initBorrowScenario() + + // The "supplier" user from the init scenario is being used because it + // already has 1k u/umee for collateral. + + // user borrows 90 umee + err := s.app.LeverageKeeper.Borrow(s.ctx, addr, sdk.NewInt64Coin(umeeapp.BondDenom, 90000000)) + s.Require().NoError(err) + + // create an account and address which will represent a liquidator + liquidatorAddr := sdk.AccAddress([]byte("addr______________03")) + liquidatorAcc := s.app.AccountKeeper.NewAccountWithAddress(s.ctx, liquidatorAddr) + s.app.AccountKeeper.SetAccount(s.ctx, liquidatorAcc) + + // mint and send 10k umee to liquidator + s.Require().NoError(s.app.BankKeeper.MintCoins(s.ctx, minttypes.ModuleName, + sdk.NewCoins(sdk.NewInt64Coin(umeeapp.BondDenom, 10000000000)), // 10k umee + )) + s.Require().NoError(s.app.BankKeeper.SendCoinsFromModuleToAccount(s.ctx, minttypes.ModuleName, liquidatorAddr, + sdk.NewCoins(sdk.NewInt64Coin(umeeapp.BondDenom, 10000000000)), // 10k umee, + )) + + // liquidator attempts to liquidate user, but user is ineligible (not over borrow limit) + repayment := sdk.NewInt64Coin(umeeapp.BondDenom, 30000000) // 30 umee + rewardDenom := types.ToUTokenDenom(umeeapp.BondDenom) + _, _, _, err = s.app.LeverageKeeper.Liquidate(s.ctx, liquidatorAddr, addr, repayment, rewardDenom) + s.Require().Error(err) + + // set umee liquidation threshold to 0.01 to allow liquidation + umeeToken, err := s.app.LeverageKeeper.GetTokenSettings(s.ctx, umeeDenom) + s.Require().NoError(err) + umeeToken.CollateralWeight = sdk.MustNewDecFromStr("0.01") + umeeToken.LiquidationThreshold = sdk.MustNewDecFromStr("0.01") + + s.Require().NoError(s.app.LeverageKeeper.SetTokenSettings(s.ctx, umeeToken)) + + // liquidator partially liquidates user, receiving some uTokens + repayment = sdk.NewInt64Coin(umeeapp.BondDenom, 10000000) // 10 umee + repaid, liquidated, reward, err := s.app.LeverageKeeper.Liquidate( + s.ctx, liquidatorAddr, addr, repayment, types.ToUTokenDenom(umeeDenom), + ) + s.Require().NoError(err) + s.Require().Equal(repayment, repaid) // 10 umee + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(umeeDenom), 11000000), liquidated) // 11 u/umee + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(umeeDenom), 11000000), reward) // 11 u/umee + + // verify borrower's new borrowed amount is 80 umee (still over borrow limit) + borrowed := s.app.LeverageKeeper.GetBorrow(s.ctx, addr, umeeapp.BondDenom) + s.Require().Equal(sdk.NewInt64Coin(umeeapp.BondDenom, 80000000), borrowed) + + // verify borrower's new collateral amount (1k - 11) = 989 u/umee + collateral := s.app.LeverageKeeper.GetCollateralAmount(s.ctx, addr, types.ToUTokenDenom(umeeDenom)) + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(umeeDenom), 989000000), collateral) + + // verify liquidator's new u/umee balance = 11 = (10 + liquidation incentive) + uTokenBalance := s.app.BankKeeper.GetBalance(s.ctx, liquidatorAddr, rewardDenom) + s.Require().Equal(sdk.NewInt64Coin(rewardDenom, 11000000), uTokenBalance) + + // verify liquidator's new umee balance (10k - 11) = 9990 umee + tokenBalance := s.app.BankKeeper.GetBalance(s.ctx, liquidatorAddr, umeeapp.BondDenom) + s.Require().Equal(sdk.NewInt64Coin(umeeapp.BondDenom, 9990000000), tokenBalance) + + // liquidator partially liquidates user, receiving base tokens directly at slightly reduced incentive + repaid, liquidated, reward, err = s.app.LeverageKeeper.Liquidate( + s.ctx, liquidatorAddr, addr, repayment, umeeDenom, + ) + s.Require().NoError(err) + s.Require().Equal(repayment, repaid) // 10 umee + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(umeeDenom), 10900000), liquidated) // 10.9 u/umee + s.Require().Equal(sdk.NewInt64Coin(umeeDenom, 10900000), reward) // 10.9 umee + + // verify borrower's new borrow amount is 70 umee (still over borrow limit) + borrowed = s.app.LeverageKeeper.GetBorrow(s.ctx, addr, umeeapp.BondDenom) + s.Require().Equal(sdk.NewInt64Coin(umeeapp.BondDenom, 70000000), borrowed) + + // verify borrower's new collateral amount (989 - 10.9) = 978.1 u/umee + collateral = s.app.LeverageKeeper.GetCollateralAmount(s.ctx, addr, types.ToUTokenDenom(umeeDenom)) + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(umeeDenom), 978100000), collateral) + + // verify liquidator's u/umee balance = 11 (unchanged) + uTokenBalance = s.app.BankKeeper.GetBalance(s.ctx, liquidatorAddr, rewardDenom) + s.Require().Equal(sdk.NewInt64Coin(rewardDenom, 11000000), uTokenBalance) + + // verify liquidator's new umee balance (9990 - 10 + 10.9) = 9990.9 umee + tokenBalance = s.app.BankKeeper.GetBalance(s.ctx, liquidatorAddr, umeeapp.BondDenom) + s.Require().Equal(sdk.NewInt64Coin(umeeapp.BondDenom, 9990900000), tokenBalance) + + // liquidator fully liquidates user, receiving more collateral and reducing borrowed amount to zero + repayment = sdk.NewInt64Coin(umeeapp.BondDenom, 300000000) // 300 umee + repaid, liquidated, reward, err = s.app.LeverageKeeper.Liquidate( + s.ctx, liquidatorAddr, addr, repayment, types.ToUTokenDenom(umeeDenom), + ) + s.Require().NoError(err) + s.Require().Equal(sdk.NewInt64Coin(umeeDenom, 70000000), repaid) // 70 umee + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(umeeDenom), 77000000), liquidated) // 77 u/umee + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(umeeDenom), 77000000), reward) // 77 u/umee + + // verify that repayment has not been modified + s.Require().Equal(sdk.NewInt(300000000), repayment.Amount) + + // verify liquidator's new u/umee balance = 88 = (11 + 77) + uTokenBalance = s.app.BankKeeper.GetBalance(s.ctx, liquidatorAddr, rewardDenom) + s.Require().Equal(sdk.NewInt64Coin(rewardDenom, 88000000), uTokenBalance) + + // verify borrower's new borrowed amount is zero + borrowed = s.app.LeverageKeeper.GetBorrow(s.ctx, addr, umeeapp.BondDenom) + s.Require().Equal(sdk.NewInt64Coin(umeeapp.BondDenom, 0), borrowed) + + // verify borrower's new collateral amount (978.1 - 77) = 901.1 u/umee + collateral = s.app.LeverageKeeper.GetCollateralAmount(s.ctx, addr, types.ToUTokenDenom(umeeDenom)) + s.Require().Equal(sdk.NewInt64Coin(types.ToUTokenDenom(umeeDenom), 901100000), collateral) + + // verify liquidator's new umee balance (9990.9 - 70) = 9920.9 umee + tokenBalance = s.app.BankKeeper.GetBalance(s.ctx, liquidatorAddr, umeeapp.BondDenom) + s.Require().Equal(sdk.NewInt64Coin(umeeapp.BondDenom, 9920900000), tokenBalance) +} diff --git a/x/leverage/keeper/msg_server.go b/x/leverage/keeper/msg_server.go index de788a4728..4e7983b08c 100644 --- a/x/leverage/keeper/msg_server.go +++ b/x/leverage/keeper/msg_server.go @@ -31,21 +31,24 @@ func (s msgServer) Supply( return nil, err } - if err := s.keeper.Supply(ctx, supplierAddr, msg.Asset); err != nil { + received, err := s.keeper.Supply(ctx, supplierAddr, msg.Asset) + if err != nil { return nil, err } s.keeper.Logger(ctx).Debug( "assets supplied", "supplier", supplierAddr.String(), - "amount", msg.Asset.String(), + "supplied", msg.Asset.String(), + "received", received.String(), ) ctx.EventManager().EmitEvents(sdk.Events{ sdk.NewEvent( types.EventTypeSupply, sdk.NewAttribute(types.EventAttrSupplier, supplierAddr.String()), - sdk.NewAttribute(sdk.AttributeKeyAmount, msg.Asset.String()), + sdk.NewAttribute(types.EventAttrSupplied, msg.Asset.String()), + sdk.NewAttribute(types.EventAttrReceived, received.String()), ), sdk.NewEvent( sdk.EventTypeMessage, @@ -54,7 +57,9 @@ func (s msgServer) Supply( ), }) - return &types.MsgSupplyResponse{}, nil + return &types.MsgSupplyResponse{ + Received: received, + }, nil } func (s msgServer) Withdraw( @@ -68,21 +73,24 @@ func (s msgServer) Withdraw( return nil, err } - if err := s.keeper.Withdraw(ctx, supplierAddr, msg.Asset); err != nil { + received, err := s.keeper.Withdraw(ctx, supplierAddr, msg.Asset) + if err != nil { return nil, err } s.keeper.Logger(ctx).Debug( "supplied assets withdrawn", "supplier", supplierAddr.String(), - "amount", msg.Asset.String(), + "redeemed", msg.Asset.String(), + "received", received.String(), ) ctx.EventManager().EmitEvents(sdk.Events{ sdk.NewEvent( types.EventTypeWithdraw, sdk.NewAttribute(types.EventAttrSupplier, supplierAddr.String()), - sdk.NewAttribute(sdk.AttributeKeyAmount, msg.Asset.String()), + sdk.NewAttribute(types.EventAttrRedeemed, msg.Asset.String()), + sdk.NewAttribute(types.EventAttrReceived, received.String()), ), sdk.NewEvent( sdk.EventTypeMessage, @@ -91,7 +99,9 @@ func (s msgServer) Withdraw( ), }) - return &types.MsgWithdrawResponse{}, nil + return &types.MsgWithdrawResponse{ + Received: received, + }, nil } func (s msgServer) Collateralize( @@ -105,21 +115,21 @@ func (s msgServer) Collateralize( return nil, err } - if err := s.keeper.Collateralize(ctx, borrowerAddr, msg.Coin); err != nil { + if err := s.keeper.Collateralize(ctx, borrowerAddr, msg.Asset); err != nil { return nil, err } s.keeper.Logger(ctx).Debug( "collateral added", "borrower", borrowerAddr.String(), - "amount", msg.Coin.String(), + "amount", msg.Asset.String(), ) ctx.EventManager().EmitEvents(sdk.Events{ sdk.NewEvent( types.EventTypeCollateralize, sdk.NewAttribute(types.EventAttrBorrower, borrowerAddr.String()), - sdk.NewAttribute(sdk.AttributeKeyAmount, msg.Coin.String()), + sdk.NewAttribute(sdk.AttributeKeyAmount, msg.Asset.String()), ), sdk.NewEvent( sdk.EventTypeMessage, @@ -142,21 +152,21 @@ func (s msgServer) Decollateralize( return nil, err } - if err := s.keeper.Decollateralize(ctx, borrowerAddr, msg.Coin); err != nil { + if err := s.keeper.Decollateralize(ctx, borrowerAddr, msg.Asset); err != nil { return nil, err } s.keeper.Logger(ctx).Debug( "collateral removed", "borrower", borrowerAddr.String(), - "amount", msg.Coin.String(), + "amount", msg.Asset.String(), ) ctx.EventManager().EmitEvents(sdk.Events{ sdk.NewEvent( types.EventTypeDecollateralize, sdk.NewAttribute(types.EventAttrBorrower, borrowerAddr.String()), - sdk.NewAttribute(sdk.AttributeKeyAmount, msg.Coin.String()), + sdk.NewAttribute(sdk.AttributeKeyAmount, msg.Asset.String()), ), sdk.NewEvent( sdk.EventTypeMessage, @@ -221,21 +231,19 @@ func (s msgServer) Repay( return nil, err } - repaidCoin := sdk.NewCoin(msg.Asset.Denom, repaid) - s.keeper.Logger(ctx).Debug( "borrowed assets repaid", "borrower", borrowerAddr.String(), - "amount", repaidCoin.String(), "attempted", msg.Asset.String(), + "repaid", repaid.String(), ) ctx.EventManager().EmitEvents(sdk.Events{ sdk.NewEvent( - types.EventTypeRepayBorrowedAsset, + types.EventTypeRepay, sdk.NewAttribute(types.EventAttrBorrower, borrowerAddr.String()), - sdk.NewAttribute(sdk.AttributeKeyAmount, repaidCoin.String()), sdk.NewAttribute(types.EventAttrAttempted, msg.Asset.String()), + sdk.NewAttribute(types.EventAttrRepaid, repaid.String()), ), sdk.NewEvent( sdk.EventTypeMessage, @@ -245,7 +253,7 @@ func (s msgServer) Repay( }) return &types.MsgRepayResponse{ - Repaid: repaidCoin, + Repaid: repaid, }, nil } @@ -265,18 +273,18 @@ func (s msgServer) Liquidate( return nil, err } - repaid, collateral, reward, err := s.keeper.Liquidate(ctx, liquidator, borrower, msg.Repayment, msg.RewardDenom) + repaid, liquidated, reward, err := s.keeper.Liquidate(ctx, liquidator, borrower, msg.Repayment, msg.RewardDenom) if err != nil { return nil, err } s.keeper.Logger(ctx).Debug( - "borrowed assets repaid by liquidator", + "unhealthy borrower liquidated", "liquidator", liquidator.String(), "borrower", borrower.String(), "attempted", msg.Repayment.String(), "repaid", repaid.String(), - "collateral", collateral.String(), + "liquidated", liquidated.String(), "reward", reward.String(), ) @@ -287,7 +295,7 @@ func (s msgServer) Liquidate( sdk.NewAttribute(types.EventAttrBorrower, borrower.String()), sdk.NewAttribute(types.EventAttrAttempted, msg.Repayment.String()), sdk.NewAttribute(types.EventAttrRepaid, reward.String()), - sdk.NewAttribute(types.EventAttrCollateral, collateral.String()), + sdk.NewAttribute(types.EventAttrLiquidated, liquidated.String()), sdk.NewAttribute(types.EventAttrReward, reward.String()), ), sdk.NewEvent( @@ -299,7 +307,7 @@ func (s msgServer) Liquidate( return &types.MsgLiquidateResponse{ Repaid: repaid, - Collateral: collateral, + Collateral: liquidated, Reward: reward, }, nil } diff --git a/x/leverage/simulation/operations.go b/x/leverage/simulation/operations.go index 25f04a4683..f74c39f026 100644 --- a/x/leverage/simulation/operations.go +++ b/x/leverage/simulation/operations.go @@ -294,7 +294,7 @@ func SimulateMsgRepay(ak simulation.AccountKeeper, bk types.BankKeeper, lk keepe ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { from, repayToken, skip := randomRepayFields(r, ctx, accs, lk) if skip { - return simtypes.NoOpMsg(types.ModuleName, types.EventTypeRepayBorrowedAsset, "skip all transfers"), nil, nil + return simtypes.NoOpMsg(types.ModuleName, types.EventTypeRepay, "skip all transfers"), nil, nil } msg := types.NewMsgRepay(from.Address, repayToken) @@ -305,7 +305,7 @@ func SimulateMsgRepay(ak simulation.AccountKeeper, bk types.BankKeeper, lk keepe TxGen: simappparams.MakeTestEncodingConfig().TxConfig, Cdc: nil, Msg: msg, - MsgType: types.EventTypeRepayBorrowedAsset, + MsgType: types.EventTypeRepay, Context: ctx, SimAccount: from, AccountKeeper: ak, diff --git a/x/leverage/simulation/operations_test.go b/x/leverage/simulation/operations_test.go index 5cf67d64ae..adcb730888 100644 --- a/x/leverage/simulation/operations_test.go +++ b/x/leverage/simulation/operations_test.go @@ -151,7 +151,7 @@ func (s *SimTestSuite) TestWeightedOperations() { {simulation.DefaultWeightMsgBorrow, types.ModuleName, types.EventTypeBorrow}, {simulation.DefaultWeightMsgCollateralize, types.ModuleName, types.EventTypeCollateralize}, {simulation.DefaultWeightMsgDecollateralize, types.ModuleName, types.EventTypeDecollateralize}, - {simulation.DefaultWeightMsgRepay, types.ModuleName, types.EventTypeRepayBorrowedAsset}, + {simulation.DefaultWeightMsgRepay, types.ModuleName, types.EventTypeRepay}, {simulation.DefaultWeightMsgLiquidate, types.ModuleName, types.EventTypeLiquidate}, } @@ -191,7 +191,8 @@ func (s *SimTestSuite) TestSimulateMsgWithdraw() { supplyToken := sdk.NewCoin(umeeapp.BondDenom, sdk.NewInt(100)) accs := s.getTestingAccounts(r, 3, func(fundedAccount simtypes.Account) { - s.Require().NoError(s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken)) + _, err := s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken) + s.Require().NoError(err) }) s.app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: s.app.LastBlockHeight() + 1, AppHash: s.app.LastCommitID().Hash}}) @@ -215,13 +216,11 @@ func (s *SimTestSuite) TestSimulateMsgBorrow() { supplyToken := sdk.NewCoin(umeeapp.BondDenom, sdk.NewInt(1000)) accs := s.getTestingAccounts(r, 3, func(fundedAccount simtypes.Account) { - uToken, err := s.app.LeverageKeeper.ExchangeToken(s.ctx, supplyToken) + uToken, err := s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken) if err != nil { s.Require().NoError(err) } - - s.app.LeverageKeeper.Collateralize(s.ctx, fundedAccount.Address, uToken) - s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken) + s.Require().NoError(s.app.LeverageKeeper.Collateralize(s.ctx, fundedAccount.Address, uToken)) }) s.app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: s.app.LastBlockHeight() + 1, AppHash: s.app.LastCommitID().Hash}}) @@ -245,7 +244,8 @@ func (s *SimTestSuite) TestSimulateMsgCollateralize() { supplyToken := sdk.NewInt64Coin(umeeapp.BondDenom, 100) accs := s.getTestingAccounts(r, 3, func(fundedAccount simtypes.Account) { - s.Require().NoError(s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken)) + _, err := s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken) + s.Require().NoError(err) }) s.app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: s.app.LastBlockHeight() + 1, AppHash: s.app.LastCommitID().Hash}}) @@ -260,7 +260,7 @@ func (s *SimTestSuite) TestSimulateMsgCollateralize() { s.Require().True(operationMsg.OK) s.Require().Equal("umee1ghekyjucln7y67ntx7cf27m9dpuxxemn8w6h33", msg.Borrower) s.Require().Equal(types.EventTypeCollateralize, msg.Type()) - s.Require().Equal("73u/uumee", msg.Coin.String()) + s.Require().Equal("73u/uumee", msg.Asset.String()) s.Require().Len(futureOperations, 0) } @@ -269,12 +269,8 @@ func (s *SimTestSuite) TestSimulateMsgDecollateralize() { supplyToken := sdk.NewInt64Coin(umeeapp.BondDenom, 100) accs := s.getTestingAccounts(r, 3, func(fundedAccount simtypes.Account) { - uToken, err := s.app.LeverageKeeper.ExchangeToken(s.ctx, supplyToken) - if err != nil { - s.Require().NoError(err) - } - - s.Require().NoError(s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken)) + uToken, err := s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken) + s.Require().NoError(err) s.Require().NoError(s.app.LeverageKeeper.Collateralize(s.ctx, fundedAccount.Address, uToken)) }) @@ -290,7 +286,7 @@ func (s *SimTestSuite) TestSimulateMsgDecollateralize() { s.Require().True(operationMsg.OK) s.Require().Equal("umee1ghekyjucln7y67ntx7cf27m9dpuxxemn8w6h33", msg.Borrower) s.Require().Equal(types.EventTypeDecollateralize, msg.Type()) - s.Require().Equal("73u/uumee", msg.Coin.String()) + s.Require().Equal("73u/uumee", msg.Asset.String()) s.Require().Len(futureOperations, 0) } @@ -300,12 +296,8 @@ func (s *SimTestSuite) TestSimulateMsgRepay() { borrowToken := sdk.NewInt64Coin(umeeapp.BondDenom, 20) accs := s.getTestingAccounts(r, 3, func(fundedAccount simtypes.Account) { - uToken, err := s.app.LeverageKeeper.ExchangeToken(s.ctx, supplyToken) - if err != nil { - s.Require().NoError(err) - } - - s.Require().NoError(s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken)) + uToken, err := s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken) + s.Require().NoError(err) s.Require().NoError(s.app.LeverageKeeper.Collateralize(s.ctx, fundedAccount.Address, uToken)) s.Require().NoError(s.app.LeverageKeeper.Borrow(s.ctx, fundedAccount.Address, borrowToken)) }) @@ -321,7 +313,7 @@ func (s *SimTestSuite) TestSimulateMsgRepay() { s.Require().True(operationMsg.OK) s.Require().Equal("umee1ghekyjucln7y67ntx7cf27m9dpuxxemn8w6h33", msg.Borrower) - s.Require().Equal(types.EventTypeRepayBorrowedAsset, msg.Type()) + s.Require().Equal(types.EventTypeRepay, msg.Type()) s.Require().Equal("9uumee", msg.Asset.String()) s.Require().Len(futureOperations, 0) } @@ -333,7 +325,8 @@ func (s *SimTestSuite) TestSimulateMsgLiquidate() { borrowToken := sdk.NewCoin(umeeapp.BondDenom, sdk.NewInt(10)) accs := s.getTestingAccounts(r, 3, func(fundedAccount simtypes.Account) { - s.Require().NoError(s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken)) + _, err := s.app.LeverageKeeper.Supply(s.ctx, fundedAccount.Address, supplyToken) + s.Require().NoError(err) s.Require().NoError(s.app.LeverageKeeper.Collateralize(s.ctx, fundedAccount.Address, uToken)) s.Require().NoError(s.app.LeverageKeeper.Borrow(s.ctx, fundedAccount.Address, borrowToken)) }) diff --git a/x/leverage/types/events.go b/x/leverage/types/events.go index d065526404..540b096098 100644 --- a/x/leverage/types/events.go +++ b/x/leverage/types/events.go @@ -2,27 +2,32 @@ package types // Event types and attributes for the leverage module const ( - EventTypeSupply = "supply" - EventTypeWithdraw = "withdraw" - EventTypeCollateralize = "collateralize" - EventTypeDecollateralize = "decollateralize" - EventTypeBorrow = "borrow" - EventTypeRepayBorrowedAsset = "repay" - EventTypeLiquidate = "liquidate" - EventTypeRepayBadDebt = "repay_bad_debt" - EventTypeReservesExhausted = "reserves_exhausted" - EventTypeInterestAccrual = "interest_accrual" - EventTypeFundOracle = "fund_oracle" + // Messages + EventTypeSupply = "supply" + EventTypeWithdraw = "withdraw" + EventTypeCollateralize = "collateralize" + EventTypeDecollateralize = "decollateralize" + EventTypeBorrow = "borrow" + EventTypeRepay = "repay" + EventTypeLiquidate = "liquidate" + + // EndBlock + EventTypeRepayBadDebt = "repay_bad_debt" + EventTypeReservesExhausted = "reserves_exhausted" + EventTypeInterestAccrual = "interest_accrual" + EventTypeFundOracle = "fund_oracle" EventAttrModule = ModuleName EventAttrSupplier = "supplier" EventAttrBorrower = "borrower" EventAttrLiquidator = "liquidator" EventAttrDenom = "denom" - EventAttrEnable = "enabled" + EventAttrSupplied = "supplied" + EventAttrReceived = "received" + EventAttrRedeemed = "redeemed" EventAttrAttempted = "attempted" EventAttrRepaid = "repaid" - EventAttrCollateral = "collateral" + EventAttrLiquidated = "liquidated" EventAttrReward = "reward" EventAttrInterest = "total_interest" EventAttrBlockHeight = "block_height" diff --git a/x/leverage/types/tx.go b/x/leverage/types/tx.go index a0ea980782..d911a37162 100644 --- a/x/leverage/types/tx.go +++ b/x/leverage/types/tx.go @@ -55,10 +55,10 @@ func (msg *MsgWithdraw) GetSignBytes() []byte { return sdk.MustSortJSON(bz) } -func NewMsgCollateralize(borrower sdk.AccAddress, coin sdk.Coin) *MsgCollateralize { +func NewMsgCollateralize(borrower sdk.AccAddress, asset sdk.Coin) *MsgCollateralize { return &MsgCollateralize{ Borrower: borrower.String(), - Coin: coin, + Asset: asset, } } @@ -79,10 +79,10 @@ func (msg *MsgCollateralize) GetSignBytes() []byte { return sdk.MustSortJSON(bz) } -func NewMsgDecollateralize(borrower sdk.AccAddress, coin sdk.Coin) *MsgDecollateralize { +func NewMsgDecollateralize(borrower sdk.AccAddress, asset sdk.Coin) *MsgDecollateralize { return &MsgDecollateralize{ Borrower: borrower.String(), - Coin: coin, + Asset: asset, } } @@ -135,7 +135,7 @@ func NewMsgRepay(borrower sdk.AccAddress, asset sdk.Coin) *MsgRepay { } func (msg MsgRepay) Route() string { return ModuleName } -func (msg MsgRepay) Type() string { return EventTypeRepayBorrowedAsset } +func (msg MsgRepay) Type() string { return EventTypeRepay } func (msg *MsgRepay) ValidateBasic() error { return validateSenderAndAsset(msg.Borrower, &msg.Asset) diff --git a/x/leverage/types/tx.pb.go b/x/leverage/types/tx.pb.go index 3c518eff3f..11f61d55b4 100644 --- a/x/leverage/types/tx.pb.go +++ b/x/leverage/types/tx.pb.go @@ -29,7 +29,7 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -// MsgSupply is the request structure for the Supply RPC. +// MsgSupply represents a user's request to supply assets to the module. type MsgSupply struct { // Supplier is the account address supplying assets and the signer of the message. Supplier string `protobuf:"bytes,1,opt,name=supplier,proto3" json:"supplier,omitempty"` @@ -115,7 +115,7 @@ var xxx_messageInfo_MsgWithdraw proto.InternalMessageInfo type MsgCollateralize struct { // Borrower is the account address adding collateral and the signer of the message. Borrower string `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"` - Coin types.Coin `protobuf:"bytes,2,opt,name=coin,proto3" json:"coin"` + Asset types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"` } func (m *MsgCollateralize) Reset() { *m = MsgCollateralize{} } @@ -156,7 +156,7 @@ var xxx_messageInfo_MsgCollateralize proto.InternalMessageInfo type MsgDecollateralize struct { // Borrower is the account address removing collateral and the signer of the message. Borrower string `protobuf:"bytes,1,opt,name=borrower,proto3" json:"borrower,omitempty"` - Coin types.Coin `protobuf:"bytes,2,opt,name=coin,proto3" json:"coin"` + Asset types.Coin `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"` } func (m *MsgDecollateralize) Reset() { *m = MsgDecollateralize{} } @@ -329,6 +329,8 @@ var xxx_messageInfo_MsgLiquidate proto.InternalMessageInfo // MsgSupplyResponse defines the Msg/Supply response type. type MsgSupplyResponse struct { + // Received is the amount of uTokens received. + Received types.Coin `protobuf:"bytes,1,opt,name=received,proto3" json:"received"` } func (m *MsgSupplyResponse) Reset() { *m = MsgSupplyResponse{} } @@ -366,6 +368,8 @@ var xxx_messageInfo_MsgSupplyResponse proto.InternalMessageInfo // MsgWithdrawResponse defines the Msg/Withdraw response type. type MsgWithdrawResponse struct { + // Received is the amount of base tokens received. + Received types.Coin `protobuf:"bytes,1,opt,name=received,proto3" json:"received"` } func (m *MsgWithdrawResponse) Reset() { *m = MsgWithdrawResponse{} } @@ -514,8 +518,7 @@ var xxx_messageInfo_MsgBorrowResponse proto.InternalMessageInfo // MsgRepayResponse defines the Msg/Repay response type. type MsgRepayResponse struct { - // Repaid is the amount of debt, in base tokens, that was repaid to the - // module by the borrower. + // Repaid is the amount of base tokens repaid to the module. Repaid types.Coin `protobuf:"bytes,1,opt,name=repaid,proto3" json:"repaid"` } @@ -554,11 +557,11 @@ var xxx_messageInfo_MsgRepayResponse proto.InternalMessageInfo // MsgLiquidateResponse defines the Msg/Liquidate response type. type MsgLiquidateResponse struct { - // Repaid is the amount of debt, in base tokens, that liquidator repaid + // Repaid is the amount of borrowed base tokens that the liquidator repaid // to the module on behalf of the borrower. Repaid types.Coin `protobuf:"bytes,1,opt,name=repaid,proto3" json:"repaid"` // Collateral is the amount of the borrower's uToken collateral that - // was converted to the reward tokens as a result of liquidation. + // was liquidated. Collateral types.Coin `protobuf:"bytes,2,opt,name=collateral,proto3" json:"collateral"` // Reward is the amount of base tokens that the liquidator received from // the module as reward for the liquidation. @@ -618,46 +621,46 @@ func init() { func init() { proto.RegisterFile("umee/leverage/v1/tx.proto", fileDescriptor_72683128ee6e8843) } var fileDescriptor_72683128ee6e8843 = []byte{ - // 617 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xdb, 0x6e, 0xd3, 0x40, - 0x10, 0x8d, 0xdb, 0x34, 0x4a, 0x26, 0x45, 0x14, 0xb7, 0x48, 0xa9, 0x01, 0x53, 0xcc, 0x45, 0x15, - 0x02, 0x9b, 0xa4, 0x42, 0x3c, 0x21, 0xa4, 0xb4, 0x12, 0x52, 0xc1, 0x08, 0xa5, 0x0f, 0x48, 0x48, - 0x50, 0x9c, 0x64, 0xe4, 0x5a, 0x38, 0x5e, 0xe3, 0xdd, 0x24, 0x0d, 0x5f, 0xc1, 0x87, 0xf0, 0x21, - 0xe1, 0xad, 0x2f, 0x48, 0x3c, 0x21, 0x48, 0x7e, 0x04, 0xad, 0x2f, 0x9b, 0x0b, 0x6e, 0xb0, 0xa8, - 0xf2, 0xb6, 0x3b, 0xe7, 0xcc, 0x39, 0xeb, 0x99, 0xd1, 0x18, 0xb6, 0xbb, 0x1d, 0x44, 0xc3, 0xc5, - 0x1e, 0x06, 0x96, 0x8d, 0x46, 0xaf, 0x6a, 0xb0, 0x53, 0xdd, 0x0f, 0x08, 0x23, 0xf2, 0x06, 0x87, - 0xf4, 0x04, 0xd2, 0x7b, 0x55, 0x45, 0x6d, 0x11, 0xda, 0x21, 0xd4, 0x68, 0x5a, 0x94, 0x53, 0x9b, - 0xc8, 0xac, 0xaa, 0xd1, 0x22, 0x8e, 0x17, 0x65, 0x28, 0x5b, 0x36, 0xb1, 0x49, 0x78, 0x34, 0xf8, - 0x29, 0x8a, 0x6a, 0xef, 0xa1, 0x64, 0x52, 0xfb, 0xa8, 0xeb, 0xfb, 0xee, 0x40, 0x56, 0xa0, 0x48, - 0xf9, 0xc9, 0xc1, 0xa0, 0x22, 0xed, 0x48, 0xbb, 0xa5, 0x86, 0xb8, 0xcb, 0x8f, 0x61, 0xcd, 0xa2, - 0x14, 0x59, 0x65, 0x65, 0x47, 0xda, 0x2d, 0xd7, 0xb6, 0xf5, 0xc8, 0x4e, 0xe7, 0x76, 0x7a, 0x6c, - 0xa7, 0xef, 0x13, 0xc7, 0xab, 0xe7, 0x87, 0x3f, 0x6f, 0xe6, 0x1a, 0x11, 0x5b, 0xfb, 0x00, 0x65, - 0x93, 0xda, 0x6f, 0x1c, 0x76, 0xd2, 0x0e, 0xac, 0xfe, 0x32, 0x1c, 0x5a, 0xb0, 0x61, 0x52, 0x7b, - 0x9f, 0xb8, 0xae, 0xc5, 0x30, 0xb0, 0x5c, 0xe7, 0x33, 0x72, 0x9b, 0x26, 0x09, 0x02, 0xd2, 0x9f, - 0xd8, 0x24, 0x77, 0x79, 0x0f, 0xf2, 0xbc, 0x2a, 0x59, 0x5d, 0x42, 0xb2, 0x86, 0x20, 0x9b, 0xd4, - 0x3e, 0xc0, 0xd6, 0x72, 0x6d, 0xa2, 0x6e, 0xd4, 0x43, 0x8d, 0x85, 0xea, 0xff, 0x59, 0xab, 0x77, - 0x50, 0x34, 0xa9, 0xdd, 0x40, 0xdf, 0x1a, 0x2c, 0x43, 0xfe, 0xab, 0x04, 0xeb, 0x26, 0xb5, 0x5f, - 0x3a, 0x9f, 0xba, 0x4e, 0xdb, 0x62, 0x28, 0xab, 0x00, 0x6e, 0x7c, 0x21, 0x89, 0xcb, 0x54, 0x64, - 0xe6, 0x0d, 0x2b, 0x73, 0x6f, 0x78, 0x0a, 0xa5, 0x80, 0x3f, 0xb4, 0x83, 0x1e, 0xab, 0xac, 0x66, - 0x7b, 0xc7, 0x24, 0x43, 0xbe, 0x05, 0xeb, 0x01, 0xf6, 0xad, 0xa0, 0x7d, 0xdc, 0x46, 0x8f, 0x74, - 0x2a, 0xf9, 0x50, 0xbe, 0x1c, 0xc5, 0x0e, 0x78, 0x48, 0xdb, 0x84, 0x2b, 0x62, 0xf6, 0x1b, 0x48, - 0x7d, 0xe2, 0x51, 0xd4, 0xae, 0xc2, 0xe6, 0xd4, 0xc0, 0x8a, 0xb0, 0x02, 0x95, 0xf9, 0x29, 0x13, - 0xd8, 0x75, 0x50, 0xfe, 0x1e, 0x0e, 0x81, 0x46, 0x2e, 0x51, 0x4f, 0x45, 0xf0, 0x45, 0x38, 0xb4, - 0x61, 0x23, 0x92, 0x98, 0xfc, 0x04, 0x0a, 0xfc, 0xf9, 0x4e, 0x3b, 0x2c, 0x54, 0x86, 0xaf, 0x8d, - 0xe9, 0xda, 0x37, 0x09, 0xb6, 0xa6, 0xcb, 0x7e, 0x61, 0x45, 0xf9, 0x19, 0xc0, 0xe4, 0x63, 0xb2, - 0x0e, 0xc1, 0x54, 0x4a, 0xe4, 0xcc, 0x2b, 0x9d, 0xb5, 0x73, 0x31, 0xbd, 0xf6, 0x3d, 0x0f, 0xab, - 0x26, 0xb5, 0xe5, 0x43, 0x28, 0xc4, 0x4b, 0xe9, 0x9a, 0x3e, 0xbf, 0xea, 0x74, 0xd1, 0x35, 0xe5, - 0xf6, 0x02, 0x50, 0x94, 0xe1, 0x35, 0x14, 0xc5, 0x02, 0xba, 0x91, 0x9a, 0x90, 0xc0, 0xca, 0xdd, - 0x85, 0xb0, 0x50, 0x3c, 0x86, 0x4b, 0xb3, 0x0b, 0x47, 0x4b, 0xcd, 0x9b, 0xe1, 0x28, 0xf7, 0xff, - 0xcd, 0x11, 0x06, 0x08, 0x97, 0xe7, 0x97, 0xcd, 0x9d, 0xd4, 0xf4, 0x39, 0x96, 0xf2, 0x20, 0x0b, - 0x4b, 0xd8, 0x1c, 0x42, 0x21, 0x5e, 0x36, 0xe9, 0x55, 0x8e, 0xc0, 0x73, 0xaa, 0x3c, 0x3b, 0xd2, - 0xf2, 0x73, 0x58, 0x8b, 0x17, 0x4b, 0x2a, 0x3b, 0xc4, 0x14, 0xed, 0x7c, 0x4c, 0x08, 0x1d, 0x41, - 0x69, 0x6a, 0x83, 0xa4, 0x26, 0x08, 0x5c, 0xb9, 0xb7, 0x18, 0x4f, 0x44, 0xeb, 0xaf, 0x86, 0xbf, - 0xd5, 0xdc, 0x70, 0xa4, 0x4a, 0x67, 0x23, 0x55, 0xfa, 0x35, 0x52, 0xa5, 0x2f, 0x63, 0x35, 0x77, - 0x36, 0x56, 0x73, 0x3f, 0xc6, 0x6a, 0xee, 0xed, 0x23, 0xdb, 0x61, 0x27, 0xdd, 0xa6, 0xde, 0x22, - 0x1d, 0x83, 0xeb, 0x3d, 0xf4, 0x90, 0xf5, 0x49, 0xf0, 0x31, 0xbc, 0x18, 0xbd, 0x9a, 0x71, 0x3a, - 0xf9, 0x0b, 0xb3, 0x81, 0x8f, 0xb4, 0x59, 0x08, 0x7f, 0x9f, 0x7b, 0x7f, 0x02, 0x00, 0x00, 0xff, - 0xff, 0xf4, 0x30, 0x1e, 0x2f, 0xa3, 0x07, 0x00, 0x00, + // 623 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x6e, 0xd3, 0x40, + 0x10, 0x8e, 0xdb, 0x34, 0x4a, 0x26, 0x45, 0x14, 0xb7, 0x87, 0xd4, 0x80, 0x29, 0xe6, 0x47, 0x15, + 0x02, 0x9b, 0x04, 0x21, 0x0e, 0x08, 0x21, 0xa5, 0x95, 0x90, 0x0a, 0x46, 0x55, 0x7a, 0x40, 0x42, + 0x82, 0xe2, 0x24, 0xa3, 0xad, 0x85, 0xe3, 0x35, 0xbb, 0x4e, 0xd2, 0xf0, 0x14, 0x3c, 0x08, 0x0f, + 0x12, 0x6e, 0xbd, 0x20, 0x71, 0x42, 0x90, 0xbc, 0x08, 0xf2, 0xdf, 0xe6, 0x07, 0x37, 0x58, 0x40, + 0x6e, 0xbb, 0xf3, 0xcd, 0x7c, 0xdf, 0xec, 0xee, 0x97, 0x89, 0x61, 0xbb, 0xdb, 0x41, 0x34, 0x1c, + 0xec, 0x21, 0xb3, 0x08, 0x1a, 0xbd, 0xaa, 0xe1, 0x9f, 0xea, 0x1e, 0xa3, 0x3e, 0x95, 0x37, 0x02, + 0x48, 0x4f, 0x20, 0xbd, 0x57, 0x55, 0xd4, 0x16, 0xe5, 0x1d, 0xca, 0x8d, 0xa6, 0xc5, 0x83, 0xd4, + 0x26, 0xfa, 0x56, 0xd5, 0x68, 0x51, 0xdb, 0x8d, 0x2a, 0x94, 0x2d, 0x42, 0x09, 0x0d, 0x97, 0x46, + 0xb0, 0x8a, 0xa2, 0xda, 0x5b, 0x28, 0x99, 0x9c, 0x1c, 0x75, 0x3d, 0xcf, 0x19, 0xc8, 0x0a, 0x14, + 0x79, 0xb0, 0xb2, 0x91, 0x55, 0xa4, 0x1d, 0x69, 0xb7, 0xd4, 0x10, 0x7b, 0xf9, 0x21, 0xac, 0x59, + 0x9c, 0xa3, 0x5f, 0x59, 0xd9, 0x91, 0x76, 0xcb, 0xb5, 0x6d, 0x3d, 0x92, 0xd3, 0x03, 0x39, 0x3d, + 0x96, 0xd3, 0xf7, 0xa8, 0xed, 0xd6, 0xf3, 0xc3, 0xef, 0xd7, 0x72, 0x8d, 0x28, 0x5b, 0x7b, 0x07, + 0x65, 0x93, 0x93, 0x57, 0xb6, 0x7f, 0xd2, 0x66, 0x56, 0x7f, 0x19, 0x0a, 0x08, 0x1b, 0x26, 0x27, + 0x7b, 0xd4, 0x71, 0x2c, 0x1f, 0x99, 0xe5, 0xd8, 0x1f, 0x31, 0x90, 0x69, 0x52, 0xc6, 0x68, 0x7f, + 0x22, 0x93, 0xec, 0xff, 0x56, 0x86, 0x80, 0x6c, 0x72, 0xb2, 0x8f, 0xad, 0x65, 0x0b, 0x45, 0x2f, + 0x52, 0x0f, 0x59, 0x96, 0xc1, 0xff, 0x06, 0x8a, 0x26, 0x27, 0x0d, 0xf4, 0xac, 0xc1, 0x32, 0xe8, + 0x3f, 0x4b, 0xb0, 0x6e, 0x72, 0xf2, 0xc2, 0xfe, 0xd0, 0xb5, 0xdb, 0x96, 0x8f, 0xb2, 0x0a, 0xe0, + 0xc4, 0x1b, 0x9a, 0xa8, 0x4c, 0x45, 0x66, 0x7a, 0x58, 0x99, 0xeb, 0xe1, 0x09, 0x94, 0x58, 0xd0, + 0x68, 0x07, 0x5d, 0xbf, 0xb2, 0x9a, 0xad, 0x8f, 0x49, 0x85, 0x7c, 0x1d, 0xd6, 0x19, 0xf6, 0x2d, + 0xd6, 0x3e, 0x6e, 0xa3, 0x4b, 0x3b, 0x95, 0x7c, 0x48, 0x5f, 0x8e, 0x62, 0xfb, 0x41, 0x48, 0x3b, + 0x84, 0x4b, 0xc2, 0xff, 0x0d, 0xe4, 0x1e, 0x75, 0x39, 0xca, 0x8f, 0xa1, 0xc8, 0xb0, 0x85, 0x76, + 0x0f, 0xdb, 0x61, 0xc3, 0x19, 0x54, 0x45, 0x81, 0xd6, 0x80, 0xcd, 0x29, 0xc7, 0xff, 0x1f, 0x4e, + 0x05, 0x2a, 0xf3, 0x1e, 0x4f, 0x88, 0xb5, 0x2b, 0xa0, 0xfc, 0x6e, 0x4c, 0x81, 0x6e, 0x86, 0xe7, + 0x8b, 0xdc, 0x24, 0x82, 0xcf, 0xc3, 0x9f, 0x4c, 0x68, 0x01, 0xd1, 0xdf, 0x23, 0x28, 0x04, 0x17, + 0x67, 0x67, 0xee, 0x2e, 0x4e, 0xd7, 0xbe, 0x48, 0xb0, 0x35, 0xfd, 0xe0, 0xff, 0xcc, 0x28, 0x3f, + 0x05, 0x98, 0x1c, 0x26, 0xab, 0xfd, 0xa6, 0x4a, 0x22, 0xe5, 0xe0, 0x8d, 0xb3, 0x7a, 0x26, 0x4e, + 0xaf, 0x7d, 0xcd, 0xc3, 0xaa, 0xc9, 0x89, 0x7c, 0x00, 0x85, 0x78, 0x24, 0x5e, 0xd6, 0xe7, 0x07, + 0xad, 0x2e, 0xfc, 0xa2, 0xdc, 0x58, 0x00, 0x8a, 0x6b, 0x38, 0x84, 0xa2, 0x18, 0x7f, 0x57, 0x53, + 0x0b, 0x12, 0x58, 0xb9, 0xb5, 0x10, 0x16, 0x8c, 0xc7, 0x70, 0x61, 0x76, 0xdc, 0x69, 0xa9, 0x75, + 0x33, 0x39, 0xca, 0x9d, 0x3f, 0xe7, 0x08, 0x01, 0x84, 0x8b, 0xf3, 0x83, 0xee, 0x66, 0x6a, 0xf9, + 0x5c, 0x96, 0x72, 0x37, 0x4b, 0x96, 0x90, 0x39, 0x80, 0x42, 0x3c, 0xe6, 0xd2, 0x6f, 0x39, 0x02, + 0xcf, 0xb9, 0xe5, 0x59, 0x4b, 0xcb, 0xcf, 0x60, 0x2d, 0x1e, 0x69, 0xa9, 0xd9, 0x21, 0xa6, 0x68, + 0xe7, 0x63, 0x82, 0xe8, 0x08, 0x4a, 0x53, 0xb3, 0x2b, 0xb5, 0x40, 0xe0, 0xca, 0xed, 0xc5, 0x78, + 0x42, 0x5a, 0x7f, 0x39, 0xfc, 0xa9, 0xe6, 0x86, 0x23, 0x55, 0x3a, 0x1b, 0xa9, 0xd2, 0x8f, 0x91, + 0x2a, 0x7d, 0x1a, 0xab, 0xb9, 0xb3, 0xb1, 0x9a, 0xfb, 0x36, 0x56, 0x73, 0xaf, 0xef, 0x13, 0xdb, + 0x3f, 0xe9, 0x36, 0xf5, 0x16, 0xed, 0x18, 0x01, 0xdf, 0x3d, 0x17, 0xfd, 0x3e, 0x65, 0xef, 0xc3, + 0x8d, 0xd1, 0xab, 0x19, 0xa7, 0x93, 0x6f, 0x00, 0x7f, 0xe0, 0x21, 0x6f, 0x16, 0xc2, 0x3f, 0xef, + 0x07, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x70, 0x35, 0x21, 0x04, 0x21, 0x08, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1079,7 +1082,7 @@ func (m *MsgCollateralize) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l { - size, err := m.Coin.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Asset.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1119,7 +1122,7 @@ func (m *MsgDecollateralize) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l { - size, err := m.Coin.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Asset.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1292,6 +1295,16 @@ func (m *MsgSupplyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + { + size, err := m.Received.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } @@ -1315,6 +1328,16 @@ func (m *MsgWithdrawResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + { + size, err := m.Received.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } @@ -1524,7 +1547,7 @@ func (m *MsgCollateralize) Size() (n int) { if l > 0 { n += 1 + l + sovTx(uint64(l)) } - l = m.Coin.Size() + l = m.Asset.Size() n += 1 + l + sovTx(uint64(l)) return n } @@ -1539,7 +1562,7 @@ func (m *MsgDecollateralize) Size() (n int) { if l > 0 { n += 1 + l + sovTx(uint64(l)) } - l = m.Coin.Size() + l = m.Asset.Size() n += 1 + l + sovTx(uint64(l)) return n } @@ -1603,6 +1626,8 @@ func (m *MsgSupplyResponse) Size() (n int) { } var l int _ = l + l = m.Received.Size() + n += 1 + l + sovTx(uint64(l)) return n } @@ -1612,6 +1637,8 @@ func (m *MsgWithdrawResponse) Size() (n int) { } var l int _ = l + l = m.Received.Size() + n += 1 + l + sovTx(uint64(l)) return n } @@ -1967,7 +1994,7 @@ func (m *MsgCollateralize) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Coin", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Asset", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -1994,7 +2021,7 @@ func (m *MsgCollateralize) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Coin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Asset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2082,7 +2109,7 @@ func (m *MsgDecollateralize) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Coin", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Asset", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -2109,7 +2136,7 @@ func (m *MsgDecollateralize) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Coin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Asset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2572,6 +2599,39 @@ func (m *MsgSupplyResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgSupplyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Received", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Received.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -2622,6 +2682,39 @@ func (m *MsgWithdrawResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgWithdrawResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Received", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Received.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:])