diff --git a/app/app.go b/app/app.go
index 7c0bf157..9843e066 100644
--- a/app/app.go
+++ b/app/app.go
@@ -125,6 +125,9 @@ import (
kavadistclient "github.com/kava-labs/kava/x/kavadist/client"
kavadistkeeper "github.com/kava-labs/kava/x/kavadist/keeper"
kavadisttypes "github.com/kava-labs/kava/x/kavadist/types"
+ "github.com/kava-labs/kava/x/liquid"
+ liquidkeeper "github.com/kava-labs/kava/x/liquid/keeper"
+ liquidtypes "github.com/kava-labs/kava/x/liquid/types"
pricefeed "github.com/kava-labs/kava/x/pricefeed"
pricefeedkeeper "github.com/kava-labs/kava/x/pricefeed/keeper"
pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
@@ -190,6 +193,7 @@ var (
savings.AppModuleBasic{},
validatorvesting.AppModuleBasic{},
evmutil.AppModuleBasic{},
+ liquid.AppModuleBasic{},
earn.AppModuleBasic{},
)
@@ -215,12 +219,12 @@ var (
cdptypes.LiquidatorMacc: {authtypes.Minter, authtypes.Burner},
hardtypes.ModuleAccountName: {authtypes.Minter},
savingstypes.ModuleAccountName: nil,
- earntypes.ModuleName: nil,
+ liquidtypes.ModuleAccountName: {authtypes.Minter, authtypes.Burner},
+ earntypes.ModuleAccountName: nil,
}
)
// Verify app interface at compile time
-// var _ simapp.App = (*App)(nil) // TODO
var _ servertypes.Application = (*App)(nil)
// Options bundles several configuration params for an App.
@@ -285,6 +289,7 @@ type App struct {
committeeKeeper committeekeeper.Keeper
incentiveKeeper incentivekeeper.Keeper
savingsKeeper savingskeeper.Keeper
+ liquidKeeper liquidkeeper.Keeper
earnKeeper earnkeeper.Keeper
// make scoped keepers public for test purposes
@@ -586,6 +591,12 @@ func NewApp(
app.accountKeeper,
app.bankKeeper,
)
+ app.liquidKeeper = liquidkeeper.NewDefaultKeeper(
+ appCodec,
+ app.accountKeeper,
+ app.bankKeeper,
+ &app.stakingKeeper,
+ )
app.incentiveKeeper = incentivekeeper.NewKeeper(
appCodec,
keys[incentivetypes.StoreKey],
@@ -691,6 +702,7 @@ func NewApp(
incentive.NewAppModule(app.incentiveKeeper, app.accountKeeper, app.bankKeeper, app.cdpKeeper),
evmutil.NewAppModule(app.evmutilKeeper, app.bankKeeper),
savings.NewAppModule(app.savingsKeeper, app.accountKeeper, app.bankKeeper),
+ liquid.NewAppModule(app.liquidKeeper),
earn.NewAppModule(app.earnKeeper, app.accountKeeper, app.bankKeeper),
)
@@ -738,6 +750,7 @@ func NewApp(
authz.ModuleName,
evmutiltypes.ModuleName,
savingstypes.ModuleName,
+ liquidtypes.ModuleName,
earntypes.ModuleName,
)
@@ -777,6 +790,7 @@ func NewApp(
authz.ModuleName,
evmutiltypes.ModuleName,
savingstypes.ModuleName,
+ liquidtypes.ModuleName,
earntypes.ModuleName,
)
@@ -816,6 +830,7 @@ func NewApp(
paramstypes.ModuleName,
upgradetypes.ModuleName,
validatorvestingtypes.ModuleName,
+ liquidtypes.ModuleName,
)
app.mm.RegisterInvariants(&app.crisisKeeper)
@@ -979,10 +994,11 @@ func (app *App) loadBlockedMaccAddrs() map[string]bool {
modAccAddrs := app.ModuleAccountAddrs()
kavadistMaccAddr := app.accountKeeper.GetModuleAddress(kavadisttypes.ModuleName)
earnMaccAddr := app.accountKeeper.GetModuleAddress(earntypes.ModuleName)
+ liquidMaccAddr := app.accountKeeper.GetModuleAddress(liquidtypes.ModuleName)
for addr := range modAccAddrs {
// Set the kavadist and earn module account address as unblocked
- if addr == kavadistMaccAddr.String() || addr == earnMaccAddr.String() {
+ if addr == kavadistMaccAddr.String() || addr == earnMaccAddr.String() || addr == liquidMaccAddr.String() {
modAccAddrs[addr] = false
}
}
diff --git a/app/test_common.go b/app/test_common.go
index 084ae182..ccb5455a 100644
--- a/app/test_common.go
+++ b/app/test_common.go
@@ -40,6 +40,7 @@ import (
incentivekeeper "github.com/kava-labs/kava/x/incentive/keeper"
issuancekeeper "github.com/kava-labs/kava/x/issuance/keeper"
kavadistkeeper "github.com/kava-labs/kava/x/kavadist/keeper"
+ liquidkeeper "github.com/kava-labs/kava/x/liquid/keeper"
pricefeedkeeper "github.com/kava-labs/kava/x/pricefeed/keeper"
savingskeeper "github.com/kava-labs/kava/x/savings/keeper"
swapkeeper "github.com/kava-labs/kava/x/swap/keeper"
@@ -109,6 +110,7 @@ func (tApp TestApp) GetEvmutilKeeper() evmutilkeeper.Keeper { return tApp.ev
func (tApp TestApp) GetEvmKeeper() *evmkeeper.Keeper { return tApp.evmKeeper }
func (tApp TestApp) GetSavingsKeeper() savingskeeper.Keeper { return tApp.savingsKeeper }
func (tApp TestApp) GetFeeMarketKeeper() feemarketkeeper.Keeper { return tApp.feeMarketKeeper }
+func (tApp TestApp) GetLiquidKeeper() liquidkeeper.Keeper { return tApp.liquidKeeper }
func (tApp TestApp) GetEarnKeeper() earnkeeper.Keeper { return tApp.earnKeeper }
// LegacyAmino returns the app's amino codec.
diff --git a/contrib/devnet/init-new-chain.sh b/contrib/devnet/init-new-chain.sh
index 20674282..58e29d20 100755
--- a/contrib/devnet/init-new-chain.sh
+++ b/contrib/devnet/init-new-chain.sh
@@ -35,6 +35,10 @@ sed -in-place='' 's/enable = false/enable = true/g' $DATA/config/app.toml
# Set evm tracer to json
sed -in-place='' 's/tracer = ""/tracer = "json"/g' $DATA/config/app.toml
+# Enable full error trace to be returned on tx failure
+sed -in-place='' '/iavl-cache-size/a\
+trace = true' $DATA/config/app.toml
+
# Set client chain id
sed -in-place='' 's/chain-id = ""/chain-id = "kavalocalnet_8888-1"/g' $DATA/config/client.toml
diff --git a/docs/core/proto-docs.md b/docs/core/proto-docs.md
index 3a7d4561..5ccc403c 100644
--- a/docs/core/proto-docs.md
+++ b/docs/core/proto-docs.md
@@ -385,6 +385,14 @@
- [Query](#kava.kavadist.v1beta1.Query)
+- [kava/liquid/v1beta1/tx.proto](#kava/liquid/v1beta1/tx.proto)
+ - [MsgBurnDerivative](#kava.liquid.v1beta1.MsgBurnDerivative)
+ - [MsgBurnDerivativeResponse](#kava.liquid.v1beta1.MsgBurnDerivativeResponse)
+ - [MsgMintDerivative](#kava.liquid.v1beta1.MsgMintDerivative)
+ - [MsgMintDerivativeResponse](#kava.liquid.v1beta1.MsgMintDerivativeResponse)
+
+ - [Msg](#kava.liquid.v1beta1.Msg)
+
- [kava/pricefeed/v1beta1/store.proto](#kava/pricefeed/v1beta1/store.proto)
- [CurrentPrice](#kava.pricefeed.v1beta1.CurrentPrice)
- [Market](#kava.pricefeed.v1beta1.Market)
@@ -5384,6 +5392,97 @@ Query defines the gRPC querier service.
+
+Top
+
+## kava/liquid/v1beta1/tx.proto
+
+
+
+
+
+### MsgBurnDerivative
+MsgBurnDerivative defines the Msg/BurnDerivative request type.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | sender is the owner of the derivatives to be converted |
+| `validator` | [string](#string) | | validator is the validator of the derivatives to be converted |
+| `amount` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | | amount is the quantity of derivatives to be converted |
+
+
+
+
+
+
+
+
+### MsgBurnDerivativeResponse
+MsgBurnDerivativeResponse defines the Msg/BurnDerivative response type.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `received` | [string](#string) | | received is the number of delegation shares sent to the sender |
+
+
+
+
+
+
+
+
+### MsgMintDerivative
+MsgMintDerivative defines the Msg/MintDerivative request type.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | sender is the owner of the delegation to be converted |
+| `validator` | [string](#string) | | validator is the validator of the delegation to be converted |
+| `amount` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | | amount is the quantity of staked assets to be converted |
+
+
+
+
+
+
+
+
+### MsgMintDerivativeResponse
+MsgMintDerivativeResponse defines the Msg/MintDerivative response type.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `received` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | | received is the amount of staking derivative minted and sent to the sender |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Msg
+Msg defines the liquid Msg service.
+
+| Method Name | Request Type | Response Type | Description | HTTP Verb | Endpoint |
+| ----------- | ------------ | ------------- | ------------| ------- | -------- |
+| `MintDerivative` | [MsgMintDerivative](#kava.liquid.v1beta1.MsgMintDerivative) | [MsgMintDerivativeResponse](#kava.liquid.v1beta1.MsgMintDerivativeResponse) | MintDerivative defines a method for converting a delegation into staking deriviatives. | |
+| `BurnDerivative` | [MsgBurnDerivative](#kava.liquid.v1beta1.MsgBurnDerivative) | [MsgBurnDerivativeResponse](#kava.liquid.v1beta1.MsgBurnDerivativeResponse) | BurnDerivative defines a method for converting staking deriviatives into a delegation. | |
+
+
+
+
+
Top
diff --git a/proto/kava/liquid/v1beta1/tx.proto b/proto/kava/liquid/v1beta1/tx.proto
new file mode 100644
index 00000000..da6925d2
--- /dev/null
+++ b/proto/kava/liquid/v1beta1/tx.proto
@@ -0,0 +1,54 @@
+syntax = "proto3";
+package kava.liquid.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "cosmos/base/v1beta1/coin.proto";
+import "cosmos_proto/cosmos.proto";
+
+option go_package = "github.com/kava-labs/kava/x/liquid/types";
+
+// Msg defines the liquid Msg service.
+service Msg {
+
+ // MintDerivative defines a method for converting a delegation into staking deriviatives.
+ rpc MintDerivative(MsgMintDerivative) returns (MsgMintDerivativeResponse);
+
+ // BurnDerivative defines a method for converting staking deriviatives into a delegation.
+ rpc BurnDerivative(MsgBurnDerivative) returns (MsgBurnDerivativeResponse);
+}
+
+// MsgMintDerivative defines the Msg/MintDerivative request type.
+message MsgMintDerivative {
+ // sender is the owner of the delegation to be converted
+ string sender = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+ // validator is the validator of the delegation to be converted
+ string validator = 2;
+ // amount is the quantity of staked assets to be converted
+ cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false];
+}
+
+// MsgMintDerivativeResponse defines the Msg/MintDerivative response type.
+message MsgMintDerivativeResponse {
+ // received is the amount of staking derivative minted and sent to the sender
+ cosmos.base.v1beta1.Coin received = 1 [(gogoproto.nullable) = false];
+}
+
+// MsgBurnDerivative defines the Msg/BurnDerivative request type.
+message MsgBurnDerivative {
+ // sender is the owner of the derivatives to be converted
+ string sender = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+ // validator is the validator of the derivatives to be converted
+ string validator = 2;
+ // amount is the quantity of derivatives to be converted
+ cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false];
+}
+
+// MsgBurnDerivativeResponse defines the Msg/BurnDerivative response type.
+message MsgBurnDerivativeResponse {
+ // received is the number of delegation shares sent to the sender
+ string received = 1 [
+ (cosmos_proto.scalar) = "cosmos.Dec",
+ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
+ (gogoproto.nullable) = false
+ ];
+}
\ No newline at end of file
diff --git a/x/liquid/client/cli/query.go b/x/liquid/client/cli/query.go
new file mode 100644
index 00000000..70054c2a
--- /dev/null
+++ b/x/liquid/client/cli/query.go
@@ -0,0 +1,31 @@
+package cli
+
+import (
+ "github.com/spf13/cobra"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/client/flags"
+
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+// GetQueryCmd returns the cli query commands for this module
+func GetQueryCmd() *cobra.Command {
+ liquidQueryCmd := &cobra.Command{
+ Use: types.ModuleName,
+ Short: "Querying commands for the liquid module",
+ DisableFlagParsing: true,
+ SuggestionsMinimumDistance: 2,
+ RunE: client.ValidateCmd,
+ }
+
+ cmds := []*cobra.Command{}
+
+ for _, cmd := range cmds {
+ flags.AddQueryFlagsToCmd(cmd)
+ }
+
+ liquidQueryCmd.AddCommand(cmds...)
+
+ return liquidQueryCmd
+}
diff --git a/x/liquid/client/cli/tx.go b/x/liquid/client/cli/tx.go
new file mode 100644
index 00000000..6ef2043f
--- /dev/null
+++ b/x/liquid/client/cli/tx.go
@@ -0,0 +1,122 @@
+package cli
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/spf13/cobra"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/client/flags"
+ "github.com/cosmos/cosmos-sdk/client/tx"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ "github.com/cosmos/cosmos-sdk/version"
+
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+// GetTxCmd returns the transaction commands for this module
+func GetTxCmd() *cobra.Command {
+ liquidTxCmd := &cobra.Command{
+ Use: types.ModuleName,
+ Short: "liquid transactions subcommands",
+ DisableFlagParsing: true,
+ SuggestionsMinimumDistance: 2,
+ RunE: client.ValidateCmd,
+ }
+
+ cmds := []*cobra.Command{
+ getCmdMintDerivative(),
+ getCmdBurnDerivative(),
+ }
+
+ for _, cmd := range cmds {
+ flags.AddTxFlagsToCmd(cmd)
+ }
+
+ liquidTxCmd.AddCommand(cmds...)
+
+ return liquidTxCmd
+}
+
+func getCmdMintDerivative() *cobra.Command {
+ return &cobra.Command{
+ Use: "mint [validator-addr] [amount]",
+ Short: "mints staking derivative from a delegation",
+ Long: "Mint removes a portion of a user's staking delegation and issues them validator specific staking derivative tokens.",
+ Args: cobra.ExactArgs(2),
+ Example: fmt.Sprintf(
+ `%s tx %s mint kavavaloper16lnfpgn6llvn4fstg5nfrljj6aaxyee9z59jqd 10000000ukava --from `, version.AppName, types.ModuleName,
+ ),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientTxContext(cmd)
+ if err != nil {
+ return err
+ }
+
+ valAddr, err := sdk.ValAddressFromBech32(args[0])
+ if err != nil {
+ return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, err.Error())
+ }
+
+ coin, err := sdk.ParseCoinNormalized(args[1])
+ if err != nil {
+ return err
+ }
+
+ msg := types.NewMsgMintDerivative(clientCtx.GetFromAddress(), valAddr, coin)
+ if err := msg.ValidateBasic(); err != nil {
+ return err
+ }
+ return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+ },
+ }
+}
+
+func getCmdBurnDerivative() *cobra.Command {
+ return &cobra.Command{
+ Use: "burn [amount]",
+ Short: "burns staking derivative to redeem a delegation",
+ Long: "Burn removes some staking derivative from a user's account and converts it back to a staking delegation.",
+ Example: fmt.Sprintf(
+ `%s tx %s burn 10000000bkava-kavavaloper16lnfpgn6llvn4fstg5nfrljj6aaxyee9z59jqd --from `, version.AppName, types.ModuleName,
+ ),
+ Args: cobra.ExactArgs(1),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientTxContext(cmd)
+ if err != nil {
+ return err
+ }
+
+ amount, err := sdk.ParseCoinNormalized(args[0])
+ if err != nil {
+ return err
+ }
+
+ valAddr, err := parseLiquidStakingTokenDenom(amount.Denom)
+ if err != nil {
+ return sdkerrors.Wrap(types.ErrInvalidDenom, err.Error())
+ }
+
+ msg := types.NewMsgBurnDerivative(clientCtx.GetFromAddress(), valAddr, amount)
+ if err := msg.ValidateBasic(); err != nil {
+ return err
+ }
+ return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+ },
+ }
+}
+
+// parseLiquidStakingTokenDenom extracts a validator address from a derivative denom.
+func parseLiquidStakingTokenDenom(denom string) (sdk.ValAddress, error) {
+ elements := strings.Split(denom, types.DenomSeparator)
+ if len(elements) != 2 {
+ return nil, fmt.Errorf("cannot parse denom %s", denom)
+ }
+ addr, err := sdk.ValAddressFromBech32(elements[1])
+ if err != nil {
+ return nil, err
+ }
+ return addr, nil
+}
diff --git a/x/liquid/keeper/derivative.go b/x/liquid/keeper/derivative.go
new file mode 100644
index 00000000..cac2b74b
--- /dev/null
+++ b/x/liquid/keeper/derivative.go
@@ -0,0 +1,118 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+// MintDerivative removes a user's staking delegation and mints them equivalent staking derivative coins.
+//
+// The input staking token amount is used to calculate shares in the user's delegation, which are transferred to a delegation owned by the module.
+// Derivative coins are them minted and transferred to the user.
+func (k Keeper) MintDerivative(ctx sdk.Context, delegatorAddr sdk.AccAddress, valAddr sdk.ValAddress, amount sdk.Coin) (sdk.Coin, error) {
+ bondDenom := k.stakingKeeper.BondDenom(ctx)
+ if amount.Denom != bondDenom {
+ return sdk.Coin{}, sdkerrors.Wrapf(types.ErrInvalidDenom, "expected %s", bondDenom)
+ }
+
+ derivativeAmount, shares, err := k.CalculateDerivativeSharesFromTokens(ctx, delegatorAddr, valAddr, amount.Amount)
+ if err != nil {
+ return sdk.Coin{}, err
+ }
+
+ // Fetching the module account will create it if it doesn't exist.
+ // This is necessary as otherwise TransferDelegation will create a normal account.
+ modAcc := k.accountKeeper.GetModuleAccount(ctx, types.ModuleAccountName)
+ if _, err := k.TransferDelegation(ctx, valAddr, delegatorAddr, modAcc.GetAddress(), shares); err != nil {
+ return sdk.Coin{}, err
+ }
+
+ liquidTokenDenom := k.GetLiquidStakingTokenDenom(valAddr)
+ liquidToken := sdk.NewCoin(liquidTokenDenom, derivativeAmount)
+ if err = k.mintCoins(ctx, delegatorAddr, sdk.NewCoins(liquidToken)); err != nil {
+ return sdk.Coin{}, err
+ }
+
+ ctx.EventManager().EmitEvent(
+ sdk.NewEvent(
+ types.EventTypeMintDerivative,
+ sdk.NewAttribute(types.AttributeKeyDelegator, delegatorAddr.String()),
+ sdk.NewAttribute(types.AttributeKeyValidator, valAddr.String()),
+ sdk.NewAttribute(sdk.AttributeKeyAmount, liquidToken.String()),
+ sdk.NewAttribute(types.AttributeKeySharesTransferred, shares.String()),
+ ),
+ )
+
+ return liquidToken, nil
+}
+
+// CalculateDerivativeSharesFromTokens converts a staking token amount into its equivalent delegation shares, and staking derivative amount.
+// This combines the code for calculating the shares to be transferred, and the derivative coins to be minted.
+func (k Keeper) CalculateDerivativeSharesFromTokens(ctx sdk.Context, delegator sdk.AccAddress, validator sdk.ValAddress, tokens sdk.Int) (sdk.Int, sdk.Dec, error) {
+ if !tokens.IsPositive() {
+ return sdk.Int{}, sdk.Dec{}, sdkerrors.Wrap(types.ErrUntransferableShares, "token amount must be positive")
+ }
+ shares, err := k.stakingKeeper.ValidateUnbondAmount(ctx, delegator, validator, tokens)
+ if err != nil {
+ return sdk.Int{}, sdk.Dec{}, err
+ }
+ return shares.TruncateInt(), shares, nil
+}
+
+// BurnDerivative burns an user's staking derivative coins and returns them an equivalent staking delegation.
+//
+// The derivative coins are burned, and an equivalent number of shares in the module's staking delegation are transferred back to the user.
+func (k Keeper) BurnDerivative(ctx sdk.Context, delegatorAddr sdk.AccAddress, valAddr sdk.ValAddress, amount sdk.Coin) (sdk.Dec, error) {
+
+ if amount.Denom != k.GetLiquidStakingTokenDenom(valAddr) {
+ return sdk.Dec{}, sdkerrors.Wrap(types.ErrInvalidDenom, "derivative denom does not match validator")
+ }
+
+ if err := k.burnCoins(ctx, delegatorAddr, sdk.NewCoins(amount)); err != nil {
+ return sdk.Dec{}, err
+ }
+
+ modAcc := k.accountKeeper.GetModuleAccount(ctx, types.ModuleAccountName)
+ shares := amount.Amount.ToDec()
+ receivedShares, err := k.TransferDelegation(ctx, valAddr, modAcc.GetAddress(), delegatorAddr, shares)
+ if err != nil {
+ return sdk.Dec{}, err
+ }
+
+ ctx.EventManager().EmitEvent(
+ sdk.NewEvent(
+ types.EventTypeBurnDerivative,
+ sdk.NewAttribute(types.AttributeKeyDelegator, delegatorAddr.String()),
+ sdk.NewAttribute(types.AttributeKeyValidator, valAddr.String()),
+ sdk.NewAttribute(sdk.AttributeKeyAmount, amount.String()),
+ sdk.NewAttribute(types.AttributeKeySharesTransferred, shares.String()),
+ ),
+ )
+ return receivedShares, nil
+}
+
+func (k Keeper) GetLiquidStakingTokenDenom(valAddr sdk.ValAddress) string {
+ return types.GetLiquidStakingTokenDenom(k.derivativeDenom, valAddr)
+}
+
+func (k Keeper) mintCoins(ctx sdk.Context, receiver sdk.AccAddress, amount sdk.Coins) error {
+ if err := k.bankKeeper.MintCoins(ctx, types.ModuleAccountName, amount); err != nil {
+ return err
+ }
+ if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleAccountName, receiver, amount); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (k Keeper) burnCoins(ctx sdk.Context, sender sdk.AccAddress, amount sdk.Coins) error {
+ if err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, sender, types.ModuleAccountName, amount); err != nil {
+ return err
+ }
+ if err := k.bankKeeper.BurnCoins(ctx, types.ModuleAccountName, amount); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/x/liquid/keeper/derivative_test.go b/x/liquid/keeper/derivative_test.go
new file mode 100644
index 00000000..f389b722
--- /dev/null
+++ b/x/liquid/keeper/derivative_test.go
@@ -0,0 +1,316 @@
+package keeper_test
+
+import (
+ "fmt"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+ "github.com/cosmos/cosmos-sdk/x/staking"
+ stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
+ "github.com/kava-labs/kava/app"
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+func (suite *KeeperTestSuite) TestBurnDerivative() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(5)
+ valAccAddr, user := addrs[0], addrs[1]
+ valAddr := sdk.ValAddress(valAccAddr)
+
+ liquidDenom := suite.Keeper.GetLiquidStakingTokenDenom(valAddr)
+
+ testCases := []struct {
+ name string
+ balance sdk.Coin
+ moduleDelegation sdk.Int
+ burnAmount sdk.Coin
+ expectedErr error
+ }{
+ {
+ name: "user can burn their entire balance",
+ balance: c(liquidDenom, 1e9),
+ moduleDelegation: i(1e9),
+ burnAmount: c(liquidDenom, 1e9),
+ },
+ {
+ name: "user can burn minimum derivative unit",
+ balance: c(liquidDenom, 1e9),
+ moduleDelegation: i(1e9),
+ burnAmount: c(liquidDenom, 1),
+ },
+ {
+ name: "error when denom cannot be parsed",
+ balance: c(liquidDenom, 1e9),
+ moduleDelegation: i(1e9),
+ burnAmount: c(fmt.Sprintf("ckava-%s", valAddr), 1e6),
+ expectedErr: types.ErrInvalidDenom,
+ },
+ {
+ name: "error when burn amount is 0",
+ balance: c(liquidDenom, 1e9),
+ moduleDelegation: i(1e9),
+ burnAmount: c(liquidDenom, 0),
+ expectedErr: types.ErrUntransferableShares,
+ },
+ {
+ name: "error when user doesn't have enough funds",
+ balance: c("ukava", 10),
+ moduleDelegation: i(1e9),
+ burnAmount: c(liquidDenom, 1e9),
+ expectedErr: sdkerrors.ErrInsufficientFunds,
+ },
+ {
+ name: "error when backing delegation isn't large enough",
+ balance: c(liquidDenom, 1e9),
+ moduleDelegation: i(999_999_999),
+ burnAmount: c(liquidDenom, 1e9),
+ expectedErr: stakingtypes.ErrNotEnoughDelegationShares,
+ },
+ }
+
+ for _, tc := range testCases {
+ suite.Run(tc.name, func() {
+ suite.SetupTest()
+
+ suite.CreateAccountWithAddress(valAccAddr, suite.NewBondCoins(i(1e6)))
+ suite.CreateAccountWithAddress(user, sdk.NewCoins(tc.balance))
+ suite.AddCoinsToModule(types.ModuleAccountName, suite.NewBondCoins(tc.moduleDelegation))
+
+ // create delegation from module account to back the derivatives
+ moduleAccAddress := authtypes.NewModuleAddress(types.ModuleAccountName)
+ suite.CreateNewUnbondedValidator(valAddr, i(1e6))
+ suite.CreateDelegation(valAddr, moduleAccAddress, tc.moduleDelegation)
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+ modBalance := suite.BankKeeper.GetAllBalances(suite.Ctx, moduleAccAddress)
+
+ _, err := suite.Keeper.BurnDerivative(suite.Ctx, user, valAddr, tc.burnAmount)
+
+ suite.Require().ErrorIs(err, tc.expectedErr)
+ if tc.expectedErr != nil {
+ // if an error is expected, state should be reverted so don't need to test state is unchanged
+ return
+ }
+
+ suite.AccountBalanceEqual(user, sdk.NewCoins(tc.balance.Sub(tc.burnAmount)))
+ suite.AccountBalanceEqual(moduleAccAddress, modBalance) // ensure derivatives are burned, and not in module account
+
+ sharesTransferred := tc.burnAmount.Amount.ToDec()
+ suite.DelegationSharesEqual(valAddr, user, sharesTransferred)
+ suite.DelegationSharesEqual(valAddr, moduleAccAddress, tc.moduleDelegation.ToDec().Sub(sharesTransferred))
+
+ suite.EventsContains(suite.Ctx.EventManager().Events(), sdk.NewEvent(
+ types.EventTypeBurnDerivative,
+ sdk.NewAttribute(types.AttributeKeyDelegator, user.String()),
+ sdk.NewAttribute(types.AttributeKeyValidator, valAddr.String()),
+ sdk.NewAttribute(sdk.AttributeKeyAmount, tc.burnAmount.String()),
+ sdk.NewAttribute(types.AttributeKeySharesTransferred, sharesTransferred.String()),
+ ))
+ })
+ }
+}
+
+func (suite *KeeperTestSuite) TestCalculateShares() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(5)
+ valAccAddr, delegator := addrs[0], addrs[1]
+ valAddr := sdk.ValAddress(valAccAddr)
+
+ type returns struct {
+ derivatives sdk.Int
+ shares sdk.Dec
+ err error
+ }
+ type validator struct {
+ tokens sdk.Int
+ delegatorShares sdk.Dec
+ }
+ testCases := []struct {
+ name string
+ validator *validator
+ delegation sdk.Dec
+ transfer sdk.Int
+ expected returns
+ }{
+ {
+ name: "error when validator not found",
+ validator: nil,
+ delegation: d("1000000000"),
+ transfer: i(500e6),
+ expected: returns{
+ err: stakingtypes.ErrNoValidatorFound,
+ },
+ },
+ {
+ name: "error when delegation not found",
+ validator: &validator{i(1e9), d("1000000000")},
+ delegation: sdk.Dec{},
+ transfer: i(500e6),
+ expected: returns{
+ err: stakingtypes.ErrNoDelegation,
+ },
+ },
+ {
+ name: "error when transfer < 0",
+ validator: &validator{i(10), d("10")},
+ delegation: d("10"),
+ transfer: i(-1),
+ expected: returns{
+ err: types.ErrUntransferableShares,
+ },
+ },
+ { // disallow zero transfers
+ name: "error when transfer = 0",
+ validator: &validator{i(10), d("10")},
+ delegation: d("10"),
+ transfer: i(0),
+ expected: returns{
+ err: types.ErrUntransferableShares,
+ },
+ },
+ {
+ name: "error when transfer > delegated shares",
+ validator: &validator{i(10), d("10")},
+ delegation: d("10"),
+ transfer: i(11),
+ expected: returns{
+ err: sdkerrors.ErrInvalidRequest,
+ },
+ },
+ {
+ name: "error when validator has no tokens",
+ validator: &validator{i(0), d("10")},
+ delegation: d("10"),
+ transfer: i(5),
+ expected: returns{
+ err: stakingtypes.ErrInsufficientShares,
+ },
+ },
+ {
+ name: "shares and derivatives are truncated",
+ validator: &validator{i(3), d("4")},
+ delegation: d("4"),
+ transfer: i(2),
+ expected: returns{
+ derivatives: i(2), // truncated down
+ shares: d("2.666666666666666666"), // 2/3 * 4 not rounded to ...667
+ },
+ },
+ {
+ name: "error if calculated shares > shares in delegation",
+ validator: &validator{i(3), d("4")},
+ delegation: d("2.666666666666666665"), // one less than 2/3 * 4
+ transfer: i(2),
+ expected: returns{
+ err: sdkerrors.ErrInvalidRequest,
+ },
+ },
+ }
+
+ for _, tc := range testCases {
+ suite.Run(tc.name, func() {
+ suite.SetupTest()
+
+ if tc.validator != nil {
+ suite.StakingKeeper.SetValidator(suite.Ctx, stakingtypes.Validator{
+ OperatorAddress: valAddr.String(),
+ Tokens: tc.validator.tokens,
+ DelegatorShares: tc.validator.delegatorShares,
+ })
+ }
+ if !tc.delegation.IsNil() {
+ suite.StakingKeeper.SetDelegation(suite.Ctx, stakingtypes.Delegation{
+ DelegatorAddress: delegator.String(),
+ ValidatorAddress: valAddr.String(),
+ Shares: tc.delegation,
+ })
+ }
+
+ derivatives, shares, err := suite.Keeper.CalculateDerivativeSharesFromTokens(suite.Ctx, delegator, valAddr, tc.transfer)
+ if tc.expected.err != nil {
+ suite.ErrorIs(err, tc.expected.err)
+ } else {
+ suite.NoError(err)
+ suite.Equal(tc.expected.derivatives, derivatives, "expected '%s' got '%s'", tc.expected.derivatives, derivatives)
+ suite.Equal(tc.expected.shares, shares)
+ }
+ })
+ }
+}
+
+func (suite *KeeperTestSuite) TestMintDerivative() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(5)
+ valAccAddr, delegator := addrs[0], addrs[1]
+ valAddr := sdk.ValAddress(valAccAddr)
+ moduleAccAddress := authtypes.NewModuleAddress(types.ModuleAccountName)
+
+ initialBalance := i(1e9)
+ vestedBalance := i(500e6)
+
+ testCases := []struct {
+ name string
+ amount sdk.Coin
+ expectedDerivatives sdk.Int
+ expectedSharesRemaining sdk.Dec
+ expectedSharesAdded sdk.Dec
+ expectedErr error
+ }{
+ {
+ name: "derivative is minted",
+ amount: suite.NewBondCoin(vestedBalance),
+ expectedDerivatives: i(500e6),
+ expectedSharesRemaining: d("500000000.0"),
+ expectedSharesAdded: d("500000000.0"),
+ },
+ {
+ name: "error when the input denom isn't correct",
+ amount: sdk.NewCoin("invalid", i(1000)),
+ expectedErr: types.ErrInvalidDenom,
+ },
+ {
+ name: "error when shares cannot be calculated",
+ amount: suite.NewBondCoin(initialBalance.Mul(i(100))),
+ expectedErr: sdkerrors.ErrInvalidRequest,
+ },
+ {
+ name: "error when shares cannot be transferred",
+ amount: suite.NewBondCoin(initialBalance), // trying to move vesting coins will fail in `TransferShares`
+ expectedErr: sdkerrors.ErrInsufficientFunds,
+ },
+ }
+
+ for _, tc := range testCases {
+ suite.Run(tc.name, func() {
+ suite.SetupTest()
+
+ suite.CreateAccountWithAddress(valAccAddr, suite.NewBondCoins(initialBalance))
+ suite.CreateVestingAccountWithAddress(delegator, suite.NewBondCoins(initialBalance), suite.NewBondCoins(vestedBalance))
+
+ suite.CreateNewUnbondedValidator(valAddr, initialBalance)
+ suite.CreateDelegation(valAddr, delegator, initialBalance)
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ _, err := suite.Keeper.MintDerivative(suite.Ctx, delegator, valAddr, tc.amount)
+
+ suite.Require().ErrorIs(err, tc.expectedErr)
+ if tc.expectedErr != nil {
+ // if an error is expected, state should be reverted so don't need to test state is unchanged
+ return
+ }
+
+ derivative := sdk.NewCoins(sdk.NewCoin(fmt.Sprintf("bkava-%s", valAddr), tc.expectedDerivatives))
+ suite.AccountBalanceEqual(delegator, derivative)
+
+ suite.DelegationSharesEqual(valAddr, delegator, tc.expectedSharesRemaining)
+ suite.DelegationSharesEqual(valAddr, moduleAccAddress, tc.expectedSharesAdded)
+
+ sharesTransferred := initialBalance.ToDec().Sub(tc.expectedSharesRemaining)
+ suite.EventsContains(suite.Ctx.EventManager().Events(), sdk.NewEvent(
+ types.EventTypeMintDerivative,
+ sdk.NewAttribute(types.AttributeKeyDelegator, delegator.String()),
+ sdk.NewAttribute(types.AttributeKeyValidator, valAddr.String()),
+ sdk.NewAttribute(sdk.AttributeKeyAmount, derivative.String()),
+ sdk.NewAttribute(types.AttributeKeySharesTransferred, sharesTransferred.String()),
+ ))
+ })
+ }
+}
diff --git a/x/liquid/keeper/keeper.go b/x/liquid/keeper/keeper.go
new file mode 100644
index 00000000..0756f38c
--- /dev/null
+++ b/x/liquid/keeper/keeper.go
@@ -0,0 +1,52 @@
+package keeper
+
+import (
+ "fmt"
+
+ "github.com/cosmos/cosmos-sdk/codec"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/tendermint/tendermint/libs/log"
+
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+// Keeper struct for the liquid module.
+type Keeper struct {
+ cdc codec.Codec
+
+ accountKeeper types.AccountKeeper
+ bankKeeper types.BankKeeper
+ stakingKeeper types.StakingKeeper
+
+ derivativeDenom string
+}
+
+// NewKeeper returns a new keeper for the liquid module.
+func NewKeeper(
+ cdc codec.Codec,
+ ak types.AccountKeeper, bk types.BankKeeper, sk types.StakingKeeper,
+ derivativeDenom string,
+) Keeper {
+
+ return Keeper{
+ cdc: cdc,
+ accountKeeper: ak,
+ bankKeeper: bk,
+ stakingKeeper: sk,
+ derivativeDenom: derivativeDenom,
+ }
+}
+
+// NewDefaultKeeper returns a new keeper for the liquid module with default values.
+func NewDefaultKeeper(
+ cdc codec.Codec,
+ ak types.AccountKeeper, bk types.BankKeeper, sk types.StakingKeeper,
+) Keeper {
+
+ return NewKeeper(cdc, ak, bk, sk, types.DefaultDerivativeDenom)
+}
+
+// Logger returns a module-specific logger.
+func (k Keeper) Logger(ctx sdk.Context) log.Logger {
+ return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
+}
diff --git a/x/liquid/keeper/keeper_test.go b/x/liquid/keeper/keeper_test.go
new file mode 100644
index 00000000..37a16a37
--- /dev/null
+++ b/x/liquid/keeper/keeper_test.go
@@ -0,0 +1,238 @@
+package keeper_test
+
+import (
+ "fmt"
+ "reflect"
+ "testing"
+
+ "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
+ "github.com/cosmos/cosmos-sdk/simapp"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+ vestingtypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"
+ bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+ stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
+ stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+ "github.com/stretchr/testify/suite"
+ abci "github.com/tendermint/tendermint/abci/types"
+ tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+ tmtime "github.com/tendermint/tendermint/types/time"
+
+ "github.com/kava-labs/kava/app"
+ "github.com/kava-labs/kava/x/liquid/keeper"
+)
+
+// Test suite used for all keeper tests
+type KeeperTestSuite struct {
+ suite.Suite
+ App app.TestApp
+ Ctx sdk.Context
+ Keeper keeper.Keeper
+ BankKeeper bankkeeper.Keeper
+ StakingKeeper stakingkeeper.Keeper
+}
+
+// The default state used by each test
+func (suite *KeeperTestSuite) SetupTest() {
+ tApp := app.NewTestApp()
+ ctx := tApp.NewContext(true, tmproto.Header{Height: 1, Time: tmtime.Now()})
+
+ tApp.InitializeFromGenesisStates()
+
+ suite.App = tApp
+ suite.Ctx = ctx
+ suite.Keeper = tApp.GetLiquidKeeper()
+ suite.StakingKeeper = tApp.GetStakingKeeper()
+ suite.BankKeeper = tApp.GetBankKeeper()
+}
+
+// CreateAccount creates a new account (with a fixed address) from the provided balance.
+func (suite *KeeperTestSuite) CreateAccount(initialBalance sdk.Coins) authtypes.AccountI {
+ _, addrs := app.GeneratePrivKeyAddressPairs(1)
+
+ return suite.CreateAccountWithAddress(addrs[0], initialBalance)
+}
+
+// CreateAccount creates a new account from the provided balance and address
+func (suite *KeeperTestSuite) CreateAccountWithAddress(addr sdk.AccAddress, initialBalance sdk.Coins) authtypes.AccountI {
+ ak := suite.App.GetAccountKeeper()
+
+ acc := ak.NewAccountWithAddress(suite.Ctx, addr)
+ ak.SetAccount(suite.Ctx, acc)
+
+ err := simapp.FundAccount(suite.BankKeeper, suite.Ctx, acc.GetAddress(), initialBalance)
+ suite.Require().NoError(err)
+
+ return acc
+}
+
+// CreateVestingAccount creates a new vesting account. `vestingBalance` should be a fraction of `initialBalance`.
+func (suite *KeeperTestSuite) CreateVestingAccountWithAddress(addr sdk.AccAddress, initialBalance sdk.Coins, vestingBalance sdk.Coins) authtypes.AccountI {
+ if vestingBalance.IsAnyGT(initialBalance) {
+ panic("vesting balance must be less than initial balance")
+ }
+ acc := suite.CreateAccountWithAddress(addr, initialBalance)
+ bacc := acc.(*authtypes.BaseAccount)
+
+ periods := vestingtypes.Periods{
+ vestingtypes.Period{
+ Length: 31556952,
+ Amount: vestingBalance,
+ },
+ }
+ vacc := vestingtypes.NewPeriodicVestingAccount(bacc, vestingBalance, suite.Ctx.BlockTime().Unix(), periods)
+ suite.App.GetAccountKeeper().SetAccount(suite.Ctx, vacc)
+ return vacc
+}
+
+// AddCoinsToModule adds coins to the a module account, creating it if it doesn't exist.
+func (suite *KeeperTestSuite) AddCoinsToModule(module string, amount sdk.Coins) {
+ err := simapp.FundModuleAccount(suite.BankKeeper, suite.Ctx, module, amount)
+ suite.Require().NoError(err)
+}
+
+// AccountBalanceEqual checks if an account has the specified coins.
+func (suite *KeeperTestSuite) AccountBalanceEqual(addr sdk.AccAddress, coins sdk.Coins) {
+ balance := suite.BankKeeper.GetAllBalances(suite.Ctx, addr)
+ suite.Equalf(coins, balance, "expected account balance to equal coins %s, but got %s", coins, balance)
+}
+
+func (suite *KeeperTestSuite) deliverMsgCreateValidator(ctx sdk.Context, address sdk.ValAddress, selfDelegation sdk.Coin) error {
+ msg, err := stakingtypes.NewMsgCreateValidator(
+ address,
+ ed25519.GenPrivKey().PubKey(),
+ selfDelegation,
+ stakingtypes.Description{},
+ stakingtypes.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
+ sdk.NewInt(1e6),
+ )
+ if err != nil {
+ return err
+ }
+
+ msgServer := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
+ _, err = msgServer.CreateValidator(sdk.WrapSDKContext(suite.Ctx), msg)
+ return err
+}
+
+// NewBondCoin creates a Coin with the current staking denom.
+func (suite *KeeperTestSuite) NewBondCoin(amount sdk.Int) sdk.Coin {
+ stakingDenom := suite.StakingKeeper.BondDenom(suite.Ctx)
+ return sdk.NewCoin(stakingDenom, amount)
+}
+
+// NewBondCoins creates Coins with the current staking denom.
+func (suite *KeeperTestSuite) NewBondCoins(amount sdk.Int) sdk.Coins {
+ return sdk.NewCoins(suite.NewBondCoin(amount))
+}
+
+// CreateNewUnbondedValidator creates a new validator in the staking module.
+// New validators are unbonded until the end blocker is run.
+func (suite *KeeperTestSuite) CreateNewUnbondedValidator(addr sdk.ValAddress, selfDelegation sdk.Int) stakingtypes.Validator {
+ // Create a validator
+ err := suite.deliverMsgCreateValidator(suite.Ctx, addr, suite.NewBondCoin(selfDelegation))
+ suite.Require().NoError(err)
+
+ // New validators are created in an unbonded state. Note if the end blocker is run later this validator could become bonded.
+
+ validator, found := suite.StakingKeeper.GetValidator(suite.Ctx, addr)
+ suite.Require().True(found)
+ return validator
+}
+
+// SlashValidator burns tokens staked in a validator. new_tokens = old_tokens * (1-slashFraction)
+func (suite *KeeperTestSuite) SlashValidator(addr sdk.ValAddress, slashFraction sdk.Dec) {
+ validator, found := suite.StakingKeeper.GetValidator(suite.Ctx, addr)
+ suite.Require().True(found)
+ consAddr, err := validator.GetConsAddr()
+ suite.Require().NoError(err)
+
+ // Assume infraction was at current height. Note unbonding delegations and redelegations are only slashed if created after
+ // the infraction height so none will be slashed.
+ infractionHeight := suite.Ctx.BlockHeight()
+
+ power := suite.StakingKeeper.TokensToConsensusPower(suite.Ctx, validator.GetTokens())
+
+ suite.StakingKeeper.Slash(suite.Ctx, consAddr, infractionHeight, power, slashFraction)
+}
+
+// CreateDelegation delegates tokens to a validator.
+func (suite *KeeperTestSuite) CreateDelegation(valAddr sdk.ValAddress, delegator sdk.AccAddress, amount sdk.Int) sdk.Dec {
+ stakingDenom := suite.StakingKeeper.BondDenom(suite.Ctx)
+ msg := stakingtypes.NewMsgDelegate(
+ delegator,
+ valAddr,
+ sdk.NewCoin(stakingDenom, amount),
+ )
+
+ msgServer := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
+ _, err := msgServer.Delegate(sdk.WrapSDKContext(suite.Ctx), msg)
+ suite.Require().NoError(err)
+
+ del, found := suite.StakingKeeper.GetDelegation(suite.Ctx, delegator, valAddr)
+ suite.Require().True(found)
+ return del.Shares
+}
+
+// CreateRedelegation undelegates tokens from one validator and delegates to another.
+func (suite *KeeperTestSuite) CreateRedelegation(delegator sdk.AccAddress, fromValidator, toValidator sdk.ValAddress, amount sdk.Int) {
+ stakingDenom := suite.StakingKeeper.BondDenom(suite.Ctx)
+ msg := stakingtypes.NewMsgBeginRedelegate(
+ delegator,
+ fromValidator,
+ toValidator,
+ sdk.NewCoin(stakingDenom, amount),
+ )
+
+ msgServer := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
+ _, err := msgServer.BeginRedelegate(sdk.WrapSDKContext(suite.Ctx), msg)
+ suite.Require().NoError(err)
+}
+
+// DelegationSharesEqual checks if a delegation has the specified shares.
+// It expects delegations with zero shares to not be stored in state.
+func (suite *KeeperTestSuite) DelegationSharesEqual(valAddr sdk.ValAddress, delegator sdk.AccAddress, shares sdk.Dec) bool {
+ del, found := suite.StakingKeeper.GetDelegation(suite.Ctx, delegator, valAddr)
+
+ if shares.IsZero() {
+ return suite.Falsef(found, "expected delegator to not be found, got %s shares", del.Shares)
+ } else {
+ res := suite.True(found, "expected delegator to be found")
+ return res && suite.Truef(shares.Equal(del.Shares), "expected %s delegator shares but got %s", shares, del.Shares)
+ }
+}
+
+// EventsContains asserts that the expected event is in the provided events
+func (suite *KeeperTestSuite) EventsContains(events sdk.Events, expectedEvent sdk.Event) {
+ foundMatch := false
+ for _, event := range events {
+ if event.Type == expectedEvent.Type {
+ if reflect.DeepEqual(attrsToMap(expectedEvent.Attributes), attrsToMap(event.Attributes)) {
+ foundMatch = true
+ }
+ }
+ }
+
+ suite.True(foundMatch, fmt.Sprintf("event of type %s not found or did not match", expectedEvent.Type))
+}
+
+// EventsDoNotContainType asserts that the provided events do contain an event of a certain type.
+func (suite *KeeperTestSuite) EventsDoNotContainType(events sdk.Events, eventType string) {
+ for _, event := range events {
+ suite.Falsef(event.Type == eventType, "found unexpected event %s", eventType)
+ }
+}
+
+func attrsToMap(attrs []abci.EventAttribute) []sdk.Attribute {
+ out := []sdk.Attribute{}
+
+ for _, attr := range attrs {
+ out = append(out, sdk.NewAttribute(string(attr.Key), string(attr.Value)))
+ }
+
+ return out
+}
+
+func TestKeeperTestSuite(t *testing.T) {
+ suite.Run(t, new(KeeperTestSuite))
+}
diff --git a/x/liquid/keeper/msg_server.go b/x/liquid/keeper/msg_server.go
new file mode 100644
index 00000000..b09e6b4b
--- /dev/null
+++ b/x/liquid/keeper/msg_server.go
@@ -0,0 +1,84 @@
+package keeper
+
+import (
+ "context"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+type msgServer struct {
+ keeper Keeper
+}
+
+// NewMsgServerImpl returns an implementation of the liquid MsgServer interface
+// for the provided Keeper.
+func NewMsgServerImpl(keeper Keeper) types.MsgServer {
+ return &msgServer{keeper: keeper}
+}
+
+var _ types.MsgServer = msgServer{}
+
+// MintDerivative handles MintDerivative msgs.
+func (k msgServer) MintDerivative(goCtx context.Context, msg *types.MsgMintDerivative) (*types.MsgMintDerivativeResponse, error) {
+ ctx := sdk.UnwrapSDKContext(goCtx)
+
+ validator, err := sdk.ValAddressFromBech32(msg.Validator)
+ if err != nil {
+ return nil, err
+ }
+
+ sender, err := sdk.AccAddressFromBech32(msg.Sender)
+ if err != nil {
+ return nil, err
+ }
+
+ mintedDerivative, err := k.keeper.MintDerivative(ctx, sender, validator, msg.Amount)
+ if err != nil {
+ return nil, err
+ }
+
+ ctx.EventManager().EmitEvent(
+ sdk.NewEvent(
+ sdk.EventTypeMessage,
+ sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
+ sdk.NewAttribute(sdk.AttributeKeySender, msg.Sender),
+ ),
+ )
+
+ return &types.MsgMintDerivativeResponse{
+ Received: mintedDerivative,
+ }, nil
+}
+
+// BurnDerivative handles BurnDerivative msgs.
+func (k msgServer) BurnDerivative(goCtx context.Context, msg *types.MsgBurnDerivative) (*types.MsgBurnDerivativeResponse, error) {
+ ctx := sdk.UnwrapSDKContext(goCtx)
+
+ sender, err := sdk.AccAddressFromBech32(msg.Sender)
+ if err != nil {
+ return nil, err
+ }
+
+ validator, err := sdk.ValAddressFromBech32(msg.Validator)
+ if err != nil {
+ return nil, err
+ }
+
+ sharesReceived, err := k.keeper.BurnDerivative(ctx, sender, validator, msg.Amount)
+ if err != nil {
+ return nil, err
+ }
+
+ ctx.EventManager().EmitEvent(
+ sdk.NewEvent(
+ sdk.EventTypeMessage,
+ sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
+ sdk.NewAttribute(sdk.AttributeKeySender, msg.Sender),
+ ),
+ )
+ return &types.MsgBurnDerivativeResponse{
+ Received: sharesReceived,
+ }, nil
+}
diff --git a/x/liquid/keeper/staking.go b/x/liquid/keeper/staking.go
new file mode 100644
index 00000000..8c809518
--- /dev/null
+++ b/x/liquid/keeper/staking.go
@@ -0,0 +1,109 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+// TransferDelegation moves some delegation shares between addresses, while keeping the same validator.
+//
+// Internally shares are unbonded, tokens moved then bonded again. This limits only vested tokens from being transferred.
+// The sending delegation must not have any active redelegations.
+// A validator cannot reduce self delegated shares below its min self delegation.
+// Attempting to transfer zero shares will error.
+func (k Keeper) TransferDelegation(ctx sdk.Context, valAddr sdk.ValAddress, fromDelegator, toDelegator sdk.AccAddress, shares sdk.Dec) (sdk.Dec, error) {
+ // Redelegations link a delegation to it's previous validator so slashes are propagated to the new validator.
+ // If the delegation is transferred to a new owner, the redelegation object must be updated.
+ // For expediency all transfers with redelegations are blocked.
+ if k.stakingKeeper.HasReceivingRedelegation(ctx, fromDelegator, valAddr) {
+ return sdk.Dec{}, types.ErrRedelegationsNotCompleted
+ }
+
+ if shares.IsNil() || shares.LT(sdk.ZeroDec()) {
+ return sdk.Dec{}, sdkerrors.Wrap(types.ErrUntransferableShares, "nil or negative shares")
+ }
+ if shares.Equal(sdk.ZeroDec()) {
+ // Block 0 transfers to reduce edge cases.
+ return sdk.Dec{}, sdkerrors.Wrap(types.ErrUntransferableShares, "zero shares")
+ }
+
+ fromDelegation, found := k.stakingKeeper.GetDelegation(ctx, fromDelegator, valAddr)
+ if !found {
+ return sdk.Dec{}, types.ErrNoDelegatorForAddress
+ }
+ validator, found := k.stakingKeeper.GetValidator(ctx, valAddr)
+ if !found {
+ return sdk.Dec{}, types.ErrNoValidatorFound
+ }
+ // Prevent validators from reducing their self delegation below the min.
+ isValidatorOperator := fromDelegator.Equals(valAddr)
+ if isValidatorOperator {
+ if isBelowMinSelfDelegation(validator, fromDelegation.Shares.Sub(shares)) {
+ return sdk.Dec{}, types.ErrSelfDelegationBelowMinimum
+ }
+ }
+
+ returnAmount, err := k.fastUndelegate(ctx, valAddr, fromDelegator, shares)
+ if err != nil {
+ return sdk.Dec{}, err
+ }
+ returnCoins := sdk.NewCoins(sdk.NewCoin(k.stakingKeeper.BondDenom(ctx), returnAmount))
+
+ if err := k.bankKeeper.SendCoins(ctx, fromDelegator, toDelegator, returnCoins); err != nil {
+ return sdk.Dec{}, err
+ }
+ receivedShares, err := k.delegateFromAccount(ctx, valAddr, toDelegator, returnAmount)
+ if err != nil {
+ return sdk.Dec{}, err
+ }
+
+ return receivedShares, nil
+}
+
+// isBelowMinSelfDelegation check if the supplied shares, converted to tokens, are under the validator's min_self_delegation.
+func isBelowMinSelfDelegation(validator stakingtypes.ValidatorI, shares sdk.Dec) bool {
+ return validator.TokensFromShares(shares).TruncateInt().LT(validator.GetMinSelfDelegation())
+}
+
+// fastUndelegate undelegates shares from a validator skipping the unbonding period and not creating any unbonding delegations.
+func (k Keeper) fastUndelegate(ctx sdk.Context, valAddr sdk.ValAddress, delegator sdk.AccAddress, shares sdk.Dec) (sdk.Int, error) {
+ validator, found := k.stakingKeeper.GetValidator(ctx, valAddr)
+ if !found {
+ return sdk.Int{}, types.ErrNoDelegatorForAddress
+ }
+
+ returnAmount, err := k.stakingKeeper.Unbond(ctx, delegator, valAddr, shares)
+ if err != nil {
+ return sdk.Int{}, err
+ }
+ returnCoins := sdk.NewCoins(sdk.NewCoin(k.stakingKeeper.BondDenom(ctx), returnAmount))
+
+ // transfer the validator tokens to the not bonded pool
+ if validator.IsBonded() {
+ if err := k.bankKeeper.SendCoinsFromModuleToModule(ctx, stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, returnCoins); err != nil {
+ panic(err)
+ }
+ }
+
+ if err := k.bankKeeper.UndelegateCoinsFromModuleToAccount(ctx, stakingtypes.NotBondedPoolName, delegator, returnCoins); err != nil {
+ return sdk.Int{}, err
+ }
+ return returnAmount, nil
+}
+
+// delegateFromAccount delegates to a validator from an account (vs redelegating from an existing delegation)
+func (k Keeper) delegateFromAccount(ctx sdk.Context, valAddr sdk.ValAddress, delegator sdk.AccAddress, amount sdk.Int) (sdk.Dec, error) {
+ validator, found := k.stakingKeeper.GetValidator(ctx, valAddr)
+ if !found {
+ return sdk.Dec{}, types.ErrNoValidatorFound
+ }
+ // source tokens are from an account, so subtractAccount true and tokenSrc unbonded
+ newShares, err := k.stakingKeeper.Delegate(ctx, delegator, amount, stakingtypes.Unbonded, validator, true)
+ if err != nil {
+ return sdk.Dec{}, err
+ }
+ return newShares, nil
+}
diff --git a/x/liquid/keeper/staking_test.go b/x/liquid/keeper/staking_test.go
new file mode 100644
index 00000000..8ab495ee
--- /dev/null
+++ b/x/liquid/keeper/staking_test.go
@@ -0,0 +1,378 @@
+package keeper_test
+
+import (
+ "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+ "github.com/cosmos/cosmos-sdk/x/staking"
+ stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
+ stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
+ "github.com/kava-labs/kava/app"
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+var (
+ // d is an alias for sdk.MustNewDecFromStr
+ d = sdk.MustNewDecFromStr
+ // i is an alias for sdk.NewInt
+ i = sdk.NewInt
+ // c is an alias for sdk.NewInt64Coin
+ c = sdk.NewInt64Coin
+)
+
+func (suite *KeeperTestSuite) TestTransferDelegation_ValidatorStates() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(3)
+ valAccAddr, fromDelegator, toDelegator := addrs[0], addrs[1], addrs[2]
+ valAddr := sdk.ValAddress(valAccAddr)
+
+ initialBalance := i(1e9)
+
+ notBondedModAddr := authtypes.NewModuleAddress(stakingtypes.NotBondedPoolName)
+ bondedModAddr := authtypes.NewModuleAddress(stakingtypes.BondedPoolName)
+
+ testCases := []struct {
+ name string
+ createValidator func() (delegatorShares sdk.Dec, err error)
+ }{
+ {
+ name: "bonded validator",
+ createValidator: func() (sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, initialBalance)
+ delegatorShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+
+ // Run end blocker to update validator state to bonded.
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return delegatorShares, nil
+ },
+ },
+ {
+ name: "unbonded validator",
+ createValidator: func() (sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, initialBalance)
+ delegatorShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+
+ // Don't run end blocker, new validators are by default unbonded.
+ return delegatorShares, nil
+ },
+ },
+ {
+ name: "ubonding (jailed) validator",
+ createValidator: func() (sdk.Dec, error) {
+ val := suite.CreateNewUnbondedValidator(valAddr, initialBalance)
+ delegatorShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+
+ // Run end blocker to update validator state to bonded.
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ // Jail and run end blocker to transition validator to unbonding.
+ consAddr, err := val.GetConsAddr()
+ if err != nil {
+ return sdk.Dec{}, err
+ }
+ suite.StakingKeeper.Jail(suite.Ctx, consAddr)
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return delegatorShares, nil
+ },
+ },
+ }
+
+ for _, tc := range testCases {
+ suite.Run(tc.name, func() {
+ suite.SetupTest()
+
+ suite.CreateAccountWithAddress(valAccAddr, suite.NewBondCoins(i(1e9)))
+ suite.CreateAccountWithAddress(fromDelegator, suite.NewBondCoins(i(1e9)))
+
+ fromDelegationShares, err := tc.createValidator()
+ suite.Require().NoError(err)
+
+ validator, found := suite.StakingKeeper.GetValidator(suite.Ctx, valAddr)
+ suite.Require().True(found)
+ notBondedBalance := suite.BankKeeper.GetAllBalances(suite.Ctx, notBondedModAddr)
+ bondedBalance := suite.BankKeeper.GetAllBalances(suite.Ctx, bondedModAddr)
+
+ shares := d("1000")
+
+ _, err = suite.Keeper.TransferDelegation(suite.Ctx, valAddr, fromDelegator, toDelegator, shares)
+ suite.Require().NoError(err)
+
+ // Transferring a delegation should move shares, and leave the validator and pool balances the same.
+
+ suite.DelegationSharesEqual(valAddr, fromDelegator, fromDelegationShares.Sub(shares))
+ suite.DelegationSharesEqual(valAddr, toDelegator, shares) // also creates new delegation
+
+ validatorAfter, found := suite.StakingKeeper.GetValidator(suite.Ctx, valAddr)
+ suite.Require().True(found)
+ suite.Equal(validator.GetTokens(), validatorAfter.GetTokens())
+ suite.Equal(validator.GetDelegatorShares(), validatorAfter.GetDelegatorShares())
+ suite.Equal(validator.GetStatus(), validatorAfter.GetStatus())
+
+ suite.AccountBalanceEqual(notBondedModAddr, notBondedBalance)
+ suite.AccountBalanceEqual(bondedModAddr, bondedBalance)
+ })
+ }
+}
+
+func (suite *KeeperTestSuite) TestTransferDelegation_Shares() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(5)
+ valAccAddr, fromDelegator, toDelegator := addrs[0], addrs[1], addrs[2]
+ valAddr := sdk.ValAddress(valAccAddr)
+
+ initialBalance := i(1e12)
+
+ testCases := []struct {
+ name string
+ createDelegations func() (fromDelegatorShares, toDelegatorShares sdk.Dec, err error)
+ shares sdk.Dec
+ expectReceived sdk.Dec
+ expectedErr error
+ }{
+ {
+ name: "negative shares cannot be transferred",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+ // Run end blocker to update validator state to bonded.
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return fromDelegationShares, sdk.ZeroDec(), nil
+ },
+ shares: d("-1.0"),
+ expectedErr: types.ErrUntransferableShares,
+ },
+ {
+ name: "nil shares cannot be transferred",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return fromDelegationShares, sdk.ZeroDec(), nil
+ },
+ shares: sdk.Dec{},
+ expectedErr: types.ErrUntransferableShares,
+ },
+ {
+ name: "0 shares cannot be transferred",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+ toDelegationShares := suite.CreateDelegation(valAddr, toDelegator, i(2e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return fromDelegationShares, toDelegationShares, nil
+ },
+ shares: sdk.ZeroDec(),
+ expectedErr: types.ErrUntransferableShares,
+ },
+ {
+ name: "all shares can be transferred",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+ toDelegationShares := suite.CreateDelegation(valAddr, toDelegator, i(2e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return fromDelegationShares, toDelegationShares, nil
+ },
+ shares: d("1000000000.0"),
+ expectReceived: d("1000000000.0"),
+ },
+ {
+ name: "excess shares cannot be transferred",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return fromDelegationShares, sdk.ZeroDec(), nil
+ },
+ shares: d("1000000000.000000000000000001"),
+ expectedErr: stakingtypes.ErrNotEnoughDelegationShares,
+ },
+ {
+ name: "shares can be transferred to a non existent delegation",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return fromDelegationShares, sdk.ZeroDec(), nil
+ },
+ shares: d("500000000.0"),
+ expectReceived: d("500000000.0"),
+ },
+ {
+ name: "shares cannot be transferred from a non existent delegation",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ return sdk.ZeroDec(), sdk.ZeroDec(), nil
+ },
+ shares: d("500000000.0"),
+ expectedErr: types.ErrNoDelegatorForAddress,
+ },
+ {
+ name: "slashed validator shares can be transferred",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ suite.SlashValidator(valAddr, d("0.05"))
+
+ return fromDelegationShares, sdk.ZeroDec(), nil
+ },
+ shares: d("500000000.0"),
+ expectReceived: d("500000000.0"),
+ },
+ {
+ name: "zero shares received when transfer < 1 token",
+ createDelegations: func() (sdk.Dec, sdk.Dec, error) {
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(1e9))
+ toDelegationShares := suite.CreateDelegation(valAddr, toDelegator, i(1e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+ // make 1 share worth more than 1 token
+ suite.SlashValidator(valAddr, d("0.05"))
+
+ return fromDelegationShares, toDelegationShares, nil
+ },
+ shares: d("1.0"), // send 1 share (truncates to zero tokens)
+ expectReceived: d("0.0"),
+ },
+ }
+ for _, tc := range testCases {
+ suite.Run(tc.name, func() {
+ suite.SetupTest()
+
+ suite.CreateAccountWithAddress(valAccAddr, suite.NewBondCoins(initialBalance))
+ suite.CreateAccountWithAddress(fromDelegator, suite.NewBondCoins(initialBalance))
+ suite.CreateAccountWithAddress(toDelegator, suite.NewBondCoins(initialBalance))
+
+ fromDelegationShares, toDelegationShares, err := tc.createDelegations()
+ suite.Require().NoError(err)
+ validator, found := suite.StakingKeeper.GetValidator(suite.Ctx, valAddr)
+ suite.Require().True(found)
+
+ _, err = suite.Keeper.TransferDelegation(suite.Ctx, valAddr, fromDelegator, toDelegator, tc.shares)
+
+ if tc.expectedErr != nil {
+ suite.ErrorIs(err, tc.expectedErr)
+ return
+ }
+
+ suite.NoError(err)
+ suite.DelegationSharesEqual(valAddr, fromDelegator, fromDelegationShares.Sub(tc.shares))
+ suite.DelegationSharesEqual(valAddr, toDelegator, toDelegationShares.Add(tc.expectReceived))
+
+ validatorAfter, found := suite.StakingKeeper.GetValidator(suite.Ctx, valAddr)
+ suite.Require().True(found)
+ // total tokens should not change
+ suite.Equal(validator.GetTokens(), validatorAfter.GetTokens())
+ // but total shares can differ
+ suite.Equal(
+ validator.GetDelegatorShares().Sub(tc.shares).Add(tc.expectReceived),
+ validatorAfter.GetDelegatorShares(),
+ )
+ })
+ }
+}
+
+func (suite *KeeperTestSuite) TestTransferDelegation_RedelegationsForbidden() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(4)
+ val1AccAddr, val2AccAddr, fromDelegator, toDelegator := addrs[0], addrs[1], addrs[2], addrs[3]
+ val1Addr := sdk.ValAddress(val1AccAddr)
+ val2Addr := sdk.ValAddress(val2AccAddr)
+
+ initialBalance := i(1e12)
+
+ suite.CreateAccountWithAddress(val1AccAddr, suite.NewBondCoins(initialBalance))
+ suite.CreateAccountWithAddress(val2AccAddr, suite.NewBondCoins(initialBalance))
+ suite.CreateAccountWithAddress(fromDelegator, suite.NewBondCoins(initialBalance))
+
+ // create bonded validator 1 with a delegation
+ suite.CreateNewUnbondedValidator(val1Addr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(val1Addr, fromDelegator, i(1e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ // create validator 2 and redelegate to it
+ suite.CreateNewUnbondedValidator(val2Addr, i(1e9))
+ suite.CreateRedelegation(fromDelegator, val1Addr, val2Addr, i(1e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ _, err := suite.Keeper.TransferDelegation(suite.Ctx, val2Addr, fromDelegator, toDelegator, fromDelegationShares)
+ suite.ErrorIs(err, types.ErrRedelegationsNotCompleted)
+ suite.DelegationSharesEqual(val2Addr, fromDelegator, fromDelegationShares)
+ suite.DelegationSharesEqual(val2Addr, toDelegator, sdk.ZeroDec())
+}
+
+func (suite *KeeperTestSuite) TestTransferDelegation_CompliesWithMinSelfDelegation() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(4)
+ valAccAddr, toDelegator := addrs[0], addrs[1]
+ valAddr := sdk.ValAddress(valAccAddr)
+
+ suite.CreateAccountWithAddress(valAccAddr, suite.NewBondCoins(i(1e12)))
+
+ // create bonded validator with minimum delegated
+ minSelfDelegation := i(1e9)
+ delegation := suite.NewBondCoin(i(1e9))
+ msg, err := stakingtypes.NewMsgCreateValidator(
+ valAddr,
+ ed25519.GenPrivKey().PubKey(),
+ delegation,
+ stakingtypes.Description{},
+ stakingtypes.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
+ minSelfDelegation,
+ )
+ suite.Require().NoError(err)
+
+ msgServer := stakingkeeper.NewMsgServerImpl(suite.StakingKeeper)
+ _, err = msgServer.CreateValidator(sdk.WrapSDKContext(suite.Ctx), msg)
+ suite.Require().NoError(err)
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ _, err = suite.Keeper.TransferDelegation(suite.Ctx, valAddr, valAccAddr, toDelegator, d("0.000000000000000001"))
+ suite.ErrorIs(err, types.ErrSelfDelegationBelowMinimum)
+ suite.DelegationSharesEqual(valAddr, valAccAddr, delegation.Amount.ToDec())
+}
+
+func (suite *KeeperTestSuite) TestTransferDelegation_CanTransferVested() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(4)
+ valAccAddr, fromDelegator, toDelegator := addrs[0], addrs[1], addrs[2]
+ valAddr := sdk.ValAddress(valAccAddr)
+
+ suite.CreateAccountWithAddress(valAccAddr, suite.NewBondCoins(i(1e9)))
+ suite.CreateVestingAccountWithAddress(fromDelegator, suite.NewBondCoins(i(2e9)), suite.NewBondCoins(i(1e9)))
+
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ fromDelegationShares := suite.CreateDelegation(valAddr, fromDelegator, i(2e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ shares := d("1000000000.0")
+ _, err := suite.Keeper.TransferDelegation(suite.Ctx, valAddr, fromDelegator, toDelegator, shares)
+ suite.NoError(err)
+ suite.DelegationSharesEqual(valAddr, fromDelegator, fromDelegationShares.Sub(shares))
+ suite.DelegationSharesEqual(valAddr, toDelegator, shares)
+}
+
+func (suite *KeeperTestSuite) TestTransferDelegation_CannotTransferVesting() {
+ _, addrs := app.GeneratePrivKeyAddressPairs(4)
+ valAccAddr, fromDelegator, toDelegator := addrs[0], addrs[1], addrs[2]
+ valAddr := sdk.ValAddress(valAccAddr)
+
+ suite.CreateAccountWithAddress(valAccAddr, suite.NewBondCoins(i(1e9)))
+ suite.CreateVestingAccountWithAddress(fromDelegator, suite.NewBondCoins(i(2e9)), suite.NewBondCoins(i(1e9)))
+
+ suite.CreateNewUnbondedValidator(valAddr, i(1e9))
+ suite.CreateDelegation(valAddr, fromDelegator, i(2e9))
+ staking.EndBlocker(suite.Ctx, suite.StakingKeeper)
+
+ _, err := suite.Keeper.TransferDelegation(suite.Ctx, valAddr, fromDelegator, toDelegator, d("1000000001.0"))
+ suite.ErrorIs(err, sdkerrors.ErrInsufficientFunds)
+}
diff --git a/x/liquid/module.go b/x/liquid/module.go
new file mode 100644
index 00000000..a3756120
--- /dev/null
+++ b/x/liquid/module.go
@@ -0,0 +1,138 @@
+package liquid
+
+import (
+ "encoding/json"
+
+ "github.com/gorilla/mux"
+ "github.com/grpc-ecosystem/grpc-gateway/runtime"
+ "github.com/spf13/cobra"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/codec"
+ codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/cosmos/cosmos-sdk/types/module"
+
+ abci "github.com/tendermint/tendermint/abci/types"
+
+ "github.com/kava-labs/kava/x/liquid/client/cli"
+ "github.com/kava-labs/kava/x/liquid/keeper"
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+var (
+ _ module.AppModule = AppModule{}
+ _ module.AppModuleBasic = AppModuleBasic{}
+)
+
+// AppModuleBasic app module basics object
+type AppModuleBasic struct{}
+
+// Name get module name
+func (AppModuleBasic) Name() string {
+ return types.ModuleName
+}
+
+// RegisterLegacyAminoCodec register module codec
+func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+ types.RegisterLegacyAminoCodec(cdc)
+}
+
+// DefaultGenesis default genesis state
+func (AppModuleBasic) DefaultGenesis(_ codec.JSONCodec) json.RawMessage {
+ return []byte("{}")
+}
+
+// ValidateGenesis module validate genesis
+func (AppModuleBasic) ValidateGenesis(_ codec.JSONCodec, _ client.TxEncodingConfig, _ json.RawMessage) error {
+ return nil
+}
+
+// RegisterInterfaces implements InterfaceModule.RegisterInterfaces
+func (a AppModuleBasic) RegisterInterfaces(registry codectypes.InterfaceRegistry) {
+ types.RegisterInterfaces(registry)
+}
+
+// RegisterRESTRoutes registers REST routes for the module.
+func (a AppModuleBasic) RegisterRESTRoutes(_ client.Context, _ *mux.Router) {}
+
+// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the module.
+func (a AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) {}
+
+// GetTxCmd returns the root tx command for the module.
+func (AppModuleBasic) GetTxCmd() *cobra.Command {
+ return cli.GetTxCmd()
+}
+
+// GetQueryCmd returns no root query command for the module.
+func (AppModuleBasic) GetQueryCmd() *cobra.Command {
+ return cli.GetQueryCmd()
+}
+
+//____________________________________________________________________________
+
+// AppModule app module type
+type AppModule struct {
+ AppModuleBasic
+
+ keeper keeper.Keeper
+}
+
+// NewAppModule creates a new AppModule object
+func NewAppModule(keeper keeper.Keeper) AppModule {
+ return AppModule{
+ AppModuleBasic: AppModuleBasic{},
+ keeper: keeper,
+ }
+}
+
+// Name module name
+func (am AppModule) Name() string {
+ return am.AppModuleBasic.Name()
+}
+
+// RegisterInvariants register module invariants
+func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {}
+
+// Route module message route name
+func (am AppModule) Route() sdk.Route {
+ return sdk.Route{}
+}
+
+// QuerierRoute module querier route name
+func (AppModule) QuerierRoute() string {
+ return ""
+}
+
+// LegacyQuerierHandler returns no sdk.Querier.
+func (am AppModule) LegacyQuerierHandler(_ *codec.LegacyAmino) sdk.Querier {
+ return nil
+}
+
+// ConsensusVersion implements AppModule/ConsensusVersion.
+func (AppModule) ConsensusVersion() uint64 {
+ return 1
+}
+
+// RegisterServices registers module services.
+func (am AppModule) RegisterServices(cfg module.Configurator) {
+ types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper))
+}
+
+// InitGenesis module init-genesis
+func (am AppModule) InitGenesis(_ sdk.Context, _ codec.JSONCodec, _ json.RawMessage) []abci.ValidatorUpdate {
+ return []abci.ValidatorUpdate{}
+}
+
+// ExportGenesis module export genesis
+func (am AppModule) ExportGenesis(_ sdk.Context, cdc codec.JSONCodec) json.RawMessage {
+ return am.DefaultGenesis(cdc)
+}
+
+// BeginBlock module begin-block
+func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {}
+
+// EndBlock module end-block
+func (am AppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate {
+ return []abci.ValidatorUpdate{}
+}
diff --git a/x/liquid/types/codec.go b/x/liquid/types/codec.go
new file mode 100644
index 00000000..9a6a1599
--- /dev/null
+++ b/x/liquid/types/codec.go
@@ -0,0 +1,38 @@
+package types
+
+import (
+ "github.com/cosmos/cosmos-sdk/codec"
+ "github.com/cosmos/cosmos-sdk/codec/types"
+ "github.com/cosmos/cosmos-sdk/types/msgservice"
+
+ cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// RegisterLegacyAminoCodec registers all the necessary types and interfaces for the module.
+func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+ cdc.RegisterConcrete(&MsgMintDerivative{}, "liquid/MsgMintDerivative", nil)
+ cdc.RegisterConcrete(&MsgBurnDerivative{}, "liquid/MsgBurnDerivative", nil)
+}
+
+// RegisterInterfaces registers proto messages under their interfaces for unmarshalling,
+// in addition to registering the msg service for handling tx msgs.
+func RegisterInterfaces(registry types.InterfaceRegistry) {
+ registry.RegisterImplementations((*sdk.Msg)(nil),
+ &MsgMintDerivative{},
+ &MsgBurnDerivative{},
+ )
+
+ msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
+}
+
+var (
+ amino = codec.NewLegacyAmino()
+ ModuleCdc = codec.NewAminoCodec(amino)
+)
+
+func init() {
+ RegisterLegacyAminoCodec(amino)
+ cryptocodec.RegisterCrypto(amino)
+}
diff --git a/x/liquid/types/common_test.go b/x/liquid/types/common_test.go
new file mode 100644
index 00000000..e88e1d5e
--- /dev/null
+++ b/x/liquid/types/common_test.go
@@ -0,0 +1,13 @@
+package types_test
+
+import (
+ "os"
+ "testing"
+
+ "github.com/kava-labs/kava/app"
+)
+
+func TestMain(m *testing.M) {
+ app.SetSDKConfig()
+ os.Exit(m.Run())
+}
diff --git a/x/liquid/types/errors.go b/x/liquid/types/errors.go
new file mode 100644
index 00000000..e4d6652a
--- /dev/null
+++ b/x/liquid/types/errors.go
@@ -0,0 +1,15 @@
+package types
+
+import (
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+var (
+ ErrNoValidatorFound = sdkerrors.New(ModuleName, 2, "validator does not exist")
+ ErrNoDelegatorForAddress = sdkerrors.New(ModuleName, 3, "delegator does not contain delegation")
+ ErrInvalidDenom = sdkerrors.New(ModuleName, 4, "invalid denom")
+ ErrNotEnoughDelegationShares = sdkerrors.New(ModuleName, 5, "not enough delegation shares")
+ ErrRedelegationsNotCompleted = sdkerrors.New(ModuleName, 6, "active redelegations cannot be transferred")
+ ErrUntransferableShares = sdkerrors.New(ModuleName, 7, "shares cannot be transferred")
+ ErrSelfDelegationBelowMinimum = sdkerrors.Register(ModuleName, 8, "validator's self delegation must be greater than their minimum self delegation")
+)
diff --git a/x/liquid/types/events.go b/x/liquid/types/events.go
new file mode 100644
index 00000000..27658719
--- /dev/null
+++ b/x/liquid/types/events.go
@@ -0,0 +1,11 @@
+package types
+
+const (
+ EventTypeMintDerivative = "mint_derivative"
+ EventTypeBurnDerivative = "burn_derivative"
+
+ AttributeValueCategory = ModuleName
+ AttributeKeyDelegator = "delegator"
+ AttributeKeyValidator = "validator"
+ AttributeKeySharesTransferred = "shares_transferred"
+)
diff --git a/x/liquid/types/expected_keepers.go b/x/liquid/types/expected_keepers.go
new file mode 100644
index 00000000..c3d9ca8a
--- /dev/null
+++ b/x/liquid/types/expected_keepers.go
@@ -0,0 +1,46 @@
+package types
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+ "github.com/cosmos/cosmos-sdk/x/staking/types"
+ stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+// BankKeeper defines the expected bank keeper
+type BankKeeper interface {
+ SendCoinsFromModuleToModule(ctx sdk.Context, senderModule, recipientModule string, amt sdk.Coins) error
+ SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
+ SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
+ SendCoins(ctx sdk.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) error
+
+ MintCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
+ BurnCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
+ UndelegateCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
+}
+
+// AccountKeeper defines the expected keeper interface for interacting with account
+type AccountKeeper interface {
+ GetModuleAccount(ctx sdk.Context, name string) authtypes.ModuleAccountI
+}
+
+// StakingKeeper defines the expected keeper interface for interacting with staking
+type StakingKeeper interface {
+ BondDenom(ctx sdk.Context) (res string)
+
+ GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator stakingtypes.Validator, found bool)
+ GetDelegation(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (delegation types.Delegation, found bool)
+ HasReceivingRedelegation(ctx sdk.Context, delAddr sdk.AccAddress, valDstAddr sdk.ValAddress) bool
+
+ ValidateUnbondAmount(
+ ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt sdk.Int,
+ ) (shares sdk.Dec, err error)
+
+ Delegate(
+ ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Int, tokenSrc stakingtypes.BondStatus,
+ validator stakingtypes.Validator, subtractAccount bool,
+ ) (newShares sdk.Dec, err error)
+ Unbond(
+ ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, shares sdk.Dec,
+ ) (amount sdk.Int, err error)
+}
diff --git a/x/liquid/types/key.go b/x/liquid/types/key.go
new file mode 100644
index 00000000..ba3d9822
--- /dev/null
+++ b/x/liquid/types/key.go
@@ -0,0 +1,26 @@
+package types
+
+import (
+ "fmt"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+const (
+ // ModuleName The name that will be used throughout the module
+ ModuleName = "liquid"
+
+ // RouterKey Top level router key
+ RouterKey = ModuleName
+
+ // ModuleAccountName is the module account's name
+ ModuleAccountName = ModuleName
+
+ DefaultDerivativeDenom = "bkava"
+
+ DenomSeparator = "-"
+)
+
+func GetLiquidStakingTokenDenom(bondDenom string, valAddr sdk.ValAddress) string {
+ return fmt.Sprintf("%s%s%s", bondDenom, DenomSeparator, valAddr.String())
+}
diff --git a/x/liquid/types/msg.go b/x/liquid/types/msg.go
new file mode 100644
index 00000000..8b37ac22
--- /dev/null
+++ b/x/liquid/types/msg.go
@@ -0,0 +1,120 @@
+package types
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ "github.com/cosmos/cosmos-sdk/x/auth/legacy/legacytx"
+)
+
+const (
+ // TypeMsgMintDerivative represents the type string for MsgMintDerivative
+ TypeMsgMintDerivative = "mint_derivative"
+ // TypeMsgBurnDerivative represents the type string for MsgBurnDerivative
+ TypeMsgBurnDerivative = "burn_derivative"
+)
+
+// ensure Msg interface compliance at compile time
+var (
+ _ sdk.Msg = &MsgMintDerivative{}
+ _ legacytx.LegacyMsg = &MsgMintDerivative{}
+ _ sdk.Msg = &MsgBurnDerivative{}
+ _ legacytx.LegacyMsg = &MsgBurnDerivative{}
+)
+
+// NewMsgMintDerivative returns a new MsgMintDerivative
+func NewMsgMintDerivative(sender sdk.AccAddress, validator sdk.ValAddress, amount sdk.Coin) MsgMintDerivative {
+ return MsgMintDerivative{
+ Sender: sender.String(),
+ Validator: validator.String(),
+ Amount: amount,
+ }
+}
+
+// Route return the message type used for routing the message.
+func (msg MsgMintDerivative) Route() string { return RouterKey }
+
+// Type returns a human-readable string for the message, intended for utilization within tags.
+func (msg MsgMintDerivative) Type() string { return TypeMsgMintDerivative }
+
+// ValidateBasic does a simple validation check that doesn't require access to any other information.
+func (msg MsgMintDerivative) ValidateBasic() error {
+ _, err := sdk.AccAddressFromBech32(msg.Sender)
+ if err != nil {
+ return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, err.Error())
+ }
+
+ _, err = sdk.ValAddressFromBech32(msg.Validator)
+ if err != nil {
+ return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, err.Error())
+ }
+
+ if msg.Amount.IsNil() || !msg.Amount.IsValid() || msg.Amount.IsZero() {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "'%s'", msg.Amount)
+ }
+
+ return nil
+}
+
+// GetSignBytes gets the canonical byte representation of the Msg.
+func (msg MsgMintDerivative) GetSignBytes() []byte {
+ bz := ModuleCdc.MustMarshalJSON(&msg)
+ return sdk.MustSortJSON(bz)
+}
+
+// GetSigners returns the addresses of signers that must sign.
+func (msg MsgMintDerivative) GetSigners() []sdk.AccAddress {
+ sender, err := sdk.AccAddressFromBech32(msg.Sender)
+ if err != nil {
+ panic(err)
+ }
+ return []sdk.AccAddress{sender}
+}
+
+// NewMsgBurnDerivative returns a new MsgBurnDerivative
+func NewMsgBurnDerivative(sender sdk.AccAddress, validator sdk.ValAddress, amount sdk.Coin) MsgBurnDerivative {
+ return MsgBurnDerivative{
+ Sender: sender.String(),
+ Validator: validator.String(),
+ Amount: amount,
+ }
+}
+
+// Route return the message type used for routing the message.
+func (msg MsgBurnDerivative) Route() string { return RouterKey }
+
+// Type returns a human-readable string for the message, intended for utilization within tags.
+func (msg MsgBurnDerivative) Type() string { return TypeMsgBurnDerivative }
+
+// ValidateBasic does a simple validation check that doesn't require access to any other information.
+func (msg MsgBurnDerivative) ValidateBasic() error {
+ _, err := sdk.AccAddressFromBech32(msg.Sender)
+ if err != nil {
+ return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, err.Error())
+ }
+
+ _, err = sdk.ValAddressFromBech32(msg.Validator)
+ if err != nil {
+ return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, err.Error())
+ }
+
+ if msg.Amount.IsNil() || !msg.Amount.IsValid() || msg.Amount.IsZero() {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "'%s'", msg.Amount)
+ }
+
+ return nil
+}
+
+// GetSignBytes gets the canonical byte representation of the Msg.
+func (msg MsgBurnDerivative) GetSignBytes() []byte {
+ bz := ModuleCdc.MustMarshalJSON(&msg)
+ return sdk.MustSortJSON(bz)
+}
+
+// GetSigners returns the addresses of signers that must sign.
+func (msg MsgBurnDerivative) GetSigners() []sdk.AccAddress {
+ sender, err := sdk.AccAddressFromBech32(msg.Sender)
+ if err != nil {
+ panic(err)
+ }
+ return []sdk.AccAddress{sender}
+}
diff --git a/x/liquid/types/msg_test.go b/x/liquid/types/msg_test.go
new file mode 100644
index 00000000..1ca3cda8
--- /dev/null
+++ b/x/liquid/types/msg_test.go
@@ -0,0 +1,163 @@
+package types_test
+
+import (
+ fmt "fmt"
+ "testing"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "github.com/kava-labs/kava/x/liquid/types"
+)
+
+func TestMsgMintDerivative_Signing(t *testing.T) {
+ address := mustAccAddressFromBech32("kava1gepm4nwzz40gtpur93alv9f9wm5ht4l0hzzw9d")
+ validatorAddress := mustValAddressFromBech32("kavavaloper1ypjp0m04pyp73hwgtc0dgkx0e9rrydeckewa42")
+
+ msg := types.NewMsgMintDerivative(
+ address,
+ validatorAddress,
+ sdk.NewCoin("ukava", sdk.NewInt(1e9)),
+ )
+
+ // checking for the "type" field ensures the msg is registered on the amino codec
+ signBytes := []byte(
+ `{"type":"liquid/MsgMintDerivative","value":{"amount":{"amount":"1000000000","denom":"ukava"},"sender":"kava1gepm4nwzz40gtpur93alv9f9wm5ht4l0hzzw9d","validator":"kavavaloper1ypjp0m04pyp73hwgtc0dgkx0e9rrydeckewa42"}}`,
+ )
+
+ assert.Equal(t, []sdk.AccAddress{address}, msg.GetSigners())
+ assert.Equal(t, signBytes, msg.GetSignBytes())
+}
+
+func TestMsgBurnDerivative_Signing(t *testing.T) {
+ address := mustAccAddressFromBech32("kava1gepm4nwzz40gtpur93alv9f9wm5ht4l0hzzw9d")
+ validatorAddress := mustValAddressFromBech32("kavavaloper1ypjp0m04pyp73hwgtc0dgkx0e9rrydeckewa42")
+
+ msg := types.NewMsgBurnDerivative(
+ address,
+ validatorAddress,
+ sdk.NewCoin("bkava-kavavaloper1ypjp0m04pyp73hwgtc0dgkx0e9rrydeckewa42", sdk.NewInt(1e9)),
+ )
+
+ // checking for the "type" field ensures the msg is registered on the amino codec
+ signBytes := []byte(
+ `{"type":"liquid/MsgBurnDerivative","value":{"amount":{"amount":"1000000000","denom":"bkava-kavavaloper1ypjp0m04pyp73hwgtc0dgkx0e9rrydeckewa42"},"sender":"kava1gepm4nwzz40gtpur93alv9f9wm5ht4l0hzzw9d","validator":"kavavaloper1ypjp0m04pyp73hwgtc0dgkx0e9rrydeckewa42"}}`,
+ )
+
+ assert.Equal(t, []sdk.AccAddress{address}, msg.GetSigners())
+ assert.Equal(t, signBytes, msg.GetSignBytes())
+}
+
+func TestMsg_Validate(t *testing.T) {
+ validAddress := mustAccAddressFromBech32("kava1gepm4nwzz40gtpur93alv9f9wm5ht4l0hzzw9d")
+ validValidatorAddress := mustValAddressFromBech32("kavavaloper1ypjp0m04pyp73hwgtc0dgkx0e9rrydeckewa42")
+ validCoin := sdk.NewInt64Coin("ukava", 1e9)
+
+ type msgArgs struct {
+ sender string
+ validator string
+ amount sdk.Coin
+ }
+ tests := []struct {
+ name string
+ msgArgs msgArgs
+ expectedErr error
+ }{
+ {
+ name: "normal is valid",
+ msgArgs: msgArgs{
+ sender: validAddress.String(),
+ validator: validValidatorAddress.String(),
+ amount: validCoin,
+ },
+ },
+ {
+ name: "invalid sender",
+ msgArgs: msgArgs{
+ sender: "invalid",
+ validator: validValidatorAddress.String(),
+ amount: validCoin,
+ },
+ expectedErr: sdkerrors.ErrInvalidAddress,
+ },
+ {
+ name: "invalid short sender",
+ msgArgs: msgArgs{
+ sender: "kava1uexte6", // encoded zero length address
+ validator: validValidatorAddress.String(),
+ amount: validCoin,
+ },
+ expectedErr: sdkerrors.ErrInvalidAddress,
+ },
+ {
+ name: "invalid validator",
+ msgArgs: msgArgs{
+ sender: validAddress.String(),
+ validator: "invalid",
+ amount: validCoin,
+ },
+ expectedErr: sdkerrors.ErrInvalidAddress,
+ },
+ {
+ name: "invalid nil coin",
+ msgArgs: msgArgs{
+ sender: validAddress.String(),
+ validator: validValidatorAddress.String(),
+ amount: sdk.Coin{},
+ },
+ expectedErr: sdkerrors.ErrInvalidCoins,
+ },
+ {
+ name: "invalid zero coin",
+ msgArgs: msgArgs{
+ sender: validAddress.String(),
+ validator: validValidatorAddress.String(),
+ amount: sdk.NewInt64Coin("ukava", 0),
+ },
+ expectedErr: sdkerrors.ErrInvalidCoins,
+ },
+ }
+
+ for _, tc := range tests {
+ msgs := []sdk.Msg{
+ &types.MsgMintDerivative{
+ Sender: tc.msgArgs.sender,
+ Validator: tc.msgArgs.validator,
+ Amount: tc.msgArgs.amount,
+ },
+ &types.MsgBurnDerivative{
+ Sender: tc.msgArgs.sender,
+ Validator: tc.msgArgs.validator,
+ Amount: tc.msgArgs.amount,
+ },
+ }
+ for _, msg := range msgs {
+ t.Run(fmt.Sprintf("%s/%T", tc.name, msg), func(t *testing.T) {
+ err := msg.ValidateBasic()
+ if tc.expectedErr == nil {
+ require.NoError(t, err)
+ } else {
+ require.ErrorIs(t, err, tc.expectedErr, "expected error '%s' not found in actual '%s'", tc.expectedErr, err)
+ }
+ })
+ }
+ }
+}
+
+func mustAccAddressFromBech32(address string) sdk.AccAddress {
+ addr, err := sdk.AccAddressFromBech32(address)
+ if err != nil {
+ panic(err)
+ }
+ return addr
+}
+
+func mustValAddressFromBech32(address string) sdk.ValAddress {
+ addr, err := sdk.ValAddressFromBech32(address)
+ if err != nil {
+ panic(err)
+ }
+ return addr
+}
diff --git a/x/liquid/types/tx.pb.go b/x/liquid/types/tx.pb.go
new file mode 100644
index 00000000..42619710
--- /dev/null
+++ b/x/liquid/types/tx.pb.go
@@ -0,0 +1,1188 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: kava/liquid/v1beta1/tx.proto
+
+package types
+
+import (
+ context "context"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-proto"
+ github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+ types "github.com/cosmos/cosmos-sdk/types"
+ _ "github.com/gogo/protobuf/gogoproto"
+ grpc1 "github.com/gogo/protobuf/grpc"
+ proto "github.com/gogo/protobuf/proto"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+ io "io"
+ math "math"
+ math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// MsgMintDerivative defines the Msg/MintDerivative request type.
+type MsgMintDerivative struct {
+ // sender is the owner of the delegation to be converted
+ Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
+ // validator is the validator of the delegation to be converted
+ Validator string `protobuf:"bytes,2,opt,name=validator,proto3" json:"validator,omitempty"`
+ // amount is the quantity of staked assets to be converted
+ Amount types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"`
+}
+
+func (m *MsgMintDerivative) Reset() { *m = MsgMintDerivative{} }
+func (m *MsgMintDerivative) String() string { return proto.CompactTextString(m) }
+func (*MsgMintDerivative) ProtoMessage() {}
+func (*MsgMintDerivative) Descriptor() ([]byte, []int) {
+ return fileDescriptor_738981106e50f269, []int{0}
+}
+func (m *MsgMintDerivative) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgMintDerivative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgMintDerivative.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgMintDerivative) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgMintDerivative.Merge(m, src)
+}
+func (m *MsgMintDerivative) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgMintDerivative) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgMintDerivative.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgMintDerivative proto.InternalMessageInfo
+
+func (m *MsgMintDerivative) GetSender() string {
+ if m != nil {
+ return m.Sender
+ }
+ return ""
+}
+
+func (m *MsgMintDerivative) GetValidator() string {
+ if m != nil {
+ return m.Validator
+ }
+ return ""
+}
+
+func (m *MsgMintDerivative) GetAmount() types.Coin {
+ if m != nil {
+ return m.Amount
+ }
+ return types.Coin{}
+}
+
+// MsgMintDerivativeResponse defines the Msg/MintDerivative response type.
+type MsgMintDerivativeResponse struct {
+ // received is the amount of staking derivative minted and sent to the sender
+ Received types.Coin `protobuf:"bytes,1,opt,name=received,proto3" json:"received"`
+}
+
+func (m *MsgMintDerivativeResponse) Reset() { *m = MsgMintDerivativeResponse{} }
+func (m *MsgMintDerivativeResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgMintDerivativeResponse) ProtoMessage() {}
+func (*MsgMintDerivativeResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_738981106e50f269, []int{1}
+}
+func (m *MsgMintDerivativeResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgMintDerivativeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgMintDerivativeResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgMintDerivativeResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgMintDerivativeResponse.Merge(m, src)
+}
+func (m *MsgMintDerivativeResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgMintDerivativeResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgMintDerivativeResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgMintDerivativeResponse proto.InternalMessageInfo
+
+func (m *MsgMintDerivativeResponse) GetReceived() types.Coin {
+ if m != nil {
+ return m.Received
+ }
+ return types.Coin{}
+}
+
+// MsgBurnDerivative defines the Msg/BurnDerivative request type.
+type MsgBurnDerivative struct {
+ // sender is the owner of the derivatives to be converted
+ Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
+ // validator is the validator of the derivatives to be converted
+ Validator string `protobuf:"bytes,2,opt,name=validator,proto3" json:"validator,omitempty"`
+ // amount is the quantity of derivatives to be converted
+ Amount types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"`
+}
+
+func (m *MsgBurnDerivative) Reset() { *m = MsgBurnDerivative{} }
+func (m *MsgBurnDerivative) String() string { return proto.CompactTextString(m) }
+func (*MsgBurnDerivative) ProtoMessage() {}
+func (*MsgBurnDerivative) Descriptor() ([]byte, []int) {
+ return fileDescriptor_738981106e50f269, []int{2}
+}
+func (m *MsgBurnDerivative) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgBurnDerivative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgBurnDerivative.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgBurnDerivative) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgBurnDerivative.Merge(m, src)
+}
+func (m *MsgBurnDerivative) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgBurnDerivative) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgBurnDerivative.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgBurnDerivative proto.InternalMessageInfo
+
+func (m *MsgBurnDerivative) GetSender() string {
+ if m != nil {
+ return m.Sender
+ }
+ return ""
+}
+
+func (m *MsgBurnDerivative) GetValidator() string {
+ if m != nil {
+ return m.Validator
+ }
+ return ""
+}
+
+func (m *MsgBurnDerivative) GetAmount() types.Coin {
+ if m != nil {
+ return m.Amount
+ }
+ return types.Coin{}
+}
+
+// MsgBurnDerivativeResponse defines the Msg/BurnDerivative response type.
+type MsgBurnDerivativeResponse struct {
+ // received is the number of delegation shares sent to the sender
+ Received github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=received,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"received"`
+}
+
+func (m *MsgBurnDerivativeResponse) Reset() { *m = MsgBurnDerivativeResponse{} }
+func (m *MsgBurnDerivativeResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgBurnDerivativeResponse) ProtoMessage() {}
+func (*MsgBurnDerivativeResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_738981106e50f269, []int{3}
+}
+func (m *MsgBurnDerivativeResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgBurnDerivativeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgBurnDerivativeResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgBurnDerivativeResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgBurnDerivativeResponse.Merge(m, src)
+}
+func (m *MsgBurnDerivativeResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgBurnDerivativeResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgBurnDerivativeResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgBurnDerivativeResponse proto.InternalMessageInfo
+
+func init() {
+ proto.RegisterType((*MsgMintDerivative)(nil), "kava.liquid.v1beta1.MsgMintDerivative")
+ proto.RegisterType((*MsgMintDerivativeResponse)(nil), "kava.liquid.v1beta1.MsgMintDerivativeResponse")
+ proto.RegisterType((*MsgBurnDerivative)(nil), "kava.liquid.v1beta1.MsgBurnDerivative")
+ proto.RegisterType((*MsgBurnDerivativeResponse)(nil), "kava.liquid.v1beta1.MsgBurnDerivativeResponse")
+}
+
+func init() { proto.RegisterFile("kava/liquid/v1beta1/tx.proto", fileDescriptor_738981106e50f269) }
+
+var fileDescriptor_738981106e50f269 = []byte{
+ // 421 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x53, 0xbd, 0xae, 0xda, 0x30,
+ 0x18, 0x8d, 0x7b, 0x2b, 0x54, 0x5c, 0xe9, 0x4a, 0x4d, 0xef, 0x10, 0xd0, 0x55, 0x40, 0x0c, 0x88,
+ 0x25, 0x4e, 0xa1, 0x43, 0x87, 0x76, 0x69, 0xca, 0xca, 0x92, 0x2e, 0xa8, 0x4b, 0xe5, 0x24, 0x56,
+ 0xb0, 0x00, 0x9b, 0xda, 0x4e, 0x44, 0xdf, 0xa2, 0x0f, 0xd0, 0xc7, 0xe0, 0x21, 0x18, 0x11, 0x53,
+ 0xdb, 0x01, 0x55, 0xf0, 0x22, 0x55, 0x12, 0x13, 0xca, 0x9f, 0xc4, 0x78, 0xa7, 0x38, 0x3e, 0xe7,
+ 0x7c, 0x3e, 0xe7, 0xfb, 0x6c, 0xf8, 0x38, 0xc6, 0x29, 0x76, 0x27, 0xf4, 0x5b, 0x42, 0x23, 0x37,
+ 0xed, 0x06, 0x44, 0xe1, 0xae, 0xab, 0xe6, 0x68, 0x26, 0xb8, 0xe2, 0xe6, 0xeb, 0x0c, 0x45, 0x05,
+ 0x8a, 0x34, 0x5a, 0x7f, 0x88, 0x79, 0xcc, 0x73, 0xdc, 0xcd, 0x56, 0x05, 0xb5, 0x6e, 0x87, 0x5c,
+ 0x4e, 0xb9, 0x74, 0x03, 0x2c, 0x49, 0x59, 0x28, 0xe4, 0x94, 0x69, 0xbc, 0x56, 0xe0, 0x5f, 0x0b,
+ 0x61, 0xf1, 0x53, 0x40, 0xad, 0x9f, 0x00, 0xbe, 0x1a, 0xc8, 0x78, 0x40, 0x99, 0xea, 0x13, 0x41,
+ 0x53, 0xac, 0x68, 0x4a, 0xcc, 0x37, 0xb0, 0x22, 0x09, 0x8b, 0x88, 0xb0, 0x40, 0x13, 0x74, 0xaa,
+ 0x9e, 0xb5, 0x5e, 0x38, 0x0f, 0x5a, 0xf7, 0x31, 0x8a, 0x04, 0x91, 0xf2, 0xb3, 0x12, 0x94, 0xc5,
+ 0xbe, 0xe6, 0x99, 0x8f, 0xb0, 0x9a, 0xe2, 0x09, 0x8d, 0xb0, 0xe2, 0xc2, 0x7a, 0x96, 0x89, 0xfc,
+ 0xc3, 0x86, 0xf9, 0x0e, 0x56, 0xf0, 0x94, 0x27, 0x4c, 0x59, 0x77, 0x4d, 0xd0, 0x79, 0xd9, 0xab,
+ 0x21, 0x5d, 0x2c, 0x73, 0xbc, 0x0f, 0x87, 0x3e, 0x71, 0xca, 0xbc, 0xe7, 0xcb, 0x4d, 0xc3, 0xf0,
+ 0x35, 0xbd, 0x35, 0x84, 0xb5, 0x33, 0x77, 0x3e, 0x91, 0x33, 0xce, 0x24, 0x31, 0xdf, 0xc3, 0x17,
+ 0x82, 0x84, 0x84, 0xa6, 0x24, 0xca, 0x7d, 0xde, 0x50, 0xb7, 0x14, 0xec, 0x83, 0x7b, 0x89, 0x60,
+ 0x4f, 0x31, 0x78, 0x92, 0x07, 0x3f, 0x76, 0x57, 0x06, 0x1f, 0x9e, 0x04, 0xaf, 0x7a, 0x1f, 0x32,
+ 0xf1, 0x9f, 0x4d, 0xa3, 0x1d, 0x53, 0x35, 0x4a, 0x02, 0x14, 0xf2, 0xa9, 0x9e, 0xb3, 0xfe, 0x38,
+ 0x32, 0x1a, 0xbb, 0xea, 0xfb, 0x8c, 0x48, 0xd4, 0x27, 0xe1, 0x7a, 0xe1, 0x40, 0x6d, 0xa4, 0x4f,
+ 0xc2, 0x43, 0x57, 0x7a, 0xbf, 0x01, 0xbc, 0x1b, 0xc8, 0xd8, 0x1c, 0xc1, 0xfb, 0x93, 0x2b, 0xd1,
+ 0x46, 0x17, 0xee, 0x23, 0x3a, 0x1b, 0x4e, 0x1d, 0xdd, 0xc6, 0x2b, 0xb3, 0x8c, 0xe0, 0xfd, 0xc9,
+ 0x0c, 0xae, 0x9e, 0x74, 0xcc, 0xbb, 0x7e, 0xd2, 0xe5, 0xae, 0x79, 0xde, 0x72, 0x6b, 0x83, 0xd5,
+ 0xd6, 0x06, 0x7f, 0xb7, 0x36, 0xf8, 0xb1, 0xb3, 0x8d, 0xd5, 0xce, 0x36, 0x7e, 0xed, 0x6c, 0xe3,
+ 0x4b, 0xe7, 0xbf, 0xae, 0x65, 0x35, 0x9d, 0x09, 0x0e, 0x64, 0xbe, 0x72, 0xe7, 0xfb, 0xf7, 0x99,
+ 0xf7, 0x2e, 0xa8, 0xe4, 0xaf, 0xe6, 0xed, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0a, 0x25, 0x6e,
+ 0x57, 0xbb, 0x03, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// MsgClient is the client API for Msg service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type MsgClient interface {
+ // MintDerivative defines a method for converting a delegation into staking deriviatives.
+ MintDerivative(ctx context.Context, in *MsgMintDerivative, opts ...grpc.CallOption) (*MsgMintDerivativeResponse, error)
+ // BurnDerivative defines a method for converting staking deriviatives into a delegation.
+ BurnDerivative(ctx context.Context, in *MsgBurnDerivative, opts ...grpc.CallOption) (*MsgBurnDerivativeResponse, error)
+}
+
+type msgClient struct {
+ cc grpc1.ClientConn
+}
+
+func NewMsgClient(cc grpc1.ClientConn) MsgClient {
+ return &msgClient{cc}
+}
+
+func (c *msgClient) MintDerivative(ctx context.Context, in *MsgMintDerivative, opts ...grpc.CallOption) (*MsgMintDerivativeResponse, error) {
+ out := new(MsgMintDerivativeResponse)
+ err := c.cc.Invoke(ctx, "/kava.liquid.v1beta1.Msg/MintDerivative", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) BurnDerivative(ctx context.Context, in *MsgBurnDerivative, opts ...grpc.CallOption) (*MsgBurnDerivativeResponse, error) {
+ out := new(MsgBurnDerivativeResponse)
+ err := c.cc.Invoke(ctx, "/kava.liquid.v1beta1.Msg/BurnDerivative", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// MsgServer is the server API for Msg service.
+type MsgServer interface {
+ // MintDerivative defines a method for converting a delegation into staking deriviatives.
+ MintDerivative(context.Context, *MsgMintDerivative) (*MsgMintDerivativeResponse, error)
+ // BurnDerivative defines a method for converting staking deriviatives into a delegation.
+ BurnDerivative(context.Context, *MsgBurnDerivative) (*MsgBurnDerivativeResponse, error)
+}
+
+// UnimplementedMsgServer can be embedded to have forward compatible implementations.
+type UnimplementedMsgServer struct {
+}
+
+func (*UnimplementedMsgServer) MintDerivative(ctx context.Context, req *MsgMintDerivative) (*MsgMintDerivativeResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method MintDerivative not implemented")
+}
+func (*UnimplementedMsgServer) BurnDerivative(ctx context.Context, req *MsgBurnDerivative) (*MsgBurnDerivativeResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method BurnDerivative not implemented")
+}
+
+func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
+ s.RegisterService(&_Msg_serviceDesc, srv)
+}
+
+func _Msg_MintDerivative_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgMintDerivative)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).MintDerivative(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/kava.liquid.v1beta1.Msg/MintDerivative",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).MintDerivative(ctx, req.(*MsgMintDerivative))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_BurnDerivative_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgBurnDerivative)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).BurnDerivative(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/kava.liquid.v1beta1.Msg/BurnDerivative",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).BurnDerivative(ctx, req.(*MsgBurnDerivative))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _Msg_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "kava.liquid.v1beta1.Msg",
+ HandlerType: (*MsgServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "MintDerivative",
+ Handler: _Msg_MintDerivative_Handler,
+ },
+ {
+ MethodName: "BurnDerivative",
+ Handler: _Msg_BurnDerivative_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "kava/liquid/v1beta1/tx.proto",
+}
+
+func (m *MsgMintDerivative) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgMintDerivative) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgMintDerivative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ {
+ size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTx(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ if len(m.Validator) > 0 {
+ i -= len(m.Validator)
+ copy(dAtA[i:], m.Validator)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Validator)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Sender) > 0 {
+ i -= len(m.Sender)
+ copy(dAtA[i:], m.Sender)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgMintDerivativeResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgMintDerivativeResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgMintDerivativeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = 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
+}
+
+func (m *MsgBurnDerivative) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgBurnDerivative) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgBurnDerivative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ {
+ size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTx(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ if len(m.Validator) > 0 {
+ i -= len(m.Validator)
+ copy(dAtA[i:], m.Validator)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Validator)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Sender) > 0 {
+ i -= len(m.Sender)
+ copy(dAtA[i:], m.Sender)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgBurnDerivativeResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgBurnDerivativeResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgBurnDerivativeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ {
+ size := m.Received.Size()
+ i -= size
+ if _, err := m.Received.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ i = encodeVarintTx(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
+}
+
+func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
+ offset -= sovTx(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ dAtA[offset] = uint8(v)
+ return base
+}
+func (m *MsgMintDerivative) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Sender)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = len(m.Validator)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = m.Amount.Size()
+ n += 1 + l + sovTx(uint64(l))
+ return n
+}
+
+func (m *MsgMintDerivativeResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = m.Received.Size()
+ n += 1 + l + sovTx(uint64(l))
+ return n
+}
+
+func (m *MsgBurnDerivative) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Sender)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = len(m.Validator)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = m.Amount.Size()
+ n += 1 + l + sovTx(uint64(l))
+ return n
+}
+
+func (m *MsgBurnDerivativeResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = m.Received.Size()
+ n += 1 + l + sovTx(uint64(l))
+ return n
+}
+
+func sovTx(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTx(x uint64) (n int) {
+ return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *MsgMintDerivative) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgMintDerivative: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgMintDerivative: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Sender = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Validator = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgMintDerivativeResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgMintDerivativeResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgMintDerivativeResponse: 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:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgBurnDerivative) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgBurnDerivative: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgBurnDerivative: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Sender = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Validator = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgBurnDerivativeResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgBurnDerivativeResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgBurnDerivativeResponse: 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 stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ 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:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipTx(dAtA []byte) (n int, err error) {
+ l := len(dAtA)
+ iNdEx := 0
+ depth := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if dAtA[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ case 1:
+ iNdEx += 8
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if length < 0 {
+ return 0, ErrInvalidLengthTx
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupTx
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthTx
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowTx = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
+)