From 527f823bb70263be9b39367cc80ce42bef415131 Mon Sep 17 00:00:00 2001 From: Roman Date: Tue, 25 Oct 2022 00:51:03 -0500 Subject: [PATCH] feat(CL): CreatePosition and WithdrawPosition messages (#3139) * feat(CL): CreatePosition and WithdrawPosition messages * lint --- proto/osmosis/concentrated-liquidity/tx.proto | 78 + x/concentrated-liquidity/export_test.go | 6 + x/concentrated-liquidity/lp.go | 25 +- x/concentrated-liquidity/lp_test.go | 14 +- x/concentrated-liquidity/msg_server.go | 91 + x/concentrated-liquidity/types/events.go | 14 + x/concentrated-liquidity/types/tx.pb.go | 1524 +++++++++++++++++ 7 files changed, 1727 insertions(+), 25 deletions(-) create mode 100644 proto/osmosis/concentrated-liquidity/tx.proto create mode 100644 x/concentrated-liquidity/msg_server.go create mode 100644 x/concentrated-liquidity/types/events.go create mode 100644 x/concentrated-liquidity/types/tx.pb.go diff --git a/proto/osmosis/concentrated-liquidity/tx.proto b/proto/osmosis/concentrated-liquidity/tx.proto new file mode 100644 index 00000000000..1709cc6ea7f --- /dev/null +++ b/proto/osmosis/concentrated-liquidity/tx.proto @@ -0,0 +1,78 @@ +syntax = "proto3"; +package osmosis.concentratedliquidity.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/v1beta1/coin.proto"; + +option go_package = "github.com/osmosis-labs/osmosis/v12/x/concentrated-liquidity/types"; + +service Msg { + rpc CreatePosition(MsgCreatePosition) returns (MsgCreatePositionResponse); + rpc WithdrawPosition(MsgWithdrawPosition) + returns (MsgWithdrawPositionResponse); +} + +// ===================== MsgCreatePosition +message MsgCreatePosition { + uint64 pool_id = 1 [ (gogoproto.moretags) = "yaml:\"pool_id\"" ]; + string sender = 2 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + int64 lower_tick = 3 [ (gogoproto.moretags) = "yaml:\"lower_tick\"" ]; + int64 upper_tick = 4 [ (gogoproto.moretags) = "yaml:\"upper_tick\"" ]; + cosmos.base.v1beta1.Coin token_desired0 = 5 [ + (gogoproto.moretags) = "yaml:\"token_desired0\"", + (gogoproto.nullable) = false + ]; + cosmos.base.v1beta1.Coin token_desired1 = 6 [ + (gogoproto.moretags) = "yaml:\"token_desired1\"", + (gogoproto.nullable) = false + ]; + string token_min_amount0 = 7 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"token_min_amount0\"", + (gogoproto.nullable) = false + ]; + string token_min_amount1 = 8 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"token_min_amount1\"", + (gogoproto.nullable) = false + ]; +} + +message MsgCreatePositionResponse { + string amount0 = 1 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"amount0\"", + (gogoproto.nullable) = false + ]; + string amount1 = 2 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"amount1\"", + (gogoproto.nullable) = false + ]; +} + +// ===================== MsgWithdrawPosition +message MsgWithdrawPosition { + uint64 pool_id = 1 [ (gogoproto.moretags) = "yaml:\"pool_id\"" ]; + string sender = 2 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + int64 lower_tick = 3 [ (gogoproto.moretags) = "yaml:\"lower_tick\"" ]; + int64 upper_tick = 4 [ (gogoproto.moretags) = "yaml:\"upper_tick\"" ]; + string liquidity_amount = 5 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"liquidity_amount\"", + (gogoproto.nullable) = false + ]; +} + +message MsgWithdrawPositionResponse { + string amount0 = 1 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"amount0\"", + (gogoproto.nullable) = false + ]; + string amount1 = 2 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"amount1\"", + (gogoproto.nullable) = false + ]; +} diff --git a/x/concentrated-liquidity/export_test.go b/x/concentrated-liquidity/export_test.go index f52e111ddb8..4fc3983f614 100644 --- a/x/concentrated-liquidity/export_test.go +++ b/x/concentrated-liquidity/export_test.go @@ -1,6 +1,8 @@ package concentrated_liquidity import ( + sdk "github.com/cosmos/cosmos-sdk/types" + cltypes "github.com/osmosis-labs/osmosis/v12/x/concentrated-liquidity/types" ) @@ -8,3 +10,7 @@ import ( func OrderInitialPoolDenoms(denom0, denom1 string) (string, string, error) { return cltypes.OrderInitialPoolDenoms(denom0, denom1) } + +func (k Keeper) CreatePosition(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, amount0Desired, amount1Desired, amount0Min, amount1Min sdk.Int, lowerTick, upperTick int64) (amtDenom0, amtDenom1 sdk.Int, err error) { + return k.createPosition(ctx, poolId, owner, amount0Desired, amount1Desired, amount0Min, amount1Min, lowerTick, upperTick) +} diff --git a/x/concentrated-liquidity/lp.go b/x/concentrated-liquidity/lp.go index de37068922e..f63723c4c89 100644 --- a/x/concentrated-liquidity/lp.go +++ b/x/concentrated-liquidity/lp.go @@ -8,7 +8,10 @@ import ( types "github.com/osmosis-labs/osmosis/v12/x/concentrated-liquidity/types" ) -func (k Keeper) Mint(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, liquidityIn sdk.Dec, lowerTick, upperTick int64) (amtDenom0, amtDenom1 sdk.Int, err error) { +func (k Keeper) createPosition(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, amount0Desired, amount1Desired, amount0Min, amount1Min sdk.Int, lowerTick, upperTick int64) (amtDenom0, amtDenom1 sdk.Int, err error) { + // TODO: calculate from amounts given + liquidityIn := sdk.MustNewDecFromStr("1517.882323") + // ensure types.MinTick <= lowerTick < types.MaxTick // TODO (bez): Add unit tests. if lowerTick < types.MinTick || lowerTick >= types.MaxTick { @@ -58,22 +61,6 @@ func (k Keeper) Mint(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, liqui return amtDenom0, amtDenom1, nil } -func (k Keeper) JoinPoolNoSwap(ctx sdk.Context, tokensIn sdk.Coins, swapFee sdk.Dec) (numShares sdk.Int, err error) { - return sdk.Int{}, nil -} - -func (k Keeper) CalcJoinPoolShares(ctx sdk.Context, tokensIn sdk.Coins, swapFee sdk.Dec) (numShares sdk.Int, newLiquidity sdk.Coins, err error) { - return sdk.Int{}, sdk.Coins{}, nil -} - -func (k Keeper) CalcJoinPoolNoSwapShares(ctx sdk.Context, tokensIn sdk.Coins, swapFee sdk.Dec) (numShares sdk.Int, newLiquidity sdk.Coins, err error) { - return sdk.Int{}, sdk.Coins{}, nil -} - -func (k Keeper) ExitPool(ctx sdk.Context, numShares sdk.Int, exitFee sdk.Dec) (exitedCoins sdk.Coins, err error) { - return sdk.Coins{}, nil -} - -func (k Keeper) CalcExitPoolCoinsFromShares(ctx sdk.Context, numShares sdk.Int, exitFee sdk.Dec) (exitedCoins sdk.Coins, err error) { - return sdk.Coins{}, nil +func (k Keeper) withdrawPosition(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, lowerTick, upperTick int64, liquidityAmount sdk.Int) (amtDenom0, amtDenom1 sdk.Int, err error) { + panic("not implemented") } diff --git a/x/concentrated-liquidity/lp_test.go b/x/concentrated-liquidity/lp_test.go index 63b7dd64bd7..d782e11dbcb 100644 --- a/x/concentrated-liquidity/lp_test.go +++ b/x/concentrated-liquidity/lp_test.go @@ -4,7 +4,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" ) -func (s *KeeperTestSuite) TestMint() { +func (s *KeeperTestSuite) TestCreatePosition() { // testing params // current tick: 85176 // lower tick: 84222 @@ -17,22 +17,24 @@ func (s *KeeperTestSuite) TestMint() { currentTick := sdk.NewInt(85176) lowerTick := int64(84222) upperTick := int64(86129) - liquidity, err := sdk.NewDecFromStr("1517.882323") - s.Require().NoError(err) + // currentSqrtP, ok := sdk.NewIntFromString("70710678") currentSqrtP, err := sdk.NewDecFromStr("70.710678") s.Require().NoError(err) denom0 := "eth" denom1 := "usdc" + amount0Desired := sdk.OneInt() + amount1Desired := sdk.NewInt(5000) + s.SetupTest() s.App.ConcentratedLiquidityKeeper.CreateNewConcentratedLiquidityPool(s.Ctx, poolId, denom0, denom1, currentSqrtP, currentTick) - asset0, asset1, err := s.App.ConcentratedLiquidityKeeper.Mint(s.Ctx, poolId, s.TestAccs[0], liquidity, lowerTick, upperTick) + asset0, asset1, err := s.App.ConcentratedLiquidityKeeper.CreatePosition(s.Ctx, poolId, s.TestAccs[0], amount0Desired, amount1Desired, sdk.OneInt(), sdk.OneInt(), lowerTick, upperTick) s.Require().NoError(err) - s.Require().Equal(sdk.NewInt(1), asset0) - s.Require().Equal(sdk.NewInt(5000), asset1) + s.Require().Equal(amount0Desired, asset0) + s.Require().Equal(amount1Desired, asset1) // check position state // 1517 is from the liquidity originally provided diff --git a/x/concentrated-liquidity/msg_server.go b/x/concentrated-liquidity/msg_server.go new file mode 100644 index 00000000000..f7b646aef83 --- /dev/null +++ b/x/concentrated-liquidity/msg_server.go @@ -0,0 +1,91 @@ +package concentrated_liquidity + +import ( + "context" + "strconv" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/osmosis-labs/osmosis/v12/x/concentrated-liquidity/types" +) + +type msgServer struct { + keeper *Keeper +} + +func NewMsgServerImpl(keeper *Keeper) types.MsgServer { + return &msgServer{ + keeper: keeper, + } +} + +// TODO: spec and tests, including events +func (server msgServer) CreatePosition(goCtx context.Context, msg *types.MsgCreatePosition) (*types.MsgCreatePositionResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + sender, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + return nil, err + } + + actualAmount0, actualAmount1, err := server.keeper.createPosition(ctx, msg.PoolId, sender, msg.TokenDesired0.Amount, msg.TokenDesired1.Amount, msg.TokenMinAmount0, msg.TokenMinAmount1, msg.LowerTick, msg.UpperTick) + if err != nil { + return nil, err + } + + ctx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + sdk.EventTypeMessage, + sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), + sdk.NewAttribute(sdk.AttributeKeySender, msg.Sender), + ), + sdk.NewEvent( + types.TypeEvtWithdrawPosition, + sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), + sdk.NewAttribute(sdk.AttributeKeySender, msg.Sender), + sdk.NewAttribute(types.AttributeKeyPoolId, strconv.FormatUint(msg.PoolId, 10)), + sdk.NewAttribute(types.AttributeAmount0, actualAmount0.String()), + sdk.NewAttribute(types.AttributeAmount1, actualAmount1.String()), + sdk.NewAttribute(types.AttributeLowerTick, strconv.FormatInt(msg.LowerTick, 10)), + sdk.NewAttribute(types.AttributeUpperTick, strconv.FormatInt(msg.UpperTick, 10)), + ), + }) + + return &types.MsgCreatePositionResponse{Amount0: actualAmount0, Amount1: actualAmount1}, nil +} + +// TODO: spec and tests, including events +func (server msgServer) WithdrawPosition(goCtx context.Context, msg *types.MsgWithdrawPosition) (*types.MsgWithdrawPositionResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + sender, err := sdk.AccAddressFromBech32(msg.Sender) + if err != nil { + return nil, err + } + + amount0, amount1, err := server.keeper.withdrawPosition(ctx, msg.PoolId, sender, msg.LowerTick, msg.UpperTick, msg.LiquidityAmount) + if err != nil { + return nil, err + } + + ctx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + sdk.EventTypeMessage, + sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), + sdk.NewAttribute(sdk.AttributeKeySender, msg.Sender), + ), + sdk.NewEvent( + types.TypeEvtWithdrawPosition, + sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), + sdk.NewAttribute(sdk.AttributeKeySender, msg.Sender), + sdk.NewAttribute(types.AttributeKeyPoolId, strconv.FormatUint(msg.PoolId, 10)), + sdk.NewAttribute(types.AttributeLiquidity, msg.LiquidityAmount.String()), + sdk.NewAttribute(types.AttributeAmount0, amount0.String()), + sdk.NewAttribute(types.AttributeAmount1, amount1.String()), + sdk.NewAttribute(types.AttributeLowerTick, strconv.FormatInt(msg.LowerTick, 10)), + sdk.NewAttribute(types.AttributeUpperTick, strconv.FormatInt(msg.UpperTick, 10)), + ), + }) + + return &types.MsgWithdrawPositionResponse{Amount0: amount0, Amount1: amount1}, nil +} diff --git a/x/concentrated-liquidity/types/events.go b/x/concentrated-liquidity/types/events.go new file mode 100644 index 00000000000..d1b0f0dce6f --- /dev/null +++ b/x/concentrated-liquidity/types/events.go @@ -0,0 +1,14 @@ +package types + +const ( + TypeEvtCreatePosition = "create_position" + TypeEvtWithdrawPosition = "withdraw_position" + + AttributeValueCategory = ModuleName + AttributeKeyPoolId = "pool_id" + AttributeAmount0 = "amount0" + AttributeAmount1 = "amount1" + AttributeLiquidity = "liquidity" + AttributeLowerTick = "lower_tick" + AttributeUpperTick = "upper_tick" +) diff --git a/x/concentrated-liquidity/types/tx.pb.go b/x/concentrated-liquidity/types/tx.pb.go new file mode 100644 index 00000000000..e6e3b40469d --- /dev/null +++ b/x/concentrated-liquidity/types/tx.pb.go @@ -0,0 +1,1524 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: osmosis/concentrated-liquidity/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + 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 + +// ===================== MsgCreatePosition +type MsgCreatePosition struct { + PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"` + Sender string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` + LowerTick int64 `protobuf:"varint,3,opt,name=lower_tick,json=lowerTick,proto3" json:"lower_tick,omitempty" yaml:"lower_tick"` + UpperTick int64 `protobuf:"varint,4,opt,name=upper_tick,json=upperTick,proto3" json:"upper_tick,omitempty" yaml:"upper_tick"` + TokenDesired0 types.Coin `protobuf:"bytes,5,opt,name=token_desired0,json=tokenDesired0,proto3" json:"token_desired0" yaml:"token_desired0"` + TokenDesired1 types.Coin `protobuf:"bytes,6,opt,name=token_desired1,json=tokenDesired1,proto3" json:"token_desired1" yaml:"token_desired1"` + TokenMinAmount0 github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=token_min_amount0,json=tokenMinAmount0,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"token_min_amount0" yaml:"token_min_amount0"` + TokenMinAmount1 github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,8,opt,name=token_min_amount1,json=tokenMinAmount1,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"token_min_amount1" yaml:"token_min_amount1"` +} + +func (m *MsgCreatePosition) Reset() { *m = MsgCreatePosition{} } +func (m *MsgCreatePosition) String() string { return proto.CompactTextString(m) } +func (*MsgCreatePosition) ProtoMessage() {} +func (*MsgCreatePosition) Descriptor() ([]byte, []int) { + return fileDescriptor_1f1fff802923d7db, []int{0} +} +func (m *MsgCreatePosition) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCreatePosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCreatePosition.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 *MsgCreatePosition) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCreatePosition.Merge(m, src) +} +func (m *MsgCreatePosition) XXX_Size() int { + return m.Size() +} +func (m *MsgCreatePosition) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCreatePosition.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCreatePosition proto.InternalMessageInfo + +func (m *MsgCreatePosition) GetPoolId() uint64 { + if m != nil { + return m.PoolId + } + return 0 +} + +func (m *MsgCreatePosition) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + +func (m *MsgCreatePosition) GetLowerTick() int64 { + if m != nil { + return m.LowerTick + } + return 0 +} + +func (m *MsgCreatePosition) GetUpperTick() int64 { + if m != nil { + return m.UpperTick + } + return 0 +} + +func (m *MsgCreatePosition) GetTokenDesired0() types.Coin { + if m != nil { + return m.TokenDesired0 + } + return types.Coin{} +} + +func (m *MsgCreatePosition) GetTokenDesired1() types.Coin { + if m != nil { + return m.TokenDesired1 + } + return types.Coin{} +} + +type MsgCreatePositionResponse struct { + Amount0 github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=amount0,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount0" yaml:"amount0"` + Amount1 github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount1,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount1" yaml:"amount1"` +} + +func (m *MsgCreatePositionResponse) Reset() { *m = MsgCreatePositionResponse{} } +func (m *MsgCreatePositionResponse) String() string { return proto.CompactTextString(m) } +func (*MsgCreatePositionResponse) ProtoMessage() {} +func (*MsgCreatePositionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1f1fff802923d7db, []int{1} +} +func (m *MsgCreatePositionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCreatePositionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCreatePositionResponse.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 *MsgCreatePositionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCreatePositionResponse.Merge(m, src) +} +func (m *MsgCreatePositionResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgCreatePositionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCreatePositionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCreatePositionResponse proto.InternalMessageInfo + +// ===================== MsgWithdrawPosition +type MsgWithdrawPosition struct { + PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"` + Sender string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` + LowerTick int64 `protobuf:"varint,3,opt,name=lower_tick,json=lowerTick,proto3" json:"lower_tick,omitempty" yaml:"lower_tick"` + UpperTick int64 `protobuf:"varint,4,opt,name=upper_tick,json=upperTick,proto3" json:"upper_tick,omitempty" yaml:"upper_tick"` + LiquidityAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=liquidity_amount,json=liquidityAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"liquidity_amount" yaml:"liquidity_amount"` +} + +func (m *MsgWithdrawPosition) Reset() { *m = MsgWithdrawPosition{} } +func (m *MsgWithdrawPosition) String() string { return proto.CompactTextString(m) } +func (*MsgWithdrawPosition) ProtoMessage() {} +func (*MsgWithdrawPosition) Descriptor() ([]byte, []int) { + return fileDescriptor_1f1fff802923d7db, []int{2} +} +func (m *MsgWithdrawPosition) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgWithdrawPosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgWithdrawPosition.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 *MsgWithdrawPosition) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgWithdrawPosition.Merge(m, src) +} +func (m *MsgWithdrawPosition) XXX_Size() int { + return m.Size() +} +func (m *MsgWithdrawPosition) XXX_DiscardUnknown() { + xxx_messageInfo_MsgWithdrawPosition.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgWithdrawPosition proto.InternalMessageInfo + +func (m *MsgWithdrawPosition) GetPoolId() uint64 { + if m != nil { + return m.PoolId + } + return 0 +} + +func (m *MsgWithdrawPosition) GetSender() string { + if m != nil { + return m.Sender + } + return "" +} + +func (m *MsgWithdrawPosition) GetLowerTick() int64 { + if m != nil { + return m.LowerTick + } + return 0 +} + +func (m *MsgWithdrawPosition) GetUpperTick() int64 { + if m != nil { + return m.UpperTick + } + return 0 +} + +type MsgWithdrawPositionResponse struct { + Amount0 github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=amount0,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount0" yaml:"amount0"` + Amount1 github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount1,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount1" yaml:"amount1"` +} + +func (m *MsgWithdrawPositionResponse) Reset() { *m = MsgWithdrawPositionResponse{} } +func (m *MsgWithdrawPositionResponse) String() string { return proto.CompactTextString(m) } +func (*MsgWithdrawPositionResponse) ProtoMessage() {} +func (*MsgWithdrawPositionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1f1fff802923d7db, []int{3} +} +func (m *MsgWithdrawPositionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgWithdrawPositionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgWithdrawPositionResponse.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 *MsgWithdrawPositionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgWithdrawPositionResponse.Merge(m, src) +} +func (m *MsgWithdrawPositionResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgWithdrawPositionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgWithdrawPositionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgWithdrawPositionResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgCreatePosition)(nil), "osmosis.concentratedliquidity.v1beta1.MsgCreatePosition") + proto.RegisterType((*MsgCreatePositionResponse)(nil), "osmosis.concentratedliquidity.v1beta1.MsgCreatePositionResponse") + proto.RegisterType((*MsgWithdrawPosition)(nil), "osmosis.concentratedliquidity.v1beta1.MsgWithdrawPosition") + proto.RegisterType((*MsgWithdrawPositionResponse)(nil), "osmosis.concentratedliquidity.v1beta1.MsgWithdrawPositionResponse") +} + +func init() { + proto.RegisterFile("osmosis/concentrated-liquidity/tx.proto", fileDescriptor_1f1fff802923d7db) +} + +var fileDescriptor_1f1fff802923d7db = []byte{ + // 617 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x55, 0xdb, 0x6a, 0x13, 0x41, + 0x18, 0xce, 0xf4, 0x90, 0x9a, 0x91, 0x1e, 0xb2, 0x5a, 0xdc, 0x46, 0xdc, 0x0d, 0x03, 0x6a, 0x44, + 0xba, 0xdb, 0xa9, 0x5e, 0x48, 0xaf, 0xea, 0xd6, 0x9b, 0x0a, 0x01, 0x59, 0x04, 0xa1, 0x08, 0x61, + 0xb3, 0x3b, 0x6c, 0x87, 0x24, 0x33, 0xeb, 0xce, 0xa4, 0x87, 0x47, 0x10, 0xbc, 0x10, 0xdf, 0xc2, + 0x37, 0xe9, 0x9d, 0x05, 0x11, 0xc4, 0x8b, 0x45, 0x9a, 0x37, 0xc8, 0x13, 0xc8, 0x1e, 0x13, 0x93, + 0x0a, 0x3d, 0x78, 0xa3, 0x57, 0xd9, 0xf9, 0xe7, 0x3b, 0x4c, 0xbe, 0xf9, 0x67, 0x06, 0x3e, 0xe4, + 0xa2, 0xc7, 0x05, 0x15, 0xa6, 0xcb, 0x99, 0x4b, 0x98, 0x0c, 0x1d, 0x49, 0xbc, 0xf5, 0x2e, 0x7d, + 0xd7, 0xa7, 0x1e, 0x95, 0xc7, 0xa6, 0x3c, 0x32, 0x82, 0x90, 0x4b, 0xae, 0xdc, 0xcf, 0x80, 0xc6, + 0x38, 0xb0, 0xc0, 0x19, 0x07, 0xb8, 0x4d, 0xa4, 0x83, 0x6b, 0xb7, 0x7d, 0xee, 0xf3, 0x84, 0x61, + 0xc6, 0x5f, 0x29, 0xb9, 0xa6, 0xb9, 0x09, 0xdb, 0x6c, 0x3b, 0x82, 0x98, 0x19, 0xd4, 0x74, 0x39, + 0x65, 0xe9, 0x3c, 0x7a, 0x3f, 0x0f, 0xab, 0x4d, 0xe1, 0xef, 0x84, 0xc4, 0x91, 0xe4, 0x15, 0x17, + 0x54, 0x52, 0xce, 0x94, 0xc7, 0x70, 0x21, 0xe0, 0xbc, 0xdb, 0xa2, 0x9e, 0x0a, 0xea, 0xa0, 0x31, + 0x67, 0x29, 0xc3, 0x48, 0x5f, 0x3a, 0x76, 0x7a, 0xdd, 0x2d, 0x94, 0x4d, 0x20, 0xbb, 0x1c, 0x7f, + 0xed, 0x7a, 0xca, 0x23, 0x58, 0x16, 0x84, 0x79, 0x24, 0x54, 0x67, 0xea, 0xa0, 0x51, 0xb1, 0xaa, + 0xc3, 0x48, 0x5f, 0x4c, 0xb1, 0x69, 0x1d, 0xd9, 0x19, 0x40, 0x79, 0x0a, 0x61, 0x97, 0x1f, 0x92, + 0xb0, 0x25, 0xa9, 0xdb, 0x51, 0x67, 0xeb, 0xa0, 0x31, 0x6b, 0xad, 0x0e, 0x23, 0xbd, 0x9a, 0xc2, + 0x47, 0x73, 0xc8, 0xae, 0x24, 0x83, 0xd7, 0xd4, 0xed, 0xc4, 0xac, 0x7e, 0x10, 0xe4, 0xac, 0xb9, + 0x49, 0xd6, 0x68, 0x0e, 0xd9, 0x95, 0x64, 0x90, 0xb0, 0x5a, 0x70, 0x49, 0xf2, 0x0e, 0x61, 0x2d, + 0x8f, 0x08, 0x1a, 0x12, 0x6f, 0x43, 0x9d, 0xaf, 0x83, 0xc6, 0xcd, 0xcd, 0x35, 0x23, 0x8d, 0xc4, + 0x88, 0x23, 0xc9, 0xd3, 0x33, 0x76, 0x38, 0x65, 0xd6, 0xbd, 0x93, 0x48, 0x2f, 0x0d, 0x23, 0x7d, + 0x35, 0x15, 0xfe, 0x9d, 0x8e, 0xec, 0xc5, 0xa4, 0xf0, 0x22, 0x1b, 0x4f, 0x19, 0x60, 0xb5, 0x7c, + 0x1d, 0x03, 0x3c, 0x61, 0x80, 0x95, 0x03, 0x58, 0x4d, 0x11, 0x3d, 0xca, 0x5a, 0x4e, 0x8f, 0xf7, + 0x99, 0xdc, 0x50, 0x17, 0x92, 0x8c, 0x5f, 0xc6, 0x42, 0x3f, 0x22, 0xfd, 0x81, 0x4f, 0xe5, 0x7e, + 0xbf, 0x6d, 0xb8, 0xbc, 0x67, 0x66, 0x3b, 0x9d, 0xfe, 0xac, 0x0b, 0xaf, 0x63, 0xca, 0xe3, 0x80, + 0x08, 0x63, 0x97, 0xc9, 0x61, 0xa4, 0xab, 0xe3, 0x96, 0x63, 0x82, 0xc8, 0x5e, 0x4e, 0x6a, 0x4d, + 0xca, 0x9e, 0xa7, 0x95, 0xf3, 0x7c, 0xb1, 0x7a, 0xe3, 0xef, 0xfa, 0xe2, 0x29, 0x5f, 0x8c, 0xbe, + 0x02, 0xb8, 0x36, 0xd5, 0x8b, 0x36, 0x11, 0x01, 0x67, 0x82, 0x28, 0x7b, 0x70, 0x21, 0xcf, 0x00, + 0x24, 0x6b, 0xd9, 0xbe, 0xf4, 0x5a, 0xb2, 0x0e, 0x2e, 0xfe, 0x79, 0x2e, 0x38, 0xd2, 0xc6, 0x59, + 0x0f, 0x5f, 0x53, 0x1b, 0x17, 0xda, 0x18, 0x7d, 0x99, 0x81, 0xb7, 0x9a, 0xc2, 0x7f, 0x43, 0xe5, + 0xbe, 0x17, 0x3a, 0x87, 0xff, 0xd5, 0x19, 0x93, 0x70, 0xa5, 0xb8, 0x88, 0xb2, 0x8d, 0x4d, 0x4e, + 0x59, 0xc5, 0xda, 0xbd, 0x74, 0x80, 0x77, 0xb2, 0xf5, 0x4d, 0xe8, 0x21, 0x7b, 0xb9, 0x28, 0xa5, + 0x8d, 0x82, 0xbe, 0x01, 0x78, 0xf7, 0x9c, 0x44, 0xff, 0xf5, 0x4e, 0xd9, 0xfc, 0x3c, 0x03, 0x67, + 0x9b, 0xc2, 0x57, 0x3e, 0x00, 0xb8, 0x34, 0x71, 0x21, 0x3f, 0x33, 0x2e, 0xf4, 0x08, 0x18, 0x53, + 0xc7, 0xa7, 0xb6, 0x7d, 0x55, 0x66, 0x11, 0xe7, 0x27, 0x00, 0x57, 0xa6, 0xba, 0x77, 0xeb, 0xe2, + 0xb2, 0x93, 0xdc, 0x9a, 0x75, 0x75, 0x6e, 0xbe, 0x28, 0xeb, 0xed, 0xc9, 0x99, 0x06, 0x4e, 0xcf, + 0x34, 0xf0, 0xf3, 0x4c, 0x03, 0x1f, 0x07, 0x5a, 0xe9, 0x74, 0xa0, 0x95, 0xbe, 0x0f, 0xb4, 0xd2, + 0x9e, 0x35, 0xb6, 0x11, 0x99, 0xcf, 0x7a, 0xd7, 0x69, 0x8b, 0x7c, 0x60, 0x1e, 0xe0, 0x4d, 0xf3, + 0xe8, 0x8f, 0xaf, 0x6e, 0xbc, 0x51, 0xed, 0x72, 0xf2, 0x38, 0x3e, 0xf9, 0x15, 0x00, 0x00, 0xff, + 0xff, 0x58, 0x25, 0x88, 0x42, 0xa4, 0x07, 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 { + CreatePosition(ctx context.Context, in *MsgCreatePosition, opts ...grpc.CallOption) (*MsgCreatePositionResponse, error) + WithdrawPosition(ctx context.Context, in *MsgWithdrawPosition, opts ...grpc.CallOption) (*MsgWithdrawPositionResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) CreatePosition(ctx context.Context, in *MsgCreatePosition, opts ...grpc.CallOption) (*MsgCreatePositionResponse, error) { + out := new(MsgCreatePositionResponse) + err := c.cc.Invoke(ctx, "/osmosis.concentratedliquidity.v1beta1.Msg/CreatePosition", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) WithdrawPosition(ctx context.Context, in *MsgWithdrawPosition, opts ...grpc.CallOption) (*MsgWithdrawPositionResponse, error) { + out := new(MsgWithdrawPositionResponse) + err := c.cc.Invoke(ctx, "/osmosis.concentratedliquidity.v1beta1.Msg/WithdrawPosition", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + CreatePosition(context.Context, *MsgCreatePosition) (*MsgCreatePositionResponse, error) + WithdrawPosition(context.Context, *MsgWithdrawPosition) (*MsgWithdrawPositionResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) CreatePosition(ctx context.Context, req *MsgCreatePosition) (*MsgCreatePositionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreatePosition not implemented") +} +func (*UnimplementedMsgServer) WithdrawPosition(ctx context.Context, req *MsgWithdrawPosition) (*MsgWithdrawPositionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WithdrawPosition not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_CreatePosition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCreatePosition) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CreatePosition(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/osmosis.concentratedliquidity.v1beta1.Msg/CreatePosition", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CreatePosition(ctx, req.(*MsgCreatePosition)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_WithdrawPosition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgWithdrawPosition) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).WithdrawPosition(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/osmosis.concentratedliquidity.v1beta1.Msg/WithdrawPosition", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).WithdrawPosition(ctx, req.(*MsgWithdrawPosition)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "osmosis.concentratedliquidity.v1beta1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreatePosition", + Handler: _Msg_CreatePosition_Handler, + }, + { + MethodName: "WithdrawPosition", + Handler: _Msg_WithdrawPosition_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "osmosis/concentrated-liquidity/tx.proto", +} + +func (m *MsgCreatePosition) 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 *MsgCreatePosition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCreatePosition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.TokenMinAmount1.Size() + i -= size + if _, err := m.TokenMinAmount1.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + { + size := m.TokenMinAmount0.Size() + i -= size + if _, err := m.TokenMinAmount0.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + { + size, err := m.TokenDesired1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + { + size, err := m.TokenDesired0.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if m.UpperTick != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.UpperTick)) + i-- + dAtA[i] = 0x20 + } + if m.LowerTick != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.LowerTick)) + i-- + dAtA[i] = 0x18 + } + 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] = 0x12 + } + if m.PoolId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.PoolId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgCreatePositionResponse) 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 *MsgCreatePositionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCreatePositionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Amount1.Size() + i -= size + if _, err := m.Amount1.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size := m.Amount0.Size() + i -= size + if _, err := m.Amount0.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawPosition) 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 *MsgWithdrawPosition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawPosition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.LiquidityAmount.Size() + i -= size + if _, err := m.LiquidityAmount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if m.UpperTick != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.UpperTick)) + i-- + dAtA[i] = 0x20 + } + if m.LowerTick != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.LowerTick)) + i-- + dAtA[i] = 0x18 + } + 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] = 0x12 + } + if m.PoolId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.PoolId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawPositionResponse) 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 *MsgWithdrawPositionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawPositionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Amount1.Size() + i -= size + if _, err := m.Amount1.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size := m.Amount0.Size() + i -= size + if _, err := m.Amount0.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 *MsgCreatePosition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PoolId != 0 { + n += 1 + sovTx(uint64(m.PoolId)) + } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.LowerTick != 0 { + n += 1 + sovTx(uint64(m.LowerTick)) + } + if m.UpperTick != 0 { + n += 1 + sovTx(uint64(m.UpperTick)) + } + l = m.TokenDesired0.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.TokenDesired1.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.TokenMinAmount0.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.TokenMinAmount1.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgCreatePositionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Amount0.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.Amount1.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgWithdrawPosition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PoolId != 0 { + n += 1 + sovTx(uint64(m.PoolId)) + } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.LowerTick != 0 { + n += 1 + sovTx(uint64(m.LowerTick)) + } + if m.UpperTick != 0 { + n += 1 + sovTx(uint64(m.UpperTick)) + } + l = m.LiquidityAmount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgWithdrawPositionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Amount0.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.Amount1.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 *MsgCreatePosition) 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: MsgCreatePosition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreatePosition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType) + } + m.PoolId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PoolId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + 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 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LowerTick", wireType) + } + m.LowerTick = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LowerTick |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UpperTick", wireType) + } + m.UpperTick = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UpperTick |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenDesired0", 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.TokenDesired0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenDesired1", 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.TokenDesired1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenMinAmount0", 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.TokenMinAmount0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenMinAmount1", 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.TokenMinAmount1.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 *MsgCreatePositionResponse) 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: MsgCreatePositionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreatePositionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount0", 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.Amount0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount1", 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.Amount1.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 *MsgWithdrawPosition) 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: MsgWithdrawPosition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawPosition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType) + } + m.PoolId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PoolId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + 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 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LowerTick", wireType) + } + m.LowerTick = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LowerTick |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UpperTick", wireType) + } + m.UpperTick = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UpperTick |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidityAmount", 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.LiquidityAmount.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 *MsgWithdrawPositionResponse) 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: MsgWithdrawPositionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawPositionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount0", 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.Amount0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount1", 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.Amount1.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") +)