forked from CosmWasm/wasmd
/
module.go
188 lines (157 loc) · 6.51 KB
/
module.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
package wasmplus
import (
"context"
"encoding/json"
"math/rand"
"github.com/grpc-ecosystem/grpc-gateway/runtime"
"github.com/spf13/cobra"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/Finschia/finschia-sdk/client"
"github.com/Finschia/finschia-sdk/codec"
cdctypes "github.com/Finschia/finschia-sdk/codec/types"
sdk "github.com/Finschia/finschia-sdk/types"
sdkerrors "github.com/Finschia/finschia-sdk/types/errors"
"github.com/Finschia/finschia-sdk/types/module"
simtypes "github.com/Finschia/finschia-sdk/types/simulation"
wasmkeeper "github.com/Finschia/wasmd/x/wasm/keeper"
"github.com/Finschia/wasmd/x/wasm/simulation"
wasmtypes "github.com/Finschia/wasmd/x/wasm/types"
"github.com/Finschia/wasmd/x/wasmplus/client/cli"
"github.com/Finschia/wasmd/x/wasmplus/keeper"
"github.com/Finschia/wasmd/x/wasmplus/types"
)
var (
_ module.AppModule = AppModule{}
_ module.AppModuleBasic = AppModuleBasic{}
)
// AppModuleBasic defines the basic application module used by the wasm module.
type AppModuleBasic struct{}
// Name returns the wasm module's name.
func (a AppModuleBasic) Name() string {
return types.ModuleName
}
func (a AppModuleBasic) RegisterLegacyAminoCodec(amino *codec.LegacyAmino) {
types.RegisterLegacyAminoCodec(amino)
}
// RegisterInterfaces implements InterfaceModule
func (a AppModuleBasic) RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
types.RegisterInterfaces(registry)
}
// DefaultGenesis returns default genesis state as raw bytes for the wasm module.
func (a AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage {
return cdc.MustMarshalJSON(&types.GenesisState{
Params: wasmtypes.DefaultParams(),
})
}
// ValidateGenesis performs genesis state validation for the wasm module.
func (a AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, message json.RawMessage) error {
var data types.GenesisState
if err := cdc.UnmarshalJSON(message, &data); err != nil {
return sdkerrors.Wrap(err, "validate genesis")
}
return data.ValidateBasic()
}
func (a AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, serveMux *runtime.ServeMux) {
if err := types.RegisterQueryHandlerClient(context.Background(), serveMux, types.NewQueryClient(clientCtx)); err != nil {
panic(err)
}
if err := wasmtypes.RegisterQueryHandlerClient(context.Background(), serveMux, wasmtypes.NewQueryClient(clientCtx)); err != nil {
panic(err)
}
}
// GetTxCmd returns the root tx command for the wasm module.
func (a AppModuleBasic) GetTxCmd() *cobra.Command {
return cli.GetTxCmd()
}
// GetQueryCmd returns no root query command for the wasm module.
func (a AppModuleBasic) GetQueryCmd() *cobra.Command {
return cli.GetQueryCmd()
}
type AppModule struct {
AppModuleBasic
cdc codec.Codec
keeper *keeper.Keeper
validatorSetSource wasmkeeper.ValidatorSetSource
accountKeeper wasmtypes.AccountKeeper // for simulation
bankKeeper simulation.BankKeeper
}
func NewAppModule(
cdc codec.Codec,
keeper *keeper.Keeper,
vs wasmkeeper.ValidatorSetSource,
ak wasmtypes.AccountKeeper,
bk simulation.BankKeeper,
) AppModule {
return AppModule{
AppModuleBasic: AppModuleBasic{},
cdc: cdc,
keeper: keeper,
validatorSetSource: vs,
accountKeeper: ak,
bankKeeper: bk,
}
}
func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate {
var genesisState types.GenesisState
cdc.MustUnmarshalJSON(data, &genesisState)
validators, err := keeper.InitGenesis(ctx, am.keeper, genesisState, am.validatorSetSource, am.Route().Handler())
if err != nil {
panic(err)
}
return validators
}
// ExportGenesis returns the exported genesis state as raw bytes for the wasm module.
func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {
gs := keeper.ExportGenesis(ctx, am.keeper)
return cdc.MustMarshalJSON(gs)
}
// RegisterInvariants registers the wasm module invariants.
func (am AppModule) RegisterInvariants(registry sdk.InvariantRegistry) {}
// Route returns the message routing key for the wasm module.
func (am AppModule) Route() sdk.Route {
return sdk.NewRoute(types.RouterKey,
NewHandler(keeper.NewPermissionedKeeper(*wasmkeeper.NewDefaultPermissionKeeper(am.keeper), am.keeper)))
}
// QuerierRoute returns the wasm module's querier route name.
func (am AppModule) QuerierRoute() string {
return wasmtypes.QuerierRoute
}
func (am AppModule) LegacyQuerierHandler(amino *codec.LegacyAmino) sdk.Querier {
return wasmkeeper.NewLegacyQuerier(am.keeper, am.keeper.QueryGasLimit())
}
func (am AppModule) RegisterServices(cfg module.Configurator) {
// wasmplus service
types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(wasmkeeper.NewDefaultPermissionKeeper(am.keeper)))
types.RegisterQueryServer(cfg.QueryServer(), keeper.Querier(am.keeper))
// wasm service
wasmtypes.RegisterMsgServer(cfg.MsgServer(), wasmkeeper.NewMsgServerImpl(wasmkeeper.NewDefaultPermissionKeeper(am.keeper)))
wasmtypes.RegisterQueryServer(cfg.QueryServer(), keeper.WasmQuerier(am.keeper))
}
// ConsensusVersion is a sequence number for state-breaking change of the
// module. It should be incremented on each consensus-breaking change
// introduced by the module. To avoid wrong/empty versions, the initial version
// should be set to 1.
func (am AppModule) ConsensusVersion() uint64 {
return 1
}
// ____________________________________________________________________________
// AppModuleSimulation functions
// GenerateGenesisState creates a randomized GenState of the bank module.
func (am AppModule) GenerateGenesisState(simState *module.SimulationState) {
simulation.RandomizedGenState(simState)
}
// ProposalContents doesn't return any content functions for governance proposals.
func (am AppModule) ProposalContents(simState module.SimulationState) []simtypes.WeightedProposalContent {
return nil
}
// RandomizedParams creates randomized bank param changes for the simulator.
func (am AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange {
return simulation.ParamChanges(r, am.cdc)
}
// RegisterStoreDecoder registers a decoder for supply module's types
func (am AppModule) RegisterStoreDecoder(registry sdk.StoreDecoderRegistry) {
}
// WeightedOperations returns the all the gov module operations with their respective weights.
func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation {
return simulation.WeightedOperations(&simState, am.accountKeeper, am.bankKeeper, am.keeper)
}