diff --git a/app/app.go b/app/app.go index 40278b7b8..f72bd9c30 100644 --- a/app/app.go +++ b/app/app.go @@ -16,8 +16,7 @@ import ( bam "github.com/irisnet/irishub/baseapp" "github.com/irisnet/irishub/modules/gov" "github.com/irisnet/irishub/modules/gov/params" - "github.com/irisnet/irishub/modules/iparams" - "github.com/irisnet/irishub/modules/parameter" + "github.com/irisnet/irishub/modules/iparam" "github.com/irisnet/irishub/modules/upgrade" "github.com/irisnet/irishub/modules/upgrade/params" "github.com/spf13/viper" @@ -73,7 +72,6 @@ type IrisApp struct { slashingKeeper slashing.Keeper paramsKeeper params.Keeper govKeeper gov.Keeper - iparamsKeeper iparams.Keeper upgradeKeeper upgrade.Keeper // fee manager @@ -116,14 +114,13 @@ func NewIrisApp(logger log.Logger, db dbm.DB, traceStore io.Writer, baseAppOptio // add handlers app.paramsKeeper = params.NewKeeper(cdc, app.keyParams) - app.iparamsKeeper = iparams.NewKeeper(app.cdc, app.keyIparams) app.coinKeeper = bank.NewKeeper(app.accountMapper) app.ibcMapper = ibc.NewMapper(app.cdc, app.keyIBC, app.RegisterCodespace(ibc.DefaultCodespace)) app.stakeKeeper = stake.NewKeeper(app.cdc, app.keyStake, app.coinKeeper, app.RegisterCodespace(stake.DefaultCodespace)) app.slashingKeeper = slashing.NewKeeper(app.cdc, app.keySlashing, app.stakeKeeper, app.paramsKeeper.Getter(), app.RegisterCodespace(slashing.DefaultCodespace)) app.feeCollectionKeeper = auth.NewFeeCollectionKeeper(app.cdc, app.keyFeeCollection) app.upgradeKeeper = upgrade.NewKeeper(app.cdc, app.keyUpgrade, app.stakeKeeper) - app.govKeeper = gov.NewKeeper(app.cdc, app.keyGov, app.iparamsKeeper.GovSetter(), app.coinKeeper, app.stakeKeeper, app.RegisterCodespace(gov.DefaultCodespace)) + app.govKeeper = gov.NewKeeper(app.cdc, app.keyGov, app.coinKeeper, app.stakeKeeper, app.RegisterCodespace(gov.DefaultCodespace)) // register message routes // need to update each module's msg type @@ -135,7 +132,7 @@ func NewIrisApp(logger log.Logger, db dbm.DB, traceStore io.Writer, baseAppOptio AddRoute("gov", []*sdk.KVStoreKey{app.keyGov, app.keyAccount, app.keyStake, app.keyIparams, app.keyParams}, gov.NewHandler(app.govKeeper)). AddRoute("upgrade", []*sdk.KVStoreKey{app.keyUpgrade, app.keyStake}, upgrade.NewHandler(app.upgradeKeeper)) - app.feeManager = bam.NewFeeManager(app.iparamsKeeper.GlobalGetter(), app.iparamsKeeper.GovGetter()) + app.feeManager = bam.NewFeeManager(app.paramsKeeper.Setter()) // initialize BaseApp app.SetInitChainer(app.initChainer) app.SetBeginBlocker(app.BeginBlocker) @@ -157,14 +154,14 @@ func NewIrisApp(logger log.Logger, db dbm.DB, traceStore io.Writer, baseAppOptio } upgrade.RegisterModuleList(app.Router()) - parameter.SetParamReadWriter(app.paramsKeeper.Setter(), + iparam.SetParamReadWriter(app.paramsKeeper.Setter(), &govparams.DepositProcedureParameter, &govparams.VotingProcedureParameter, &govparams.TallyingProcedureParameter, &upgradeparams.CurrentUpgradeProposalIdParameter, &upgradeparams.ProposalAcceptHeightParameter) - parameter.RegisterGovParamMapping(&govparams.DepositProcedureParameter, + iparam.RegisterGovParamMapping(&govparams.DepositProcedureParameter, &govparams.VotingProcedureParameter, &govparams.TallyingProcedureParameter,) @@ -257,7 +254,7 @@ func (app *IrisApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci GasPriceThreshold: 20000000000, // 20(glue), 20*10^9, 1 glue = 10^9 lue/gas, 1 iris = 10^18 lue } - bam.InitGenesis(ctx, app.iparamsKeeper.GlobalSetter(), app.iparamsKeeper.GovSetter(), feeTokenGensisConfig) + bam.InitGenesis(ctx, app.paramsKeeper.Setter(), feeTokenGensisConfig) // load the address to pubkey map slashing.InitGenesis(ctx, app.slashingKeeper, genesisState.StakeData) diff --git a/baseapp/fee.go b/baseapp/fee.go index 4a8302fdf..0c74e51d1 100644 --- a/baseapp/fee.go +++ b/baseapp/fee.go @@ -7,7 +7,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "errors" "github.com/irisnet/irishub/types" - "github.com/irisnet/irishub/modules/iparams" + "github.com/cosmos/cosmos-sdk/x/params" ) var ( @@ -54,7 +54,7 @@ func NewFeeRefundHandler(am auth.AccountMapper, fck auth.FeeCollectionKeeper, fm } // Refund process will also cost gas, but this is compensation for previous fee deduction. // It is not reasonable to consume users' gas. So the context gas is reset to transaction gas - ctx = ctx.WithGasMeter(sdk.NewGasMeter(stdTx.Fee.Gas)) + ctx = ctx.WithGasMeter(sdk.NewInfiniteGasMeter()) fee := auth.StdFee{ Gas: stdTx.Fee.Gas, @@ -99,19 +99,17 @@ func NewFeeRefundHandler(am auth.AccountMapper, fck auth.FeeCollectionKeeper, fm // FeeManager do fee tokens preprocess according to fee token configuration type FeeManager struct { - globalGetter iparams.GlobalGetter - govGetter iparams.GovGetter + ps params.Setter } -func NewFeeManager(globalGetter iparams.GlobalGetter, govGetter iparams.GovGetter) FeeManager { +func NewFeeManager(ps params.Setter) FeeManager { return FeeManager{ - globalGetter: globalGetter, - govGetter: govGetter, + ps:ps, } } func (fck FeeManager) getNativeFeeToken(ctx sdk.Context, coins sdk.Coins) sdk.Coin { - nativeFeeToken, err := fck.globalGetter.GetString(ctx, nativeFeeTokenKey) + nativeFeeToken, err := fck.ps.GetString(ctx, nativeFeeTokenKey) if err != nil { panic(err) } @@ -127,11 +125,11 @@ func (fck FeeManager) feePreprocess(ctx sdk.Context, coins sdk.Coins, gasLimit i if gasLimit <= 0 { return sdk.ErrInternal(fmt.Sprintf("gaslimit %d should be larger than 0", gasLimit)) } - nativeFeeToken, err := fck.globalGetter.GetString(ctx, nativeFeeTokenKey) + nativeFeeToken, err := fck.ps.GetString(ctx, nativeFeeTokenKey) if err != nil { panic(err) } - nativeGasPriceThreshold, err := fck.govGetter.GetString(ctx, nativeGasPriceThresholdKey) + nativeGasPriceThreshold, err := fck.ps.GetString(ctx, nativeGasPriceThresholdKey) if err != nil { panic(err) } @@ -177,7 +175,7 @@ type FeeGenesisStateConfig struct { GasPriceThreshold int64 `json:"gas_price_threshold"` } -func InitGenesis(ctx sdk.Context, globalSetter iparams.GlobalSetter, govSetter iparams.GovSetter, data FeeGenesisStateConfig) { - globalSetter.SetString(ctx, nativeFeeTokenKey, data.FeeTokenNative) - govSetter.SetString(ctx, nativeGasPriceThresholdKey, sdk.NewInt(data.GasPriceThreshold).String()) +func InitGenesis(ctx sdk.Context, ps params.Setter, data FeeGenesisStateConfig) { + ps.SetString(ctx, nativeFeeTokenKey, data.FeeTokenNative) + ps.SetString(ctx, nativeGasPriceThresholdKey, sdk.NewInt(data.GasPriceThreshold).String()) } diff --git a/client/gov/cli/query.go b/client/gov/cli/query.go index 81d103b00..5dfb52edc 100644 --- a/client/gov/cli/query.go +++ b/client/gov/cli/query.go @@ -9,7 +9,7 @@ import ( govClient "github.com/irisnet/irishub/client/gov" "github.com/irisnet/irishub/modules/gov" "github.com/irisnet/irishub/modules/gov/params" - "github.com/irisnet/irishub/modules/parameter" + "github.com/irisnet/irishub/modules/iparam" "github.com/spf13/cobra" "github.com/spf13/viper" cmn "github.com/tendermint/tendermint/libs/common" @@ -287,17 +287,17 @@ func GetCmdQueryGovConfig(storeName string, cdc *wire.Codec) *cobra.Command { } if keyStr != "" { - parameter.RegisterGovParamMapping(&govparams.DepositProcedureParameter, + iparam.RegisterGovParamMapping(&govparams.DepositProcedureParameter, &govparams.VotingProcedureParameter, &govparams.TallyingProcedureParameter) res, err := ctx.QueryStore([]byte(keyStr), storeName) if err == nil { - if p, ok := parameter.ParamMapping[keyStr]; ok { + if p, ok := iparam.ParamMapping[keyStr]; ok { p.GetValueFromRawData(cdc, res) //.(govparams.TallyingProcedure) PrintParamStr(p, keyStr) } else { - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidTallyingProcedure, fmt.Sprintf(keyStr+" is not found")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidTallyingProcedure, fmt.Sprintf(keyStr+" is not found")) } } else { return err @@ -314,7 +314,7 @@ func GetCmdQueryGovConfig(storeName string, cdc *wire.Codec) *cobra.Command { return cmd } -func PrintParamStr(p parameter.GovParameter, keyStr string) { +func PrintParamStr(p iparam.GovParameter, keyStr string) { var param gov.Param param.Key = keyStr param.Value = p.ToJson() @@ -351,7 +351,7 @@ func (pd *ParameterConfigFile) WriteFile(cdc *wire.Codec, res []sdk.KVPair) erro case "Gov/gov/TallyingProcedure": cdc.MustUnmarshalBinary(kv.Value, &pd.Govparams.TallyingProcedure) default: - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidTallyingProcedure, fmt.Sprintf(string(kv.Key)+" is not found")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidTallyingProcedure, fmt.Sprintf(string(kv.Key)+" is not found")) } } output, err := cdc.MarshalJSONIndent(pd, "", " ") @@ -384,7 +384,7 @@ func (pd *ParameterConfigFile) GetParamFromKey(keyStr string, opStr string) (gov case "Gov/gov/TallyingProcedure": jsonBytes, err = json.Marshal(pd.Govparams.TallyingProcedure) default: - return param, sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidTallyingProcedure, fmt.Sprintf(keyStr+" is not found")) + return param, sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidTallyingProcedure, fmt.Sprintf(keyStr+" is not found")) } if err != nil { diff --git a/cmd/irisdebug/hack.go b/cmd/irisdebug/hack.go index de636446f..99cd3cc50 100644 --- a/cmd/irisdebug/hack.go +++ b/cmd/irisdebug/hack.go @@ -28,7 +28,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/stake" iris "github.com/irisnet/irishub/app" - "github.com/irisnet/irishub/modules/iparams" "github.com/irisnet/irishub/modules/upgrade" "github.com/irisnet/irishub/modules/gov" ) @@ -151,7 +150,6 @@ type IrisApp struct { slashingKeeper slashing.Keeper paramsKeeper params.Keeper govKeeper gov.Keeper - iparamsKeeper iparams.Keeper upgradeKeeper upgrade.Keeper // fee manager @@ -189,14 +187,13 @@ func NewIrisApp(logger log.Logger, db dbm.DB, baseAppOptions ...func(*bam.BaseAp // add handlers app.paramsKeeper = params.NewKeeper(cdc, app.keyParams) - app.iparamsKeeper = iparams.NewKeeper(app.cdc, app.keyIparams) app.coinKeeper = bank.NewKeeper(app.accountMapper) app.ibcMapper = ibc.NewMapper(app.cdc, app.keyIBC, app.RegisterCodespace(ibc.DefaultCodespace)) app.stakeKeeper = stake.NewKeeper(app.cdc, app.keyStake, app.coinKeeper, app.RegisterCodespace(stake.DefaultCodespace)) app.slashingKeeper = slashing.NewKeeper(app.cdc, app.keySlashing, app.stakeKeeper, app.paramsKeeper.Getter(), app.RegisterCodespace(slashing.DefaultCodespace)) app.feeCollectionKeeper = auth.NewFeeCollectionKeeper(app.cdc, app.keyFeeCollection) - app.upgradeKeeper = upgrade.NewKeeper(app.cdc, app.keyUpgrade, app.stakeKeeper, app.iparamsKeeper.GovSetter()) - app.govKeeper = gov.NewKeeper(app.cdc, app.keyGov, app.iparamsKeeper.GovSetter(), app.coinKeeper, app.stakeKeeper, app.RegisterCodespace(gov.DefaultCodespace)) + app.upgradeKeeper = upgrade.NewKeeper(app.cdc, app.keyUpgrade, app.stakeKeeper) + app.govKeeper = gov.NewKeeper(app.cdc, app.keyGov, app.coinKeeper, app.stakeKeeper, app.RegisterCodespace(gov.DefaultCodespace)) // register message routes app.Router(). diff --git a/docs/modules/gov/README.md b/docs/modules/gov/README.md index 30507e2da..3fc2c3e47 100644 --- a/docs/modules/gov/README.md +++ b/docs/modules/gov/README.md @@ -1,105 +1,260 @@ -# Governance +# Gov/Iparam User Guide -## Initialize the runtime environment of blockchain +## Basic Function Description + +1. On-chain governance proposals on text +2. On-chain governance proposals on parameter change +3. On-chain governance proposals on software upgrade （unavailable) + +## Interactive process + +### governance process + +1. Any users can deposit some tokens to initiate a proposal. Once deposit reaches a certain value `min_deposit`, enter voting period, otherwise it will remain in the deposit period. Others can deposit the proposals on the deposit period. Once the sum of the deposit reaches `min_deposit`, enter voting period. However, if the block-time exceeds `max_deposit_period` in the deposit period, the proposal will be closed. +2. The proposals which enter voting period only can be voted by validators and delegators. The vote of a delegator who hasn't vote will be the same as his validator's vote, and the vote of a delegator who has voted will be remained. The votes wil be tallyed when reach `voting_period'. +3. More details about voting for proposals: +[CosmosSDK-Gov-spec](https://github.com/cosmos/cosmos-sdk/blob/develop/docs/spec/governance/overview.md) + +## Usage Scenario +### Create an environment ``` -rm -rf .iris +rm -rf iris rm -rf .iriscli -iris init gen-tx --name=iris -iris init --gen-txs --chain-id=gov-test -iris start - +iris init gen-tx --name=x --home=iris +iris init --gen-txs --chain-id=gov-test -o --home=iris +iris start --home=iris ``` -## Proposal process +### Usage scenario of parameter change + +Scenario 1：Change the parameters through the command lines -Here is an example of "parameter modification proposal". Other proposals do not need parameter "--params". For instance, sometimes we find there are a lot of useless proposals in the system, probably because the current minimum delegating amount is too small, so that many people submit meaningless ones. Here we can use "parameter modification proposal" to modify the system default minimum parameter of “delegating amount”. Firstly we need to know the value of key of this parameter before modification. The following command can be used to view: ``` -iriscli params export gov +# Query parameters can be changed by the modules'name in gov +iriscli gov query-params --module=gov --trust-node + +# Results +[ + "Gov/gov/DepositProcedure", + "Gov/gov/TallyingProcedure", + "Gov/gov/VotingProcedure" +] + +# Query parameters can be modified by "key” +iriscli gov query-params --key=Gov/gov/DepositProcedure --trust-node + +# Results +{"key":"Gov/gov/DepositProcedure","value":"{\"min_deposit\":[{\"denom\":\"iris-atto\",\"amount\":\"10000000000000000000\"}],\"max_deposit_period\":10}","op":""} + +# Send proposals, return changed parameters +echo 1234567890 | iriscli gov submit-proposal --title="update MinDeposit" --description="test" --type="ParameterChange" --deposit="10iris" --param='{"key":"Gov/gov/DepositProcedure","value":"{\"min_deposit\":[{\"denom\":\"iris-atto\",\"amount\":\"10000000000000000000\"}],\"max_deposit_period\":20}","op":"update"}' --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 + +# Deposit for a proposal +echo 1234567890 | iriscli gov deposit --proposal-id=1 --deposit=1iris --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 + +# Vote for a proposal +echo 1234567890 | iriscli gov vote --proposal-id=1 --option=Yes --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 + +# Query the state of a proposal +iriscli gov query-proposal --proposal-id=1 --trust-node + ``` -This command will export all the parameters that can be modified with the "parameter modification proposal". For instance, we get the following results: + +Scenario 2: Change the parameters by the files ``` -[ - { - "key": "gov/depositprocedure/deposit", - "value": "10000000000000000000iris" - }, - { - "key": "gov/depositprocedure/maxDepositPeriod", - "value": "10" - }, - { - "key": "gov/feeToken/gasPriceThreshold", - "value": "20000000000" - }, - { - "key": "gov/tallyingprocedure/penalty", - "value": "1/100" - }, - { - "key": "gov/tallyingprocedure/threshold", - "value": "1/2" - }, - { - "key": "gov/tallyingprocedure/veto", - "value": "1/3" - }, - { - "key": "gov/votingprocedure/votingPeriod", - "value": "20" +# Export profiles +iriscli gov pull-params --path=iris --trust-node + +# Query profiles' info +cat iris/config/params.json +{ + "gov": { + "Gov/gov/DepositProcedure": { + "min_deposit": [ + { + "denom": "iris-atto", + "amount": "10000000000000000000" + } + ], + "max_deposit_period": "10" + }, + "Gov/gov/VotingProcedure": { + "voting_period": "10" + }, + "Gov/gov/TallyingProcedure": { + "threshold": "1/2", + "veto": "1/3", + "governance_penalty": "1/100" + } } -] +} +# Modify profiles (TallyingProcedure的governance_penalty) +vi iris/config/params.json +{ + "gov": { + "Gov/gov/DepositProcedure": { + "min_deposit": [ + { + "denom": "iris-atto", + "amount": "10000000000000000000" + } + ], + "max_deposit_period": "10" + }, + "Gov/gov/VotingProcedure": { + "voting_period": "10" + }, + "Gov/gov/TallyingProcedure": { + "threshold": "1/2", + "veto": "1/3", + "governance_penalty": "20/100" + } + } +} + +# Change the parameters through files, return changed parameters +echo 1234567890 | iriscli gov submit-proposal --title="update MinDeposit" --description="test" --type="ParameterChange" --deposit="10iris" --path=iris --key=Gov/gov/TallyingProcedure --op=update --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 + +# Deposit for a proposal +echo 1234567890 | iriscli gov deposit --proposal-id=1 --deposit=1iris --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 +# Vote for a proposal +echo 1234567890 | iriscli gov vote --proposal-id=1 --option=Yes --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 + +# Query the state of a proposal +iriscli gov query-proposal --proposal-id=1 --trust-node ``` -Each (key, value) is corresponding to a set of system-preset modifiable parameters, the specific meaning of which will be updated in future documents. The key of minimum delegating amount here is gov/depositprocedure/deposit. At present, value=10000000000000000000iris（This is the value after the decimal-binary conversion, refering to the “fee-token” module for details.）. To raise the threshold of proposals, it will be doubled to 20000000000000000000iris. The following command can be used: +## CLI Command Details + +### Basic method of gov modules + +``` +# Text proposals +iriscli gov submit-proposal --title="update MinDeposit" --description="test" --type="Text" --deposit="10iris" --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 ``` -iriscli gov submit-proposal --title="update MinDeposit" --description="test" --type="ParameterChange" - --deposit="9000000000000000000iris" - --params='[{"key":"gov/depositprocedure/deposit","value":"20000000000000000001iris","op":"update"}]' - --proposer=faa1pkunlumfyglqd9dgup0mwp66kjrp6y09twmuvd - --from=iris - --chain-id=gov-test - --fee=400000000000000iris - --gas=20000 +* `--title` The title of a proposal +* `--description` The description of a proposal +* `--type` The type of a proposal {'Text','ParameterChange','SoftwareUpgrade'} +* `--deposit` The number of the tokens deposited +* The basic text proposals are as below + +``` +iriscli gov deposit --proposal-id=1 --deposit=1iris --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 ``` -Here I delegate 9000000000000000000iris, which is 1000000000000000000iris less than the minimum delegating amount, so the proposal has not been activated can not be voted. 10000000000000000000 more iris should be delegated in 10 (key:gov/depositprocedure/maxDepositPeriod) blocks (If it needs 5s to produce a block, it means you need to complete the delegation in 5 * 10s). The delegating command is as follows: +* `--propsal-id` The ID of the proposal deposited +* `--deposit` The number of the tokens deposited ``` -iriscli gov deposit --proposalID=1 - --depositer=faa1pkunlumfyglqd9dgup0mwp66kjrp6y09twmuvd - --deposit=1000000000000000000iris - --from=iris - --chain-id=gov-test - --fee=200000000000000iris - --gas=20000 +iriscli gov vote --proposal-id=1 --option=Yes --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 +``` +* `--proposal-id` The ID of the proposal in voting period +* `--option` Vote option{'Yes'-agree,'Abstain'-abstain,'No'-disagree,'nowithVeto'-strongly disagree } + + +``` +# Query the state of a proposal +iriscli gov query-proposal --proposal-id=1 --trust-node +``` + +* `--proposal-id` Query the ID of a proposal + + + +### The proposals on parameters modification + +``` +# Query parameters can be modified by the modules'name in gov +iriscli gov query-params --module=gov --trust-node +``` + +* `--module` Query the list of "key" of the parameters can be changed in the module + + +``` +# Query the parameters can be modified by "key" +iriscli gov query-params --key=Gov/gov/DepositProcedure --trust-node ``` -The above proposalID is the result from the first step. At this stage, we delegate 1000000000000000000iris tokens, which is exactly equal to the minimum delegating amount, so the proposal can be voted. And the proposer can send a voting request to each validators (currently only off-chain notification is available, but on-chain or monitoring notification will be implemented later). Then each validators can view the proposal first with the following command: + +* `--key` Query the parameter corresponding to the "key" ``` -iriscli gov query-proposal --proposalID=1 +# Export profiles +iriscli gov pull-params --path=iris --trust-node ``` -Later proposers can vote as they wish, here I vote Yes (option=Yes): +* `--path` The folder of node initialization + + ``` -iriscli gov vote --proposalID=1 - --voter=faa1pkunlumfyglqd9dgup0mwp66kjrp6y09twmuvd - --option=Yes - --from=iris - --chain-id=gov-test - --fee=400000000000000iris - --gas=20000 +# Modify the parameters through the command lines +iriscli gov submit-proposal --title="update MinDeposit" --description="test" --type="ParameterChange" --deposit="10iris" --param='{"key":"Gov/gov/DepositProcedure","value":"{\"min_deposit\":[{\"denom\":\"iris-atto\",\"amount\":\"10000000000000000000\"}],\"max_deposit_period\":20}","op":"update"}' --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 ``` -Notice that the maximum of waiting time is in 20 blocks during the voting period (key: gov/votingprocedure/votingPeriod). If the percentage of affirmative vote is still less than 50% during this period (key: gov/tallyingprocedure/threshold), the proposal will not be passed and the tokens delegated will also not be refunded (the validators haven't voted will be slashed, and 1/100 of the total tokens delegated currently will be deducted (key: gov/tallyingprocedure/penalty). This mechanism has not been implemented in current version ). Suppose there is only one validator. If I voted yes, the ratio of affirmative vote is 1>1/2 and the strong negative vote is 0<1/3 (key:gov/tallyingprocedure/veto), the proposal will be passed. After voting, the proposal is automatically executed: (key: gov/depositprocedure/deposit, value: 10000000000000000000iris) is modified to (key: gov/depositprocedure/deposit, value: 20000000000000000000iris). Then we can verify this result and query the minimum delegating amount in current system: +* `--param` The details of changed parameters （get parameters through query-params, modify it and then add "update" on the "op", more details in usage scenarios） +* Other fields' proposals are similar with text proposal ``` -iriscli iriscli params export gov/depositprocedure/deposit +# Change the parameters through files, return modified parameters +echo 1234567890 | iriscli gov submit-proposal --title="update MinDeposit" --description="test" --type="ParameterChange" --deposit="10iris" --path=iris --key=Gov/gov/TallyingProcedure --op=update --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 +``` + +* `--path` The folder of node initialization +* `--key` The key of the parameter to be modified +* `--op` The type of changed parameters; only 'update' is implemented at present +* Other fields' proposals are similar with text proposal + +### Proposals on software upgrade + +## Basic parameters + +``` +# DepositProcedure（The parameters in deposit period） +"Gov/gov/DepositProcedure": { + "min_deposit": [ + { + "denom": "iris-atto", + "amount": "10000000000000000000" + } + ], + "max_deposit_period": "10" +} +``` + +* Parameters can be changed +* The key of parameters:"Gov/gov/DepositProcedure" +* `min_deposit[0].denom` The minimum tokens deposited are counted by iris-atto. +* `min_deposit[0].amount` The number of minimum tokens and the default scope：10iris,（1iris，200iris） +* `max_deposit_period` Window period for repaying deposit, default :10， scope（0，1） + +``` +# VotingProcedure（The parameters in voting period） +"Gov/gov/VotingProcedure": { + "voting_period": "10" +}, +``` + +* Parameters can be changed +* `voting_perid` Window period for vote, default：10, scope（20，20000） + ``` +# TallyingProcedure (The parameters in Tallying period) +"Gov/gov/TallyingProcedure": { + "threshold": "1/2", + "veto": "1/3", + "governance_penalty": "1/100" +} +``` + +* Parameters can be changed +* `veto` default: 1/3, scope（0，1） +* `threshold` default 1/2, scope（0，1） +* `governance_penalty` The default ratio of slashing tokens of validators who didn't vote: 1/100, scope（0，1） +* Vote rules: If the ratio of voting power of "strongly disagree" over "veto", the proposal won't be passed. If the ratio of voting_power of "agree" over "veto", the proposal won't be passed. Otherwise, it will be passed. -This is the end of the governance process. diff --git a/docs/zh/modules/gov/README.md b/docs/zh/modules/gov/README.md index 2763a4621..a2f99bfe3 100644 --- a/docs/zh/modules/gov/README.md +++ b/docs/zh/modules/gov/README.md @@ -10,8 +10,8 @@ ### 治理流程 -1. 任何用户可以发起提议，并抵押一部分资金，如果超过`min_deposit`,提议进入投票，否则留在抵押期。其他人可以对在抵押期的提议进行抵押资金，如果提议的抵押资金总和超过`min_deposit`,则进入投票期。但是提议在抵押期停留的区块数目超过`max_deposit_period`，则提议被关闭。 -2. 进入投票期的提议，只有验证人和委托人可以进行投票，委托人如果没投票，则他继承他委托的验证人的投票选项，如果委托人投票了，则覆盖他委托的验证人的投票选项，当提议到达`voting_perid`,统计投票结果。 +1. 任何用户可以发起提议，并抵押一部分token，如果超过`min_deposit`,提议进入投票，否则留在抵押期。其他人可以对在抵押期的提议进行抵押token，如果提议的抵押token总和超过`min_deposit`,则进入投票期。但若提议在抵押期停留的出块数目超过`max_deposit_period`，则提议被关闭。 +2. 进入投票期的提议，只有验证人和委托人可以进行投票。如果委托人没投票，则他继承他委托的验证人的投票选项。如果委托人投票了，则覆盖他委托的验证人的投票选项。当提议到达`voting_perid`,统计投票结果。 3. 具体提议投票逻辑细节见[CosmosSDK-Gov-spec](https://github.com/cosmos/cosmos-sdk/blob/develop/docs/spec/governance/overview.md) ## 使用场景 @@ -138,7 +138,7 @@ iriscli gov submit-proposal --title="update MinDeposit" --description="test" --t * `--title` 提议的标题 * `--description` 提议的描述 * `--type` 提议的类型 {'Text','ParameterChange','SoftwareUpgrade'} -* `--deposit` 抵押贷币的数量 +* `--deposit` 抵押的token数量 * 上面就是典型的文本类提议 ``` @@ -146,7 +146,7 @@ iriscli gov deposit --proposal-id=1 --deposit=1iris --from=x --chain-id=gov-test ``` * `--propsal-id` 抵押提议ID -* `--deposit` 抵押的贷币数目 +* `--deposit` 抵押的token数量 ``` iriscli gov vote --proposal-id=1 --option=Yes --from=x --chain-id=gov-test --fee=0.05iris --gas=20000 @@ -228,9 +228,9 @@ echo 1234567890 | iriscli gov submit-proposal --title="update MinDeposit" --desc * 可修改参数 * 参数的key:"Gov/gov/DepositProcedure" -* `min_deposit[0].denom` 最小抵押贷币的token只能是单位是iris-atto的iris通证。 -* `min_deposit[0].amount` 最小抵押贷币的数量,默认范围:10iris（1iris，200iris） -* `max_deposit_period` 补交抵押的窗口期,默认:10 范围（0，1） +* `min_deposit[0].denom` 最小抵押token只能是单位是iris-atto的iris通证。 +* `min_deposit[0].amount` 最小抵押token数量,默认:10iris,范围（1iris，200iris） +* `max_deposit_period` 补交抵押token的窗口期,默认:10,范围（0，1） ``` # VotingProcedure（投票阶段的参数） @@ -239,7 +239,7 @@ echo 1234567890 | iriscli gov submit-proposal --title="update MinDeposit" --desc }, ``` -* `voting_perid` 投票的窗口期,默认10,范围（20，20000） +* `voting_perid` 投票的窗口期,默认:10,范围（20，20000） ``` # TallyingProcedure (统计阶段段参数) @@ -249,9 +249,9 @@ echo 1234567890 | iriscli gov submit-proposal --title="update MinDeposit" --desc "governance_penalty": "1/100" } ``` -* `veto` 默认1/3,范围（0，1） -* `threshold` 默认1/2,范围（0，1） -* `governance_penalty` 未投票的验证人惩罚贷币的比例 默认1/100,范围（0，1） +* `veto` 默认:1/3,范围（0，1） +* `threshold` 默认:1/2,范围（0，1） +* `governance_penalty` 未投票的验证人惩罚token的比例 默认:1/100,范围（0，1） * 投票统计逻辑：如果强烈反对的voting_power占总的voting_power 超过 veto,提议不通过。然后再看赞同的voting_power占总的投票的voting_power 是否超过 veto,超过则提议不通过,不超过则不通过。 diff --git a/docs/zh/modules/upgrade/README.md b/docs/zh/modules/upgrade/README.md new file mode 100644 index 000000000..fb5f2d399 --- /dev/null +++ b/docs/zh/modules/upgrade/README.md @@ -0,0 +1,22 @@ +# Upgrade User Guide + +## 基本功能描述 + +该模块支持区块链软件平滑升级的基础设施，通过UpgradeProposal和switch两阶段的投票来在约定高度切换到新版的代码，并对历史版本的链上数据完全兼容。 +## 交互流程 + +### 软件升级提议治理流程 +1. 用户提交升级软件提议 +2. 治理流程详细见[]() +3. +### 升级软件流程 +1. 用户安装新软件，并发送switch消息，广播全网自己已经安装新软件。 +2. + +## 使用场景 + +iriscli upgrade submit-switch --name=x --from=$VADDR --proposalID=1 --chain-id=upgrade-test --fee=20000000000000000iris + +iris start --replay + +## 命令详情 \ No newline at end of file diff --git a/modules/gov/errors.go b/modules/gov/errors.go index 9ca6e6ff4..45e32b14a 100644 --- a/modules/gov/errors.go +++ b/modules/gov/errors.go @@ -22,6 +22,7 @@ const ( CodeInvalidGenesis sdk.CodeType = 10 CodeInvalidProposalStatus sdk.CodeType = 11 CodeInvalidParam sdk.CodeType = 12 + CodeInvalidParamOp sdk.CodeType = 13 ) //---------------------------------------- @@ -68,5 +69,9 @@ func ErrInvalidGenesis(codespace sdk.CodespaceType, msg string) sdk.Error { } func ErrInvalidParam(codespace sdk.CodespaceType) sdk.Error { - return sdk.NewError(codespace, CodeInvalidParam, fmt.Sprintf("Param '%s' is not valid")) + return sdk.NewError(codespace, CodeInvalidParam, fmt.Sprintf("Param is not valid")) +} + +func ErrInvalidParamOp(codespace sdk.CodespaceType, opStr string) sdk.Error { + return sdk.NewError(codespace, CodeInvalidParamOp, fmt.Sprintf("Op '%s' is not valid", opStr)) } \ No newline at end of file diff --git a/modules/gov/genesis.go b/modules/gov/genesis.go index 9efe5fa59..f9a597945 100644 --- a/modules/gov/genesis.go +++ b/modules/gov/genesis.go @@ -3,7 +3,7 @@ package gov import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/irisnet/irishub/modules/gov/params" - "github.com/irisnet/irishub/modules/parameter" + "github.com/irisnet/irishub/modules/iparam" ) // GenesisState - all staking state that must be provided at genesis @@ -31,9 +31,9 @@ func InitGenesis(ctx sdk.Context, k Keeper, data GenesisState) { panic(err) } //k.setDepositProcedure(ctx, data.DepositProcedure) - parameter.InitGenesisParameter(&govparams.DepositProcedureParameter, ctx, data.DepositProcedure) - parameter.InitGenesisParameter(&govparams.VotingProcedureParameter, ctx, data.VotingProcedure) - parameter.InitGenesisParameter(&govparams.TallyingProcedureParameter, ctx, data.TallyingProcedure) + iparam.InitGenesisParameter(&govparams.DepositProcedureParameter, ctx, data.DepositProcedure) + iparam.InitGenesisParameter(&govparams.VotingProcedureParameter, ctx, data.VotingProcedure) + iparam.InitGenesisParameter(&govparams.TallyingProcedureParameter, ctx, data.TallyingProcedure) } diff --git a/modules/gov/keeper.go b/modules/gov/keeper.go index fc15f2208..77a0c0efb 100644 --- a/modules/gov/keeper.go +++ b/modules/gov/keeper.go @@ -5,15 +5,12 @@ import ( "github.com/cosmos/cosmos-sdk/wire" "github.com/cosmos/cosmos-sdk/x/bank" "github.com/irisnet/irishub/modules/gov/params" - "github.com/irisnet/irishub/modules/iparams" ) // nolint // Governance Keeper type Keeper struct { - // The reference to the ParamSetter to get and set Global Params - ps iparams.GovSetter // The reference to the CoinKeeper to modify balances ck bank.Keeper @@ -35,10 +32,9 @@ type Keeper struct { } // NewGovernanceMapper returns a mapper that uses go-wire to (binary) encode and decode gov types. -func NewKeeper(cdc *wire.Codec, key sdk.StoreKey, ps iparams.GovSetter, ck bank.Keeper, ds sdk.DelegationSet, codespace sdk.CodespaceType) Keeper { +func NewKeeper(cdc *wire.Codec, key sdk.StoreKey, ck bank.Keeper, ds sdk.DelegationSet, codespace sdk.CodespaceType) Keeper { return Keeper{ storeKey: key, - ps: ps, ck: ck, ds: ds, vs: ds.GetValidatorSet(), diff --git a/modules/gov/msgs.go b/modules/gov/msgs.go index 619ea13c1..ea3048af6 100644 --- a/modules/gov/msgs.go +++ b/modules/gov/msgs.go @@ -4,7 +4,7 @@ import ( "fmt" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/irisnet/irishub/modules/parameter" + "github.com/irisnet/irishub/modules/iparam" ) // name to idetify transaction types @@ -58,13 +58,18 @@ func (msg MsgSubmitProposal) ValidateBasic() sdk.Error { if msg.ProposalType == ProposalTypeParameterChange { - if p, ok := parameter.ParamMapping[msg.Param.Key]; ok{ + if p, ok := iparam.ParamMapping[msg.Param.Key]; ok{ return p.Valid(msg.Param.Value) } else { return ErrInvalidParam(DefaultCodespace) } } + + if msg.Param.Op != Update && msg.Param.Op != Insert { + return ErrInvalidParamOp(DefaultCodespace, msg.Param.Op) + } + return nil } diff --git a/modules/gov/params/gov_params.go b/modules/gov/params/gov_params.go index 12298c580..76c5bf7f8 100644 --- a/modules/gov/params/gov_params.go +++ b/modules/gov/params/gov_params.go @@ -6,9 +6,8 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/params" "github.com/irisnet/irishub/types" - "github.com/irisnet/irishub/modules/parameter" + "github.com/irisnet/irishub/modules/iparam" "github.com/cosmos/cosmos-sdk/wire" - "strconv" ) @@ -22,7 +21,7 @@ var ( const LOWER_BOUND_AMOUNT = 1 const UPPER_BOUND_AMOUNT = 200 -var _ parameter.GovParameter = (*DepositProcedureParam)(nil) +var _ iparam.GovParameter = (*DepositProcedureParam)(nil) type ParamSet struct { DepositProcedure DepositProcedure `json:"Gov/gov/DepositProcedure"` @@ -96,30 +95,30 @@ func (param *DepositProcedureParam) Valid(jsonStr string) sdk.Error { if err = json.Unmarshal([]byte(jsonStr), ¶m.Value); err == nil { if param.Value.MinDeposit[0].Denom != "iris-atto" { - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidMinDepositDenom, fmt.Sprintf("It should be iris-atto! git")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidMinDepositDenom, fmt.Sprintf("It should be iris-atto! git")) } LowerBound, _ := types.NewDefaultCoinType("iris").ConvertToMinCoin(fmt.Sprintf("%d%s", LOWER_BOUND_AMOUNT, "iris")) UpperBound, _ := types.NewDefaultCoinType("iris").ConvertToMinCoin(fmt.Sprintf("%d%s", UPPER_BOUND_AMOUNT, "iris")) if param.Value.MinDeposit[0].Amount.LT(LowerBound.Amount) || param.Value.MinDeposit[0].Amount.GT(UpperBound.Amount) { - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidMinDepositAmount, fmt.Sprintf("MinDepositAmount"+param.Value.MinDeposit[0].String()+" should be larger than 10 and less than 20000")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidMinDepositAmount, fmt.Sprintf("MinDepositAmount"+param.Value.MinDeposit[0].String()+" should be larger than 1iris and less than 20000iris")) } if param.Value.MaxDepositPeriod < 20 || param.Value.MaxDepositPeriod > 20000 { - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidDepositPeriod, fmt.Sprintf("MaxDepositPeriod ("+strconv.Itoa(int(param.Value.MaxDepositPeriod))+") should be larger than 20 and less than 20000")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidDepositPeriod, fmt.Sprintf("MaxDepositPeriod ("+strconv.Itoa(int(param.Value.MaxDepositPeriod))+") should be larger than 20 and less than 20000")) } return nil } - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidMinDeposit, fmt.Sprintf("Json is not valid")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidMinDeposit, fmt.Sprintf("Json is not valid")) } var VotingProcedureParameter VotingProcedureParam -var _ parameter.GovParameter = (*VotingProcedureParam)(nil) +var _ iparam.GovParameter = (*VotingProcedureParam)(nil) // Procedure around Voting in governance type VotingProcedure struct { @@ -184,17 +183,17 @@ func (param *VotingProcedureParam) Valid(jsonStr string) sdk.Error { if err = json.Unmarshal([]byte(jsonStr), ¶m.Value); err == nil { if param.Value.VotingPeriod < 20 || param.Value.VotingPeriod > 20000 { - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidVotingPeriod, fmt.Sprintf("VotingPeriod ("+strconv.Itoa(int(param.Value.VotingPeriod))+") should be larger than 20 and less than 20000")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidVotingPeriod, fmt.Sprintf("VotingPeriod ("+strconv.Itoa(int(param.Value.VotingPeriod))+") should be larger than 20 and less than 20000")) } return nil } - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidVotingProcedure, fmt.Sprintf("Json is not valid")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidVotingProcedure, fmt.Sprintf("Json is not valid")) } var TallyingProcedureParameter TallyingProcedureParam -var _ parameter.GovParameter = (*TallyingProcedureParam)(nil) +var _ iparam.GovParameter = (*TallyingProcedureParam)(nil) // Procedure around Tallying votes in governance type TallyingProcedure struct { @@ -266,19 +265,19 @@ func (param *TallyingProcedureParam) Valid(jsonStr string) sdk.Error { if err = json.Unmarshal([]byte(jsonStr), ¶m.Value); err == nil { if param.Value.Threshold.LT(sdk.NewRat(0)) || param.Value.Threshold.GT(sdk.NewRat(1)) { - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidThreshold, fmt.Sprintf("VotingPeriod ( "+param.Value.Threshold.String()+" ) should be between 0 and 1")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidThreshold, fmt.Sprintf("VotingPeriod ( "+param.Value.Threshold.String()+" ) should be between 0 and 1")) } if param.Value.GovernancePenalty.LT(sdk.NewRat(0)) || param.Value.GovernancePenalty.GT(sdk.NewRat(1)) { - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidGovernancePenalty, fmt.Sprintf("VotingPeriod ( "+param.Value.GovernancePenalty.String()+" ) should be between 0 and 1")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidGovernancePenalty, fmt.Sprintf("VotingPeriod ( "+param.Value.GovernancePenalty.String()+" ) should be between 0 and 1")) } if param.Value.Veto.LT(sdk.NewRat(0)) || param.Value.Veto.GT(sdk.NewRat(1)) { - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidVeto, fmt.Sprintf("VotingPeriod ( "+param.Value.Veto.String()+" ) should be between 0 and 1")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidVeto, fmt.Sprintf("VotingPeriod ( "+param.Value.Veto.String()+" ) should be between 0 and 1")) } return nil } - return sdk.NewError(parameter.DefaultCodespace, parameter.CodeInvalidTallyingProcedure, fmt.Sprintf("Json is not valid")) + return sdk.NewError(iparam.DefaultCodespace, iparam.CodeInvalidTallyingProcedure, fmt.Sprintf("Json is not valid")) } diff --git a/modules/gov/params/gov_params_test.go b/modules/gov/params/gov_params_test.go index b26351edd..4129a3c3f 100644 --- a/modules/gov/params/gov_params_test.go +++ b/modules/gov/params/gov_params_test.go @@ -55,35 +55,9 @@ func TestDepositProcedureParam(t *testing.T) { result := DepositProcedureParameter.Valid("{\"min_deposit\":[{\"denom\":\"atom\",\"amount\":\"200000000000000000000\"}],\"max_deposit_period\":1440}") require.Error(t, result) - DepositProcedureParameter.InitGenesis(p2) - require.Equal(t, p2, DepositProcedureParameter.Value) - DepositProcedureParameter.InitGenesis(p1) - require.Equal(t, p1, DepositProcedureParameter.Value) - - DepositProcedureParameter.LoadValue(ctx) - require.Equal(t, p2, DepositProcedureParameter.Value) - -} - -func TestDepositProcedureParamValid(t *testing.T) { - skey := sdk.NewKVStoreKey("params") - ctx := defaultContext(skey) - paramKeeper := params.NewKeeper(wire.NewCodec(), skey) - - p1deposit, _ := types.NewDefaultCoinType("iris").ConvertToMinCoin(fmt.Sprintf("%d%s", 10, "iris")) - p1 := DepositProcedure{ - MinDeposit: sdk.Coins{p1deposit}, - MaxDepositPeriod: 1440} - - DepositProcedureParameter.SetReadWriter(paramKeeper.Setter()) - find := DepositProcedureParameter.LoadValue(ctx) - require.Equal(t, find, false) - - DepositProcedureParameter.InitGenesis(nil) - require.Equal(t, p1, DepositProcedureParameter.Value) - - result := DepositProcedureParameter.Valid("{\"min_deposit\":[{\"denom\":\"iris-atto\",\"amount\":\"2000000000000000000\"}],\"max_deposit_period\":1440}") + result = DepositProcedureParameter.Valid("{\"min_deposit\":[{\"denom\":\"iris-atto\",\"amount\":\"2000000000000000000\"}],\"max_deposit_period\":1440}") require.NoError(t, result) + result = DepositProcedureParameter.Valid("{\"min_deposit\":[{\"denom\":\"iris-atto\",\"amount\":\"2000000000000000000000\"}],\"max_deposit_period\":1440}") require.Error(t, result) result = DepositProcedureParameter.Valid("{\"min_deposit\":[{\"denom\":\"iris-atto\",\"amount\":\"200000000000000000\"}],\"max_deposit_period\":1440}") @@ -101,6 +75,14 @@ func TestDepositProcedureParamValid(t *testing.T) { result = DepositProcedureParameter.Valid("{\"min_deposit\":[{\"denom\":\"iris-atto\",\"amount\":\"2000000000000000000\"}],\"max_deposit_period\":1440000}") require.Error(t, result) + DepositProcedureParameter.InitGenesis(p2) + require.Equal(t, p2, DepositProcedureParameter.Value) + DepositProcedureParameter.InitGenesis(p1) + require.Equal(t, p1, DepositProcedureParameter.Value) + + DepositProcedureParameter.LoadValue(ctx) + require.Equal(t, p2, DepositProcedureParameter.Value) + } func TestVotingProcedureParam(t *testing.T) { diff --git a/modules/gov/proposal_params.go b/modules/gov/proposal_params.go index 70ddaa5e2..3c27741ec 100644 --- a/modules/gov/proposal_params.go +++ b/modules/gov/proposal_params.go @@ -3,7 +3,7 @@ package gov import ( "fmt" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/irisnet/irishub/modules/parameter" + "github.com/irisnet/irishub/modules/iparam" ) const ( @@ -30,7 +30,7 @@ func (pp *ParameterProposal) Execute(ctx sdk.Context, k Keeper) (err error) { logger := ctx.Logger().With("module", "x/gov") logger.Info("Execute ParameterProposal begin", "info", fmt.Sprintf("current height:%d", ctx.BlockHeight())) if pp.Param.Op == Update { - parameter.ParamMapping[pp.Param.Key].Update(ctx, pp.Param.Value) + iparam.ParamMapping[pp.Param.Key].Update(ctx, pp.Param.Value) } else if pp.Param.Op == Insert { //Todo: insert } diff --git a/modules/gov/test_common.go b/modules/gov/test_common.go index a33150b0b..c993d7392 100644 --- a/modules/gov/test_common.go +++ b/modules/gov/test_common.go @@ -16,7 +16,6 @@ import ( "github.com/cosmos/cosmos-sdk/x/mock" "github.com/cosmos/cosmos-sdk/x/stake" "github.com/irisnet/irishub/modules/gov/params" - "github.com/irisnet/irishub/modules/iparams" "github.com/irisnet/irishub/types" ) @@ -31,10 +30,9 @@ func getMockApp(t *testing.T, numGenAccs int) (*mock.App, Keeper, stake.Keeper, keyStake := sdk.NewKVStoreKey("stake") keyGov := sdk.NewKVStoreKey("gov") - pk := iparams.NewKeeper(mapp.Cdc, keyGlobalParams) ck := bank.NewKeeper(mapp.AccountMapper) sk := stake.NewKeeper(mapp.Cdc, keyStake, ck, mapp.RegisterCodespace(stake.DefaultCodespace)) - keeper := NewKeeper(mapp.Cdc, keyGov, pk.GovSetter(), ck, sk, DefaultCodespace) + keeper := NewKeeper(mapp.Cdc, keyGov, ck, sk, DefaultCodespace) mapp.Router().AddRoute("gov", NewHandler(keeper)) mapp.SetEndBlocker(getEndBlocker(keeper)) diff --git a/modules/parameter/errors.go b/modules/iparam/errors.go similarity index 98% rename from modules/parameter/errors.go rename to modules/iparam/errors.go index 892d6b259..2a72be310 100644 --- a/modules/parameter/errors.go +++ b/modules/iparam/errors.go @@ -1,4 +1,4 @@ -package parameter +package iparam import ( sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/modules/parameter/helper.go b/modules/iparam/helper.go similarity index 97% rename from modules/parameter/helper.go rename to modules/iparam/helper.go index 65d0c5c83..fe71c785b 100644 --- a/modules/parameter/helper.go +++ b/modules/iparam/helper.go @@ -1,4 +1,4 @@ -package parameter +package iparam import ( sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/modules/parameter/helper_test.go b/modules/iparam/helper_test.go similarity index 99% rename from modules/parameter/helper_test.go rename to modules/iparam/helper_test.go index 6325d333b..d34c551e9 100644 --- a/modules/parameter/helper_test.go +++ b/modules/iparam/helper_test.go @@ -1,4 +1,4 @@ -package parameter +package iparam import ( "github.com/cosmos/cosmos-sdk/store" diff --git a/modules/parameter/parameter.go b/modules/iparam/parameter.go similarity index 97% rename from modules/parameter/parameter.go rename to modules/iparam/parameter.go index 90f4d35f6..b32cb98ee 100644 --- a/modules/parameter/parameter.go +++ b/modules/iparam/parameter.go @@ -1,4 +1,4 @@ -package parameter +package iparam import ( sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/modules/iparams/getter.go b/modules/iparams/getter.go deleted file mode 100644 index 73228a244..000000000 --- a/modules/iparams/getter.go +++ /dev/null @@ -1,523 +0,0 @@ -package iparams - -import ( - "fmt" - sdk "github.com/cosmos/cosmos-sdk/types" - "strings" -) - -type Getter interface { - Get(ctx sdk.Context, key string, ptr interface{}) error - GetRaw(ctx sdk.Context, key string) []byte - GetString(ctx sdk.Context, key string) (res string, err error) - GetBoolWithDefault(ctx sdk.Context, key string, def bool) (res bool) -} - -// Getter exposes methods related with only getting params -type GlobalGetter struct { - k Keeper -} - -type GovGetter struct { - k Keeper -} - -func getGlobalStoreKey(key string) string { - if strings.HasPrefix(key, Global+"/") { - return key - } - return fmt.Sprintf("%s/%s", Global, key) -} - -func getGovStoreKey(key string) string { - if strings.HasPrefix(key, Gov+"/") { - return key - } - return fmt.Sprintf("%s/%s", Gov, key) -} - -// Get exposes get -func (k GlobalGetter) Get(ctx sdk.Context, key string, ptr interface{}) error { - key = getGlobalStoreKey(key) - return k.k.get(ctx, key, ptr) -} - -// GetRaw exposes getRaw -func (k GlobalGetter) GetRaw(ctx sdk.Context, key string) []byte { - key = getGlobalStoreKey(key) - return k.k.getRaw(ctx, key) -} - -// GetString is helper function for string params -func (k GlobalGetter) GetString(ctx sdk.Context, key string) (res string, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetBool is helper function for bool params -func (k GlobalGetter) GetBool(ctx sdk.Context, key string) (res bool, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetInt16 is helper function for int16 params -func (k GlobalGetter) GetInt16(ctx sdk.Context, key string) (res int16, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetInt32 is helper function for int32 params -func (k GlobalGetter) GetInt32(ctx sdk.Context, key string) (res int32, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetInt64 is helper function for int64 params -func (k GlobalGetter) GetInt64(ctx sdk.Context, key string) (res int64, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetUint16 is helper function for uint16 params -func (k GlobalGetter) GetUint16(ctx sdk.Context, key string) (res uint16, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetUint32 is helper function for uint32 params -func (k GlobalGetter) GetUint32(ctx sdk.Context, key string) (res uint32, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetUint64 is helper function for uint64 params -func (k GlobalGetter) GetUint64(ctx sdk.Context, key string) (res uint64, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetInt is helper function for sdk.Int params -func (k GlobalGetter) GetInt(ctx sdk.Context, key string) (res sdk.Int, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetUint is helper function for sdk.Uint params -func (k GlobalGetter) GetUint(ctx sdk.Context, key string) (res sdk.Uint, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetRat is helper function for rat params -func (k GlobalGetter) GetRat(ctx sdk.Context, key string) (res sdk.Rat, err error) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetStringWithDefault is helper function for string params with default value -func (k GlobalGetter) GetStringWithDefault(ctx sdk.Context, key string, def string) (res string) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetBoolWithDefault is helper function for bool params with default value -func (k GlobalGetter) GetBoolWithDefault(ctx sdk.Context, key string, def bool) (res bool) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetInt16WithDefault is helper function for int16 params with default value -func (k GlobalGetter) GetInt16WithDefault(ctx sdk.Context, key string, def int16) (res int16) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetInt32WithDefault is helper function for int32 params with default value -func (k GlobalGetter) GetInt32WithDefault(ctx sdk.Context, key string, def int32) (res int32) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetInt64WithDefault is helper function for int64 params with default value -func (k GlobalGetter) GetInt64WithDefault(ctx sdk.Context, key string, def int64) (res int64) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetUint16WithDefault is helper function for uint16 params with default value -func (k GlobalGetter) GetUint16WithDefault(ctx sdk.Context, key string, def uint16) (res uint16) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetUint32WithDefault is helper function for uint32 params with default value -func (k GlobalGetter) GetUint32WithDefault(ctx sdk.Context, key string, def uint32) (res uint32) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetUint64WithDefault is helper function for uint64 params with default value -func (k GlobalGetter) GetUint64WithDefault(ctx sdk.Context, key string, def uint64) (res uint64) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetIntWithDefault is helper function for sdk.Int params with default value -func (k GlobalGetter) GetIntWithDefault(ctx sdk.Context, key string, def sdk.Int) (res sdk.Int) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetUintWithDefault is helper function for sdk.Uint params with default value -func (k GlobalGetter) GetUintWithDefault(ctx sdk.Context, key string, def sdk.Uint) (res sdk.Uint) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetRatWithDefault is helper function for sdk.Rat params with default value -func (k GlobalGetter) GetRatWithDefault(ctx sdk.Context, key string, def sdk.Rat) (res sdk.Rat) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// Get exposes get -func (k GovGetter) Get(ctx sdk.Context, key string, ptr interface{}) error { - key = getGovStoreKey(key) - return k.k.get(ctx, key, ptr) -} - -// GetRaw exposes getRaw -func (k GovGetter) GetRaw(ctx sdk.Context, key string) []byte { - key = getGovStoreKey(key) - return k.k.getRaw(ctx, key) -} - -// GetString is helper function for string params -func (k GovGetter) GetString(ctx sdk.Context, key string) (res string, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetBool is helper function for bool params -func (k GovGetter) GetBool(ctx sdk.Context, key string) (res bool, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetInt16 is helper function for int16 params -func (k GovGetter) GetInt16(ctx sdk.Context, key string) (res int16, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetInt32 is helper function for int32 params -func (k GovGetter) GetInt32(ctx sdk.Context, key string) (res int32, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetInt64 is helper function for int64 params -func (k GovGetter) GetInt64(ctx sdk.Context, key string) (res int64, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetUint16 is helper function for uint16 params -func (k GovGetter) GetUint16(ctx sdk.Context, key string) (res uint16, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetUint32 is helper function for uint32 params -func (k GovGetter) GetUint32(ctx sdk.Context, key string) (res uint32, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetUint64 is helper function for uint64 params -func (k GovGetter) GetUint64(ctx sdk.Context, key string) (res uint64, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetInt is helper function for sdk.Int params -func (k GovGetter) GetInt(ctx sdk.Context, key string) (res sdk.Int, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetUint is helper function for sdk.Uint params -func (k GovGetter) GetUint(ctx sdk.Context, key string) (res sdk.Uint, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetRat is helper function for rat params -func (k GovGetter) GetRat(ctx sdk.Context, key string) (res sdk.Rat, err error) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - err = k.k.cdc.UnmarshalBinary(bz, &res) - return -} - -// GetStringWithDefault is helper function for string params with default value -func (k GovGetter) GetStringWithDefault(ctx sdk.Context, key string, def string) (res string) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetBoolWithDefault is helper function for bool params with default value -func (k GovGetter) GetBoolWithDefault(ctx sdk.Context, key string, def bool) (res bool) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetInt16WithDefault is helper function for int16 params with default value -func (k GovGetter) GetInt16WithDefault(ctx sdk.Context, key string, def int16) (res int16) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetInt32WithDefault is helper function for int32 params with default value -func (k GovGetter) GetInt32WithDefault(ctx sdk.Context, key string, def int32) (res int32) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetInt64WithDefault is helper function for int64 params with default value -func (k GovGetter) GetInt64WithDefault(ctx sdk.Context, key string, def int64) (res int64) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetUint16WithDefault is helper function for uint16 params with default value -func (k GovGetter) GetUint16WithDefault(ctx sdk.Context, key string, def uint16) (res uint16) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetUint32WithDefault is helper function for uint32 params with default value -func (k GovGetter) GetUint32WithDefault(ctx sdk.Context, key string, def uint32) (res uint32) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetUint64WithDefault is helper function for uint64 params with default value -func (k GovGetter) GetUint64WithDefault(ctx sdk.Context, key string, def uint64) (res uint64) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetIntWithDefault is helper function for sdk.Int params with default value -func (k GovGetter) GetIntWithDefault(ctx sdk.Context, key string, def sdk.Int) (res sdk.Int) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetUintWithDefault is helper function for sdk.Uint params with default value -func (k GovGetter) GetUintWithDefault(ctx sdk.Context, key string, def sdk.Uint) (res sdk.Uint) { - key = getGovStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} - -// GetRatWithDefault is helper function for sdk.Rat params with default value -func (k GovGetter) GetRatWithDefault(ctx sdk.Context, key string, def sdk.Rat) (res sdk.Rat) { - key = getGlobalStoreKey(key) - store := ctx.KVStore(k.k.key) - bz := store.Get([]byte(key)) - if bz == nil { - return def - } - k.k.cdc.MustUnmarshalBinary(bz, &res) - return -} diff --git a/modules/iparams/keeper.go b/modules/iparams/keeper.go deleted file mode 100644 index efc9f317a..000000000 --- a/modules/iparams/keeper.go +++ /dev/null @@ -1,92 +0,0 @@ -package iparams - -import ( - "fmt" - "reflect" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/wire" -) - -// Keeper manages global parameter store -type Keeper struct { - cdc *wire.Codec - key sdk.StoreKey -} - -// NewKeeper constructs a new Keeper -func NewKeeper(cdc *wire.Codec, key sdk.StoreKey) Keeper { - return Keeper{ - cdc: cdc, - key: key, - } -} - -// InitKeeper constructs a new Keeper with initial parameters -func InitKeeper(ctx sdk.Context, cdc *wire.Codec, key sdk.StoreKey, params ...interface{}) Keeper { - if len(params)%2 != 0 { - panic("Odd params list length for InitKeeper") - } - - k := NewKeeper(cdc, key) - - for i := 0; i < len(params); i += 2 { - k.set(ctx, params[i].(string), params[i+1]) - } - - return k -} - -// get automatically unmarshalls parameter to pointer -func (k Keeper) get(ctx sdk.Context, key string, ptr interface{}) error { - store := ctx.KVStore(k.key) - bz := store.Get([]byte(key)) - return k.cdc.UnmarshalBinary(bz, ptr) -} - -// getRaw returns raw byte slice -func (k Keeper) getRaw(ctx sdk.Context, key string) []byte { - store := ctx.KVStore(k.key) - return store.Get([]byte(key)) -} - -// set automatically marshalls and type check parameter -func (k Keeper) set(ctx sdk.Context, key string, param interface{}) error { - store := ctx.KVStore(k.key) - bz := store.Get([]byte(key)) - if bz != nil { - ptrty := reflect.PtrTo(reflect.TypeOf(param)) - ptr := reflect.New(ptrty).Interface() - - if k.cdc.UnmarshalBinary(bz, ptr) != nil { - return fmt.Errorf("Type mismatch with stored param and provided param") - } - } - - bz, err := k.cdc.MarshalBinary(param) - if err != nil { - return err - } - store.Set([]byte(key), bz) - - return nil -} - -// setRaw sets raw byte slice -func (k Keeper) setRaw(ctx sdk.Context, key string, param []byte) { - store := ctx.KVStore(k.key) - store.Set([]byte(key), param) -} - -//// Getter returns readonly struct -//func (k Keeper) Getter() Getter { -// return Getter{k} -//} -// -//// Setter returns read/write struct -//func (k Keeper) Setter() Setter { -// return Setter{Getter{k}} -//} - - - diff --git a/modules/iparams/keeper_test.go b/modules/iparams/keeper_test.go deleted file mode 100644 index fa747690f..000000000 --- a/modules/iparams/keeper_test.go +++ /dev/null @@ -1,280 +0,0 @@ -package iparams - -import ( - "testing" - - "github.com/stretchr/testify/assert" - - abci "github.com/tendermint/tendermint/abci/types" - dbm "github.com/tendermint/tendermint/libs/db" - "github.com/tendermint/tendermint/libs/log" - - "github.com/cosmos/cosmos-sdk/store" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/wire" -) - -func defaultContext(key sdk.StoreKey) sdk.Context { - db := dbm.NewMemDB() - cms := store.NewCommitMultiStore(db) - cms.MountStoreWithDB(key, sdk.StoreTypeIAVL, db) - cms.LoadLatestVersion() - ctx := sdk.NewContext(cms, abci.Header{}, false, log.NewNopLogger()) - return ctx -} - -func TestKeeper(t *testing.T) { - kvs := []struct { - key string - param int64 - }{ - {"key1", 10}, - {"key2", 55}, - {"key3", 182}, - {"key4", 17582}, - {"key5", 2768554}, - } - - skey := sdk.NewKVStoreKey("test") - ctx := defaultContext(skey) - setter := NewKeeper(wire.NewCodec(), skey).Setter() - - for _, kv := range kvs { - err := setter.Set(ctx, kv.key, kv.param) - assert.Nil(t, err) - } - - for _, kv := range kvs { - var param int64 - err := setter.Get(ctx, kv.key, ¶m) - assert.Nil(t, err) - assert.Equal(t, kv.param, param) - } - - cdc := wire.NewCodec() - for _, kv := range kvs { - var param int64 - bz := setter.GetRaw(ctx, kv.key) - err := cdc.UnmarshalBinary(bz, ¶m) - assert.Nil(t, err) - assert.Equal(t, kv.param, param) - } - - for _, kv := range kvs { - var param bool - err := setter.Get(ctx, kv.key, ¶m) - assert.NotNil(t, err) - } - - for _, kv := range kvs { - err := setter.Set(ctx, kv.key, true) - assert.NotNil(t, err) - } -} - -func TestGetter(t *testing.T) { - key := sdk.NewKVStoreKey("test") - ctx := defaultContext(key) - keeper := NewKeeper(wire.NewCodec(), key) - - g := keeper.Getter() - s := keeper.Setter() - - kvs := []struct { - key string - param interface{} - }{ - {"string", "test"}, - {"bool", true}, - {"int16", int16(1)}, - {"int32", int32(1)}, - {"int64", int64(1)}, - {"uint16", uint16(1)}, - {"uint32", uint32(1)}, - {"uint64", uint64(1)}, - {"int", sdk.NewInt(1)}, - {"uint", sdk.NewUint(1)}, - {"rat", sdk.NewRat(1)}, - } - - assert.NotPanics(t, func() { s.SetString(ctx, kvs[0].key, "test") }) - assert.NotPanics(t, func() { s.SetBool(ctx, kvs[1].key, true) }) - assert.NotPanics(t, func() { s.SetInt16(ctx, kvs[2].key, int16(1)) }) - assert.NotPanics(t, func() { s.SetInt32(ctx, kvs[3].key, int32(1)) }) - assert.NotPanics(t, func() { s.SetInt64(ctx, kvs[4].key, int64(1)) }) - assert.NotPanics(t, func() { s.SetUint16(ctx, kvs[5].key, uint16(1)) }) - assert.NotPanics(t, func() { s.SetUint32(ctx, kvs[6].key, uint32(1)) }) - assert.NotPanics(t, func() { s.SetUint64(ctx, kvs[7].key, uint64(1)) }) - assert.NotPanics(t, func() { s.SetInt(ctx, kvs[8].key, sdk.NewInt(1)) }) - assert.NotPanics(t, func() { s.SetUint(ctx, kvs[9].key, sdk.NewUint(1)) }) - assert.NotPanics(t, func() { s.SetRat(ctx, kvs[10].key, sdk.NewRat(1)) }) - - var res interface{} - var err error - - // String - def0 := "default" - res, err = g.GetString(ctx, kvs[0].key) - assert.Nil(t, err) - assert.Equal(t, kvs[0].param, res) - - _, err = g.GetString(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetStringWithDefault(ctx, kvs[0].key, def0) - assert.Equal(t, kvs[0].param, res) - - res = g.GetStringWithDefault(ctx, "invalid", def0) - assert.Equal(t, def0, res) - - // Bool - def1 := false - res, err = g.GetBool(ctx, kvs[1].key) - assert.Nil(t, err) - assert.Equal(t, kvs[1].param, res) - - _, err = g.GetBool(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetBoolWithDefault(ctx, kvs[1].key, def1) - assert.Equal(t, kvs[1].param, res) - - res = g.GetBoolWithDefault(ctx, "invalid", def1) - assert.Equal(t, def1, res) - - // Int16 - def2 := int16(0) - res, err = g.GetInt16(ctx, kvs[2].key) - assert.Nil(t, err) - assert.Equal(t, kvs[2].param, res) - - _, err = g.GetInt16(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetInt16WithDefault(ctx, kvs[2].key, def2) - assert.Equal(t, kvs[2].param, res) - - res = g.GetInt16WithDefault(ctx, "invalid", def2) - assert.Equal(t, def2, res) - - // Int32 - def3 := int32(0) - res, err = g.GetInt32(ctx, kvs[3].key) - assert.Nil(t, err) - assert.Equal(t, kvs[3].param, res) - - _, err = g.GetInt32(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetInt32WithDefault(ctx, kvs[3].key, def3) - assert.Equal(t, kvs[3].param, res) - - res = g.GetInt32WithDefault(ctx, "invalid", def3) - assert.Equal(t, def3, res) - - // Int64 - def4 := int64(0) - res, err = g.GetInt64(ctx, kvs[4].key) - assert.Nil(t, err) - assert.Equal(t, kvs[4].param, res) - - _, err = g.GetInt64(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetInt64WithDefault(ctx, kvs[4].key, def4) - assert.Equal(t, kvs[4].param, res) - - res = g.GetInt64WithDefault(ctx, "invalid", def4) - assert.Equal(t, def4, res) - - // Uint16 - def5 := uint16(0) - res, err = g.GetUint16(ctx, kvs[5].key) - assert.Nil(t, err) - assert.Equal(t, kvs[5].param, res) - - _, err = g.GetUint16(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetUint16WithDefault(ctx, kvs[5].key, def5) - assert.Equal(t, kvs[5].param, res) - - res = g.GetUint16WithDefault(ctx, "invalid", def5) - assert.Equal(t, def5, res) - - // Uint32 - def6 := uint32(0) - res, err = g.GetUint32(ctx, kvs[6].key) - assert.Nil(t, err) - assert.Equal(t, kvs[6].param, res) - - _, err = g.GetUint32(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetUint32WithDefault(ctx, kvs[6].key, def6) - assert.Equal(t, kvs[6].param, res) - - res = g.GetUint32WithDefault(ctx, "invalid", def6) - assert.Equal(t, def6, res) - - // Uint64 - def7 := uint64(0) - res, err = g.GetUint64(ctx, kvs[7].key) - assert.Nil(t, err) - assert.Equal(t, kvs[7].param, res) - - _, err = g.GetUint64(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetUint64WithDefault(ctx, kvs[7].key, def7) - assert.Equal(t, kvs[7].param, res) - - res = g.GetUint64WithDefault(ctx, "invalid", def7) - assert.Equal(t, def7, res) - - // Int - def8 := sdk.NewInt(0) - res, err = g.GetInt(ctx, kvs[8].key) - assert.Nil(t, err) - assert.Equal(t, kvs[8].param, res) - - _, err = g.GetInt(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetIntWithDefault(ctx, kvs[8].key, def8) - assert.Equal(t, kvs[8].param, res) - - res = g.GetIntWithDefault(ctx, "invalid", def8) - assert.Equal(t, def8, res) - - // Uint - def9 := sdk.NewUint(0) - res, err = g.GetUint(ctx, kvs[9].key) - assert.Nil(t, err) - assert.Equal(t, kvs[9].param, res) - - _, err = g.GetUint(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetUintWithDefault(ctx, kvs[9].key, def9) - assert.Equal(t, kvs[9].param, res) - - res = g.GetUintWithDefault(ctx, "invalid", def9) - assert.Equal(t, def9, res) - - // Rat - def10 := sdk.NewRat(0) - res, err = g.GetRat(ctx, kvs[10].key) - assert.Nil(t, err) - assert.Equal(t, kvs[10].param, res) - - _, err = g.GetRat(ctx, "invalid") - assert.NotNil(t, err) - - res = g.GetRatWithDefault(ctx, kvs[10].key, def10) - assert.Equal(t, kvs[10].param, res) - - res = g.GetRatWithDefault(ctx, "invalid", def10) - assert.Equal(t, def10, res) - -} diff --git a/modules/iparams/msg_status.go b/modules/iparams/msg_status.go deleted file mode 100644 index c90da64b7..000000000 --- a/modules/iparams/msg_status.go +++ /dev/null @@ -1,36 +0,0 @@ -package iparams - -import ( - sdk "github.com/cosmos/cosmos-sdk/types" -) - -// GenesisState defines initial activated msg types -type GenesisState struct { - ActivatedTypes []string `json:"activated-types"` -} - -// ActivatedParamKey - paramstore key for msg type activation -func ActivatedParamKey(ty string) string { - return "Activated/" + ty -} - -// InitGenesis stores activated type to param store -func InitGenesis(ctx sdk.Context, k Keeper, data GenesisState) { - for _, ty := range data.ActivatedTypes { - k.set(ctx, ActivatedParamKey(ty), true) - } -} - -// NewAnteHandler returns an AnteHandler that checks -// whether msg type is activate or not -func NewAnteHandler(k Keeper) sdk.AnteHandler { - return func(ctx sdk.Context, tx sdk.Tx) (sdk.Context, sdk.Result, bool) { - for _, msg := range tx.GetMsgs() { - ok := k.GlobalGetter().GetBoolWithDefault(ctx, ActivatedParamKey(msg.Type()), false) - if !ok { - return ctx, sdk.ErrUnauthorized("deactivated msg type").Result(), true - } - } - return ctx, sdk.Result{}, false - } -} diff --git a/modules/iparams/proxy.go b/modules/iparams/proxy.go deleted file mode 100644 index c87181ab2..000000000 --- a/modules/iparams/proxy.go +++ /dev/null @@ -1,24 +0,0 @@ -package iparams - -const ( - Gov = "gov" - Global = "global" -) - -// Getter returns readonly struct,default get from Global -func (k Keeper) GlobalGetter() GlobalGetter { - return GlobalGetter{k} -} - -// Getter returns readonly struct,default get from Global -func (k Keeper) GovGetter() GovGetter { - return GovGetter{k} -} - -func (k Keeper) GlobalSetter() GlobalSetter { - return GlobalSetter{GlobalGetter{k}} -} - -func (k Keeper) GovSetter() GovSetter { - return GovSetter{GovGetter{k}} -} diff --git a/modules/iparams/setter.go b/modules/iparams/setter.go deleted file mode 100644 index eb5d58240..000000000 --- a/modules/iparams/setter.go +++ /dev/null @@ -1,222 +0,0 @@ -package iparams - -import ( - sdk "github.com/cosmos/cosmos-sdk/types" -) - -type Setter interface { - Set(ctx sdk.Context, key string, ptr interface{}) error - SetRaw(ctx sdk.Context, key string, param []byte) - SetString(ctx sdk.Context, key string, param string) -} - -// Setter exposes all methods including Set -type GlobalSetter struct { - GlobalGetter -} - -// Setter exposes all methods including Set -type GovSetter struct { - GovGetter -} - -// Set exposes set -func (k GlobalSetter) Set(ctx sdk.Context, key string, param interface{}) error { - key = getGlobalStoreKey(key) - return k.k.set(ctx, key, param) -} - -// SetRaw exposes setRaw -func (k GlobalSetter) SetRaw(ctx sdk.Context, key string, param []byte) { - key = getGlobalStoreKey(key) - k.k.setRaw(ctx, key, param) -} - -// SetString is helper function for string params -func (k GlobalSetter) SetString(ctx sdk.Context, key string, param string) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetBool is helper function for bool params -func (k GlobalSetter) SetBool(ctx sdk.Context, key string, param bool) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetInt16 is helper function for int16 params -func (k GlobalSetter) SetInt16(ctx sdk.Context, key string, param int16) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetInt32 is helper function for int32 params -func (k GlobalSetter) SetInt32(ctx sdk.Context, key string, param int32) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetInt64 is helper function for int64 params -func (k GlobalSetter) SetInt64(ctx sdk.Context, key string, param int64) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetUint16 is helper function for uint16 params -func (k GlobalSetter) SetUint16(ctx sdk.Context, key string, param uint16) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetUint32 is helper function for uint32 params -func (k GlobalSetter) SetUint32(ctx sdk.Context, key string, param uint32) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetUint64 is helper function for uint64 params -func (k GlobalSetter) SetUint64(ctx sdk.Context, key string, param uint64) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetInt is helper function for sdk.Int params -func (k GlobalSetter) SetInt(ctx sdk.Context, key string, param sdk.Int) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetUint is helper function for sdk.Uint params -func (k GlobalSetter) SetUint(ctx sdk.Context, key string, param sdk.Uint) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetRat is helper function for rat params -func (k GlobalSetter) SetRat(ctx sdk.Context, key string, param sdk.Rat) { - key = getGlobalStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - - -// Set exposes set -func (k GovSetter) Set(ctx sdk.Context, key string, param interface{}) error { - key = getGovStoreKey(key) - return k.k.set(ctx, key, param) -} - -// SetRaw exposes setRaw -func (k GovSetter) SetRaw(ctx sdk.Context, key string, param []byte) { - key = getGovStoreKey(key) - k.k.setRaw(ctx, key, param) -} - -// SetString is helper function for string params -func (k GovSetter) SetString(ctx sdk.Context, key string, param string) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetBool is helper function for bool params -func (k GovSetter) SetBool(ctx sdk.Context, key string, param bool) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetInt16 is helper function for int16 params -func (k GovSetter) SetInt16(ctx sdk.Context, key string, param int16) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetInt32 is helper function for int32 params -func (k GovSetter) SetInt32(ctx sdk.Context, key string, param int32) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetInt64 is helper function for int64 params -func (k GovSetter) SetInt64(ctx sdk.Context, key string, param int64) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetUint16 is helper function for uint16 params -func (k GovSetter) SetUint16(ctx sdk.Context, key string, param uint16) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetUint32 is helper function for uint32 params -func (k GovSetter) SetUint32(ctx sdk.Context, key string, param uint32) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetUint64 is helper function for uint64 params -func (k GovSetter) SetUint64(ctx sdk.Context, key string, param uint64) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetInt is helper function for sdk.Int params -func (k GovSetter) SetInt(ctx sdk.Context, key string, param sdk.Int) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetUint is helper function for sdk.Uint params -func (k GovSetter) SetUint(ctx sdk.Context, key string, param sdk.Uint) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} - -// SetRat is helper function for rat params -func (k GovSetter) SetRat(ctx sdk.Context, key string, param sdk.Rat) { - key = getGovStoreKey(key) - if err := k.k.set(ctx, key, param); err != nil { - panic(err) - } -} diff --git a/modules/upgrade/genesis.go b/modules/upgrade/genesis.go index 24e5e5293..81bb4a71b 100644 --- a/modules/upgrade/genesis.go +++ b/modules/upgrade/genesis.go @@ -4,7 +4,7 @@ import ( bam "github.com/irisnet/irishub/baseapp" sdk "github.com/cosmos/cosmos-sdk/types" "fmt" - "github.com/irisnet/irishub/modules/parameter" + "github.com/irisnet/irishub/modules/iparam" "github.com/irisnet/irishub/modules/upgrade/params" ) @@ -22,7 +22,7 @@ func InitGenesis(ctx sdk.Context, k Keeper, router bam.Router) { genesisVersion := NewVersion(0, 0, 0, moduleList) k.AddNewVersion(ctx, genesisVersion) - parameter.InitGenesisParameter(&upgradeparams.ProposalAcceptHeightParameter, ctx, -1) - parameter.InitGenesisParameter(&upgradeparams.CurrentUpgradeProposalIdParameter, ctx, -1) + iparam.InitGenesisParameter(&upgradeparams.ProposalAcceptHeightParameter, ctx, -1) + iparam.InitGenesisParameter(&upgradeparams.CurrentUpgradeProposalIdParameter, ctx, -1) InitGenesis_commitID(ctx, k) } diff --git a/modules/upgrade/params/upgrade_params.go b/modules/upgrade/params/upgrade_params.go index 609c1709d..f1477a351 100644 --- a/modules/upgrade/params/upgrade_params.go +++ b/modules/upgrade/params/upgrade_params.go @@ -3,12 +3,12 @@ package upgradeparams import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/params" - "github.com/irisnet/irishub/modules/parameter" + "github.com/irisnet/irishub/modules/iparam" ) var CurrentUpgradeProposalIdParameter CurrentUpgradeProposalIdParam -var _ parameter.SignalParameter = (*CurrentUpgradeProposalIdParam)(nil) +var _ iparam.SignalParameter = (*CurrentUpgradeProposalIdParam)(nil) type CurrentUpgradeProposalIdParam struct { Value int64 @@ -44,7 +44,7 @@ func (param *CurrentUpgradeProposalIdParam) LoadValue(ctx sdk.Context) bool { var ProposalAcceptHeightParameter ProposalAcceptHeightParam -var _ parameter.SignalParameter = (*ProposalAcceptHeightParam)(nil) +var _ iparam.SignalParameter = (*ProposalAcceptHeightParam)(nil) type ProposalAcceptHeightParam struct { Value int64