Unverified Commit b0c323c8 authored by antstalepresh's avatar antstalepresh Committed by GitHub
Browse files

Pool creation fee (#386)

* pool creation fee

* resolve existing tests

* Add test for balance change check and TODO for upgrade

* add code to configure pool creation fee param

* allow empty pool creation fee
parent 3b4b6c8c
Showing with 536 additions and 34 deletions
+536 -34
......@@ -339,6 +339,9 @@ func NewOsmosisApp(
distrParams.BaseProposerReward = sdk.ZeroDec()
distrParams.BonusProposerReward = sdk.ZeroDec()
app.DistrKeeper.SetParams(ctx, distrParams)
// configure upgrade for gamm module's pool creation fee param add
app.GAMMKeeper.SetParams(ctx, gammtypes.NewParams(sdk.Coins{sdk.NewInt64Coin("uosmo", 1000000000)})) // 1000 OSMO
})
// Create IBC Keeper
......@@ -373,7 +376,7 @@ func NewOsmosisApp(
app.StakingKeeper = *stakingKeeper.SetHooks(
stakingtypes.NewMultiStakingHooks(app.DistrKeeper.Hooks(), app.SlashingKeeper.Hooks(), app.ClaimKeeper.Hooks()),
)
gammKeeper := gammkeeper.NewKeeper(appCodec, keys[gammtypes.StoreKey], app.AccountKeeper, app.BankKeeper)
gammKeeper := gammkeeper.NewKeeper(appCodec, keys[gammtypes.StoreKey], app.GetSubspace(gammtypes.ModuleName), app.AccountKeeper, app.BankKeeper, app.DistrKeeper)
lockupKeeper := lockupkeeper.NewKeeper(appCodec, keys[lockuptypes.StoreKey], app.AccountKeeper, app.BankKeeper)
epochsKeeper := epochskeeper.NewKeeper(appCodec, keys[epochstypes.StoreKey])
incentivesKeeper := incentiveskeeper.NewKeeper(appCodec, keys[incentivestypes.StoreKey], app.GetSubspace(incentivestypes.ModuleName), app.AccountKeeper, app.BankKeeper, *lockupKeeper, epochsKeeper)
......@@ -517,6 +520,7 @@ func NewOsmosisApp(
claimtypes.ModuleName,
incentivestypes.ModuleName,
epochstypes.ModuleName,
gammtypes.ModuleName,
)
app.mm.RegisterInvariants(&app.CrisisKeeper)
......@@ -770,6 +774,7 @@ func initParamsKeeper(appCodec codec.BinaryMarshaler, legacyAmino *codec.LegacyA
paramsKeeper.Subspace(ibchost.ModuleName)
paramsKeeper.Subspace(incentivestypes.ModuleName)
paramsKeeper.Subspace(poolincentivestypes.ModuleName)
paramsKeeper.Subspace(gammtypes.ModuleName)
return paramsKeeper
}
......@@ -4,6 +4,17 @@ package osmosis.gamm;
import "gogoproto/gogo.proto";
import "google/protobuf/any.proto";
import "cosmos_proto/cosmos.proto";
import "cosmos/base/v1beta1/coin.proto";
// Params holds parameters for the incentives module
message Params {
repeated cosmos.base.v1beta1.Coin pool_creation_fee = 1 [
(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins",
(gogoproto.moretags) = "yaml:\"pool_creation_fee\"",
(gogoproto.nullable) = false
];
}
option go_package = "github.com/osmosis-labs/osmosis/x/gamm/types";
......@@ -12,4 +23,5 @@ message GenesisState {
repeated google.protobuf.Any pools = 1
[ (cosmos_proto.accepts_interface) = "PoolI" ];
uint64 next_pool_number = 2;
Params params = 3 [ (gogoproto.nullable) = false ];
}
......@@ -19,7 +19,7 @@ import (
"github.com/osmosis-labs/osmosis/x/gamm/client/cli"
gammtestutil "github.com/osmosis-labs/osmosis/x/gamm/client/testutil"
"github.com/osmosis-labs/osmosis/x/gamm/types"
gammtypes "github.com/osmosis-labs/osmosis/x/gamm/types"
tmcli "github.com/tendermint/tendermint/libs/cli"
)
......@@ -35,6 +35,16 @@ func (s *IntegrationTestSuite) SetupSuite() {
s.cfg = app.DefaultConfig()
encCfg := app.MakeEncodingConfig()
// modification to pay fee with test bond denom "stake"
genesisState := app.ModuleBasics.DefaultGenesis(encCfg.Marshaler)
gammGen := gammtypes.DefaultGenesis()
gammGen.Params.PoolCreationFee = sdk.Coins{sdk.NewInt64Coin(s.cfg.BondDenom, 1000000)}
gammGenJson := encCfg.Marshaler.MustMarshalJSON(gammGen)
genesisState[gammtypes.ModuleName] = gammGenJson
s.cfg.GenesisState = genesisState
s.network = network.New(s.T(), s.cfg)
_, err := s.network.WaitForHeight(1)
......@@ -67,7 +77,7 @@ func (s *IntegrationTestSuite) TestNewCreatePoolCmd() {
val.ClientCtx,
val.Address,
newAddr,
sdk.NewCoins(sdk.NewInt64Coin(s.cfg.BondDenom, 20000), sdk.NewInt64Coin("node0token", 20000)), fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
sdk.NewCoins(sdk.NewInt64Coin(s.cfg.BondDenom, 200000000), sdk.NewInt64Coin("node0token", 20000)), fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
)
......
......@@ -12,6 +12,7 @@ import (
// InitGenesis initializes the capability module's state from a provided genesis
// state.
func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState, unpacker codectypes.AnyUnpacker) {
k.SetParams(ctx, genState.Params)
k.SetNextPoolNumber(ctx, genState.NextPoolNumber)
liquidity := sdk.Coins{}
......@@ -56,5 +57,6 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState {
return &types.GenesisState{
NextPoolNumber: k.GetNextPoolNumber(ctx),
Pools: poolAnys,
Params: k.GetParams(ctx),
}
}
......@@ -6,6 +6,7 @@ import (
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
sdk "github.com/cosmos/cosmos-sdk/types"
simapp "github.com/osmosis-labs/osmosis/app"
appparams "github.com/osmosis-labs/osmosis/app/params"
"github.com/osmosis-labs/osmosis/x/gamm"
"github.com/osmosis-labs/osmosis/x/gamm/types"
"github.com/stretchr/testify/assert"
......@@ -42,6 +43,9 @@ func TestGammInitGenesis(t *testing.T) {
gamm.InitGenesis(ctx, app.GAMMKeeper, types.GenesisState{
Pools: []*codectypes.Any{any},
NextPoolNumber: 2,
Params: types.Params{
PoolCreationFee: sdk.Coins{sdk.NewInt64Coin(appparams.BaseCoinUnit, 1000_000_000)},
},
}, app.AppCodec())
require.Equal(t, app.GAMMKeeper.GetNextPoolNumber(ctx), uint64(2))
......@@ -68,6 +72,7 @@ func TestGammExportGenesis(t *testing.T) {
acc1 := sdk.AccAddress(ed25519.GenPrivKey().PubKey().Address().Bytes())
app.BankKeeper.SetBalances(ctx, acc1, sdk.Coins{
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewInt64Coin("foo", 100000),
sdk.NewInt64Coin("bar", 100000),
})
......@@ -110,6 +115,7 @@ func TestMarshalUnmarshalGenesis(t *testing.T) {
am := gamm.NewAppModule(appCodec, app.GAMMKeeper, app.AccountKeeper, app.BankKeeper)
acc1 := sdk.AccAddress(ed25519.GenPrivKey().PubKey().Address().Bytes())
app.BankKeeper.SetBalances(ctx, acc1, sdk.Coins{
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewInt64Coin("foo", 100000),
sdk.NewInt64Coin("bar", 100000),
})
......
......@@ -7,6 +7,7 @@ import (
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
"github.com/osmosis-labs/osmosis/x/gamm/types"
)
......@@ -24,14 +25,16 @@ type Keeper struct {
storeKey sdk.StoreKey
cdc codec.BinaryMarshaler
hooks types.GammHooks
paramSpace paramtypes.Subspace
hooks types.GammHooks
// keepers
accountKeeper types.AccountKeeper
bankKeeper types.BankKeeper
distrKeeper types.DistrKeeper
}
func NewKeeper(cdc codec.BinaryMarshaler, storeKey sdk.StoreKey, accountKeeper types.AccountKeeper, bankKeeper types.BankKeeper) Keeper {
func NewKeeper(cdc codec.BinaryMarshaler, storeKey sdk.StoreKey, paramSpace paramtypes.Subspace, accountKeeper types.AccountKeeper, bankKeeper types.BankKeeper, distrKeeper types.DistrKeeper) Keeper {
// Ensure that the module account are set.
moduleAddr, perms := accountKeeper.GetModuleAddressAndPermissions(types.ModuleName)
if moduleAddr == nil {
......@@ -43,12 +46,17 @@ func NewKeeper(cdc codec.BinaryMarshaler, storeKey sdk.StoreKey, accountKeeper t
if !permContains(perms, authtypes.Burner) {
panic(fmt.Sprintf("%s module account should have the burner permission", types.ModuleName))
}
if !paramSpace.HasKeyTable() {
paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable())
}
return Keeper{
storeKey: storeKey,
cdc: cdc,
storeKey: storeKey,
cdc: cdc,
paramSpace: paramSpace,
// keepers
accountKeeper: accountKeeper,
bankKeeper: bankKeeper,
distrKeeper: distrKeeper,
}
}
......
......@@ -50,6 +50,7 @@ func (suite *KeeperTestSuite) preparePoolWithPoolParams(poolParams types.PoolPar
suite.ctx,
acc,
sdk.NewCoins(
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewCoin("foo", sdk.NewInt(10000000)),
sdk.NewCoin("bar", sdk.NewInt(10000000)),
sdk.NewCoin("baz", sdk.NewInt(10000000)),
......
package keeper
import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/osmosis-labs/osmosis/x/gamm/types"
)
// GetParams returns the total set params
func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
k.paramSpace.GetParamSet(ctx, &params)
return params
}
// SetParams sets the total set of params
func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
k.paramSpace.SetParamSet(ctx, &params)
}
......@@ -28,6 +28,13 @@ func (k Keeper) CreatePool(
)
}
// send pool creation fee to community pool
params := k.GetParams(ctx)
err := k.distrKeeper.FundCommunityPool(ctx, params.PoolCreationFee, sender)
if err != nil {
return 0, err
}
pool, err := k.newPool(ctx, poolParams, poolAssets, futurePoolGovernor)
if err != nil {
return 0, err
......
......@@ -19,6 +19,13 @@ var (
)
func (suite *KeeperTestSuite) TestCreatePool() {
params := suite.app.GAMMKeeper.GetParams(suite.ctx)
poolCreationFeeDecCoins := sdk.DecCoins{}
for _, coin := range params.PoolCreationFee {
poolCreationFeeDecCoins = poolCreationFeeDecCoins.Add(sdk.NewDecCoin(coin.Denom, coin.Amount))
}
func() {
keeper := suite.app.GAMMKeeper
......@@ -41,6 +48,8 @@ func (suite *KeeperTestSuite) TestCreatePool() {
}{{
fn: func() {
keeper := suite.app.GAMMKeeper
prevFeePool := suite.app.DistrKeeper.GetFeePoolCommunityCoins(suite.ctx)
prevAcc1Bal := suite.app.BankKeeper.GetAllBalances(suite.ctx, acc1)
poolId, err := keeper.CreatePool(suite.ctx, acc1, types.PoolParams{
SwapFee: sdk.NewDecWithPrec(1, 2),
ExitFee: sdk.NewDecWithPrec(1, 2),
......@@ -59,6 +68,20 @@ func (suite *KeeperTestSuite) TestCreatePool() {
fmt.Sprintf("share token should be minted as %s initially", types.InitPoolSharesSupply.String()),
)
// check fee is correctly sent to community pool
feePool := suite.app.DistrKeeper.GetFeePoolCommunityCoins(suite.ctx)
suite.Require().Equal(feePool, prevFeePool.Add(poolCreationFeeDecCoins...))
// check account's balance is correctly reduced
acc1Bal := suite.app.BankKeeper.GetAllBalances(suite.ctx, acc1)
suite.Require().Equal(acc1Bal.String(),
prevAcc1Bal.Sub(params.PoolCreationFee).
Sub(sdk.Coins{
sdk.NewCoin("bar", sdk.NewInt(10000)),
sdk.NewCoin("foo", sdk.NewInt(10000)),
}).Add(sdk.NewCoin(types.GetPoolShareDenom(pool.GetId()), types.InitPoolSharesSupply)).String(),
)
liquidity := suite.app.GAMMKeeper.GetTotalLiquidity(suite.ctx)
suite.Require().Equal("10000bar,10000foo", liquidity.String())
},
......@@ -183,6 +206,48 @@ func (suite *KeeperTestSuite) TestCreatePool() {
}}, defaultFutureGovernor)
suite.Require().Error(err, "can't create the pool with duplicated PoolAssets")
},
}, {
fn: func() {
keeper := suite.app.GAMMKeeper
keeper.SetParams(suite.ctx, types.Params{
PoolCreationFee: sdk.Coins{},
})
_, err := keeper.CreatePool(suite.ctx, acc1, types.PoolParams{
SwapFee: sdk.NewDecWithPrec(1, 2),
ExitFee: sdk.NewDecWithPrec(1, 2),
}, []types.PoolAsset{{
Weight: sdk.NewInt(100),
Token: sdk.NewCoin("foo", sdk.NewInt(10000)),
}, {
Weight: sdk.NewInt(100),
Token: sdk.NewCoin("bar", sdk.NewInt(10000)),
}}, defaultFutureGovernor)
suite.Require().NoError(err)
pools, err := keeper.GetPools(suite.ctx)
suite.Require().Len(pools, 1)
suite.Require().NoError(err)
},
}, {
fn: func() {
keeper := suite.app.GAMMKeeper
keeper.SetParams(suite.ctx, types.Params{
PoolCreationFee: nil,
})
_, err := keeper.CreatePool(suite.ctx, acc1, types.PoolParams{
SwapFee: sdk.NewDecWithPrec(1, 2),
ExitFee: sdk.NewDecWithPrec(1, 2),
}, []types.PoolAsset{{
Weight: sdk.NewInt(100),
Token: sdk.NewCoin("foo", sdk.NewInt(10000)),
}, {
Weight: sdk.NewInt(100),
Token: sdk.NewCoin("bar", sdk.NewInt(10000)),
}}, defaultFutureGovernor)
suite.Require().NoError(err)
pools, err := keeper.GetPools(suite.ctx)
suite.Require().Len(pools, 1)
suite.Require().NoError(err)
},
}}
for _, test := range tests {
......@@ -194,6 +259,7 @@ func (suite *KeeperTestSuite) TestCreatePool() {
suite.ctx,
acc,
sdk.NewCoins(
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewCoin("foo", sdk.NewInt(10000000)),
sdk.NewCoin("bar", sdk.NewInt(10000000)),
sdk.NewCoin("baz", sdk.NewInt(10000000)),
......@@ -281,6 +347,7 @@ func (suite *KeeperTestSuite) TestJoinPool() {
suite.ctx,
acc,
sdk.NewCoins(
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewCoin("foo", sdk.NewInt(10000000)),
sdk.NewCoin("bar", sdk.NewInt(10000000)),
sdk.NewCoin("baz", sdk.NewInt(10000000)),
......@@ -389,6 +456,7 @@ func (suite *KeeperTestSuite) TestExitPool() {
suite.ctx,
acc,
sdk.NewCoins(
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewCoin("foo", sdk.NewInt(10000000)),
sdk.NewCoin("bar", sdk.NewInt(10000000)),
sdk.NewCoin("baz", sdk.NewInt(10000000)),
......@@ -436,6 +504,7 @@ func (suite *KeeperTestSuite) TestActivePool() {
suite.ctx,
acc,
sdk.NewCoins(
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewCoin("foo", sdk.NewInt(10000000)),
sdk.NewCoin("bar", sdk.NewInt(10000000)),
sdk.NewCoin("baz", sdk.NewInt(10000000)),
......
......@@ -218,6 +218,7 @@ func (suite *KeeperTestSuite) TestActivePoolSwap() {
suite.ctx,
acc,
sdk.NewCoins(
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewCoin("foo", sdk.NewInt(10000000)),
sdk.NewCoin("bar", sdk.NewInt(10000000)),
sdk.NewCoin("baz", sdk.NewInt(10000000)),
......
......@@ -3,6 +3,7 @@ package gamm
import (
"context"
"encoding/json"
"fmt"
"math/rand"
"github.com/cosmos/cosmos-sdk/client"
......@@ -45,12 +46,16 @@ func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
// DefaultGenesis returns default genesis state as raw bytes for the gamm
// module.
func (AppModuleBasic) DefaultGenesis(cdc codec.JSONMarshaler) json.RawMessage {
return nil
return cdc.MustMarshalJSON(types.DefaultGenesis())
}
// ValidateGenesis performs genesis state validation for the gamm module.
func (AppModuleBasic) ValidateGenesis(cdc codec.JSONMarshaler, config client.TxEncodingConfig, bz json.RawMessage) error {
return nil
var genState types.GenesisState
if err := cdc.UnmarshalJSON(bz, &genState); err != nil {
return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err)
}
return genState.Validate()
}
//---------------------------------------
......
......@@ -154,6 +154,12 @@ func SimulateMsgCreatePool(ak stakingTypes.AccountKeeper, bk stakingTypes.BankKe
for i := range balances {
denoms[i] = balances[i].Denom
}
// set the pool params to set the pool creation fee to dust amount of denom
k.SetParams(ctx, types.Params{
PoolCreationFee: sdk.Coins{sdk.NewInt64Coin(denoms[0], 1)},
})
// futurePoolGovernor := genFuturePoolGovernor(r, simAccount.Address, denoms)
msg := types.MsgCreatePool{
Sender: simAccount.Address.String(),
......@@ -184,7 +190,7 @@ func SimulateMsgSwapExactAmountIn(ak stakingTypes.AccountKeeper, bk stakingTypes
coin := simCoins[r.Intn(len(simCoins))]
// Use under 0.5% of the account balance
// TODO: Make like a 33% probability of using a ton of balance
// TODO: Make like a 33% probability of using a ton of balance
amt, _ := simtypes.RandPositiveInt(r, coin.Amount.QuoRaw(200))
tokenIn := sdk.Coin{
......
<!--
order: 4
-->
# Parameters
The gamm module contains the following parameters:
| Key | Type | Example |
| --------------- | --------- | ----------------- |
| PoolCreationFee | sdk.Coins | "1000000000uosmo" |
Note:
PoolCreationFee is the amount of coins paid to community pool at the time of pool creation which is introduced to prevent spam pool creation.
......@@ -56,3 +56,8 @@ type BankKeeper interface {
UndelegateCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
DelegateCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
}
// DistrKeeper defines the contract needed to be fulfilled for distribution keeper
type DistrKeeper interface {
FundCommunityPool(ctx sdk.Context, amount sdk.Coins, sender sdk.AccAddress) error
}
package types
import (
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
)
// DefaultGenesis creates a default GenesisState object
func DefaultGenesis() *GenesisState {
return &GenesisState{
Pools: []*codectypes.Any{},
NextPoolNumber: 1,
Params: DefaultParams(),
}
}
// Validate performs basic genesis state validation returning an error upon any
// failure.
func (gs GenesisState) Validate() error {
if err := gs.Params.Validate(); err != nil {
return err
}
return nil
}
......@@ -5,7 +5,9 @@ package types
import (
fmt "fmt"
types "github.com/cosmos/cosmos-sdk/codec/types"
types1 "github.com/cosmos/cosmos-sdk/codec/types"
github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
types "github.com/cosmos/cosmos-sdk/types"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
_ "github.com/regen-network/cosmos-proto"
......@@ -25,17 +27,63 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// Params holds parameters for the incentives module
type Params struct {
PoolCreationFee github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=pool_creation_fee,json=poolCreationFee,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"pool_creation_fee" yaml:"pool_creation_fee"`
}
func (m *Params) Reset() { *m = Params{} }
func (m *Params) String() string { return proto.CompactTextString(m) }
func (*Params) ProtoMessage() {}
func (*Params) Descriptor() ([]byte, []int) {
return fileDescriptor_5a324eb7f1dd793e, []int{0}
}
func (m *Params) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) {
xxx_messageInfo_Params.Merge(m, src)
}
func (m *Params) XXX_Size() int {
return m.Size()
}
func (m *Params) XXX_DiscardUnknown() {
xxx_messageInfo_Params.DiscardUnknown(m)
}
var xxx_messageInfo_Params proto.InternalMessageInfo
func (m *Params) GetPoolCreationFee() github_com_cosmos_cosmos_sdk_types.Coins {
if m != nil {
return m.PoolCreationFee
}
return nil
}
// GenesisState defines the gamm module's genesis state.
type GenesisState struct {
Pools []*types.Any `protobuf:"bytes,1,rep,name=pools,proto3" json:"pools,omitempty"`
NextPoolNumber uint64 `protobuf:"varint,2,opt,name=next_pool_number,json=nextPoolNumber,proto3" json:"next_pool_number,omitempty"`
Pools []*types1.Any `protobuf:"bytes,1,rep,name=pools,proto3" json:"pools,omitempty"`
NextPoolNumber uint64 `protobuf:"varint,2,opt,name=next_pool_number,json=nextPoolNumber,proto3" json:"next_pool_number,omitempty"`
Params Params `protobuf:"bytes,3,opt,name=params,proto3" json:"params"`
}
func (m *GenesisState) Reset() { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage() {}
func (*GenesisState) Descriptor() ([]byte, []int) {
return fileDescriptor_5a324eb7f1dd793e, []int{0}
return fileDescriptor_5a324eb7f1dd793e, []int{1}
}
func (m *GenesisState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
......@@ -64,7 +112,7 @@ func (m *GenesisState) XXX_DiscardUnknown() {
var xxx_messageInfo_GenesisState proto.InternalMessageInfo
func (m *GenesisState) GetPools() []*types.Any {
func (m *GenesisState) GetPools() []*types1.Any {
if m != nil {
return m.Pools
}
......@@ -78,7 +126,15 @@ func (m *GenesisState) GetNextPoolNumber() uint64 {
return 0
}
func (m *GenesisState) GetParams() Params {
if m != nil {
return m.Params
}
return Params{}
}
func init() {
proto.RegisterType((*Params)(nil), "osmosis.gamm.Params")
proto.RegisterType((*GenesisState)(nil), "osmosis.gamm.GenesisState")
}
......@@ -87,24 +143,69 @@ func init() {
}
var fileDescriptor_5a324eb7f1dd793e = []byte{
// 259 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xca, 0x2f, 0xce, 0xcd,
0x2f, 0xce, 0x2c, 0xd6, 0x4f, 0x4f, 0xcc, 0xcd, 0xd5, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34,
0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2,
0x81, 0xaa, 0xd1, 0x03, 0xa9, 0x91, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x4b, 0xe8, 0x83, 0x58,
0x10, 0x35, 0x52, 0x92, 0xe9, 0xf9, 0xf9, 0xe9, 0x39, 0xa9, 0xfa, 0x60, 0x5e, 0x52, 0x69, 0x9a,
0x7e, 0x62, 0x5e, 0x25, 0x4c, 0x2a, 0x19, 0xac, 0x3f, 0x1e, 0xa2, 0x07, 0xc2, 0x81, 0x48, 0x29,
0xe5, 0x73, 0xf1, 0xb8, 0x43, 0xac, 0x0a, 0x2e, 0x49, 0x2c, 0x49, 0x15, 0x32, 0xe5, 0x62, 0x2d,
0xc8, 0xcf, 0xcf, 0x29, 0x96, 0x60, 0x54, 0x60, 0xd6, 0xe0, 0x36, 0x12, 0xd1, 0x83, 0x98, 0xaa,
0x07, 0x33, 0x55, 0xcf, 0x31, 0xaf, 0xd2, 0x89, 0xf3, 0xd4, 0x16, 0x5d, 0xd6, 0x80, 0xfc, 0xfc,
0x1c, 0xcf, 0x20, 0x88, 0x6a, 0x21, 0x0d, 0x2e, 0x81, 0xbc, 0xd4, 0x8a, 0x92, 0x78, 0x10, 0x2f,
0x3e, 0xaf, 0x34, 0x37, 0x29, 0xb5, 0x48, 0x82, 0x49, 0x81, 0x51, 0x83, 0x25, 0x88, 0x0f, 0x24,
0x0e, 0x52, 0xeb, 0x07, 0x16, 0x75, 0x72, 0x3b, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6,
0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39,
0x86, 0x28, 0x9d, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0xa8, 0x7f,
0x75, 0x73, 0x12, 0x93, 0x8a, 0x61, 0x1c, 0xfd, 0x0a, 0x48, 0x10, 0x95, 0x54, 0x16, 0xa4, 0x16,
0x27, 0xb1, 0x81, 0x5d, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x16, 0xaa, 0x73, 0x98, 0x3f,
0x01, 0x00, 0x00,
// 390 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x52, 0x3d, 0xeb, 0xd3, 0x40,
0x18, 0xcf, 0xf9, 0xff, 0xb7, 0x60, 0x2c, 0xbe, 0x84, 0x0e, 0x69, 0x87, 0xb4, 0x64, 0xca, 0x60,
0xef, 0x68, 0xc5, 0xc5, 0xcd, 0x14, 0x2a, 0x82, 0x48, 0x89, 0x9b, 0x4b, 0xb8, 0xc4, 0x6b, 0x0c,
0x26, 0xf7, 0x84, 0xdc, 0x55, 0x9a, 0x6f, 0x21, 0xb8, 0xbb, 0xb8, 0x39, 0xfb, 0x21, 0x8a, 0x53,
0x47, 0xa7, 0x2a, 0xed, 0x37, 0xf0, 0x13, 0xc8, 0xbd, 0x54, 0x0a, 0x4e, 0xc9, 0xef, 0x7e, 0x2f,
0xf7, 0x3c, 0xbf, 0xc4, 0x0d, 0x41, 0xd4, 0x20, 0x4a, 0x41, 0x0a, 0x5a, 0xd7, 0xe4, 0xe3, 0x3c,
0x63, 0x92, 0xce, 0x49, 0xc1, 0x38, 0x13, 0xa5, 0xc0, 0x4d, 0x0b, 0x12, 0xbc, 0x81, 0xd5, 0x60,
0xa5, 0x19, 0x0f, 0x0b, 0x28, 0x40, 0x13, 0x44, 0xbd, 0x19, 0xcd, 0x78, 0x54, 0x00, 0x14, 0x15,
0x23, 0x1a, 0x65, 0xdb, 0x0d, 0xa1, 0xbc, 0xbb, 0x50, 0xb9, 0xf6, 0xa7, 0xc6, 0x63, 0x80, 0xa5,
0x02, 0x83, 0x48, 0x46, 0x05, 0xfb, 0x77, 0x79, 0x0e, 0x25, 0x37, 0x7c, 0xf8, 0x05, 0xb9, 0xfd,
0x35, 0x6d, 0x69, 0x2d, 0xbc, 0xcf, 0xc8, 0x7d, 0xd4, 0x00, 0x54, 0x69, 0xde, 0x32, 0x2a, 0x4b,
0xe0, 0xe9, 0x86, 0x31, 0x1f, 0x4d, 0x6f, 0xa2, 0x7b, 0x8b, 0x11, 0xb6, 0xa9, 0x2a, 0x07, 0xdb,
0x1c, 0xbc, 0x84, 0x92, 0xc7, 0xaf, 0xf6, 0xc7, 0x89, 0xf3, 0xe7, 0x38, 0xf1, 0x3b, 0x5a, 0x57,
0xcf, 0xc2, 0xff, 0x12, 0xc2, 0x6f, 0xbf, 0x26, 0x51, 0x51, 0xca, 0xf7, 0xdb, 0x0c, 0xe7, 0x50,
0xdb, 0xf1, 0xec, 0x63, 0x26, 0xde, 0x7d, 0x20, 0xb2, 0x6b, 0x98, 0xd0, 0x61, 0x22, 0x79, 0xa0,
0xfc, 0x4b, 0x6b, 0x5f, 0x31, 0x16, 0x7e, 0x45, 0xee, 0xe0, 0x85, 0x29, 0xeb, 0x8d, 0xa4, 0x92,
0x79, 0x4f, 0xdd, 0x9e, 0xd2, 0x08, 0x3b, 0xd9, 0x10, 0x9b, 0x5e, 0xf0, 0xa5, 0x17, 0xfc, 0x9c,
0x77, 0xf1, 0xdd, 0x1f, 0xdf, 0x67, 0xbd, 0x35, 0x40, 0xf5, 0x32, 0x31, 0x6a, 0x2f, 0x72, 0x1f,
0x72, 0xb6, 0x93, 0xa9, 0x9e, 0x8f, 0x6f, 0xeb, 0x8c, 0xb5, 0xfe, 0x9d, 0x29, 0x8a, 0x6e, 0x93,
0xfb, 0xea, 0x5c, 0x69, 0x5f, 0xeb, 0x53, 0x6f, 0xe1, 0xf6, 0x1b, 0xdd, 0x88, 0x7f, 0x33, 0x45,
0xfa, 0x86, 0xeb, 0xaf, 0x83, 0x4d, 0x5b, 0xf1, 0xad, 0x5a, 0x3b, 0xb1, 0xca, 0x78, 0xb5, 0x3f,
0x05, 0xe8, 0x70, 0x0a, 0xd0, 0xef, 0x53, 0x80, 0x3e, 0x9d, 0x03, 0xe7, 0x70, 0x0e, 0x9c, 0x9f,
0xe7, 0xc0, 0x79, 0xfb, 0xf8, 0x6a, 0x75, 0x9b, 0x33, 0xab, 0x68, 0x26, 0x2e, 0x80, 0xec, 0xcc,
0x8f, 0xa1, 0x4b, 0xc8, 0xfa, 0x7a, 0x8b, 0x27, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x6a,
0x74, 0x74, 0x35, 0x02, 0x00, 0x00,
}
func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.PoolCreationFee) > 0 {
for iNdEx := len(m.PoolCreationFee) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.PoolCreationFee[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *GenesisState) Marshal() (dAtA []byte, err error) {
......@@ -127,6 +228,16 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
{
size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
if m.NextPoolNumber != 0 {
i = encodeVarintGenesis(dAtA, i, uint64(m.NextPoolNumber))
i--
......@@ -160,6 +271,21 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func (m *Params) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.PoolCreationFee) > 0 {
for _, e := range m.PoolCreationFee {
l = e.Size()
n += 1 + l + sovGenesis(uint64(l))
}
}
return n
}
func (m *GenesisState) Size() (n int) {
if m == nil {
return 0
......@@ -175,6 +301,8 @@ func (m *GenesisState) Size() (n int) {
if m.NextPoolNumber != 0 {
n += 1 + sovGenesis(uint64(m.NextPoolNumber))
}
l = m.Params.Size()
n += 1 + l + sovGenesis(uint64(l))
return n
}
......@@ -184,6 +312,93 @@ func sovGenesis(x uint64) (n int) {
func sozGenesis(x uint64) (n int) {
return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) 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 ErrIntOverflowGenesis
}
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: Params: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PoolCreationFee", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PoolCreationFee = append(m.PoolCreationFee, types.Coin{})
if err := m.PoolCreationFee[len(m.PoolCreationFee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenesis
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthGenesis
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GenesisState) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
......@@ -242,7 +457,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Pools = append(m.Pools, &types.Any{})
m.Pools = append(m.Pools, &types1.Any{})
if err := m.Pools[len(m.Pools)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
......@@ -266,6 +481,39 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
break
}
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenesis
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])
......
package types
import (
"fmt"
sdk "github.com/cosmos/cosmos-sdk/types"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
appparams "github.com/osmosis-labs/osmosis/app/params"
)
// Parameter store keys
var (
KeyPoolCreationFee = []byte("PoolCreationFee")
)
// ParamTable for gamm module.
func ParamKeyTable() paramtypes.KeyTable {
return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
}
func NewParams(poolCreationFee sdk.Coins) Params {
return Params{
PoolCreationFee: poolCreationFee,
}
}
// default gamm module parameters
func DefaultParams() Params {
return Params{
PoolCreationFee: sdk.Coins{sdk.NewInt64Coin(appparams.BaseCoinUnit, 1000_000_000)}, // 1000 OSMO
}
}
// validate params
func (p Params) Validate() error {
if err := validatePoolCreationFee(p.PoolCreationFee); err != nil {
return err
}
return nil
}
// Implements params.ParamSet
func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
return paramtypes.ParamSetPairs{
paramtypes.NewParamSetPair(KeyPoolCreationFee, &p.PoolCreationFee, validatePoolCreationFee),
}
}
func validatePoolCreationFee(i interface{}) error {
v, ok := i.(sdk.Coins)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
if v.Validate() != nil {
return fmt.Errorf("invalid pool creation fee: %+v", i)
}
return nil
}
......@@ -52,6 +52,7 @@ func (suite *KeeperTestSuite) preparePoolWithPoolParams(poolParams gammtypes.Poo
suite.ctx,
acc,
sdk.NewCoins(
sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
sdk.NewCoin("foo", sdk.NewInt(10000000)),
sdk.NewCoin("bar", sdk.NewInt(10000000)),
sdk.NewCoin("baz", sdk.NewInt(10000000)),
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment