mirror of https://github.com/certusone/wasmd.git
136 lines
4.0 KiB
Go
136 lines
4.0 KiB
Go
package keeper
|
|
|
|
import (
|
|
"context"
|
|
|
|
abci "github.com/cometbft/cometbft/abci/types"
|
|
|
|
errorsmod "cosmossdk.io/errors"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
"github.com/CosmWasm/wasmd/x/wasm/types"
|
|
)
|
|
|
|
// ValidatorSetSource is a subset of the staking keeper
|
|
type ValidatorSetSource interface {
|
|
ApplyAndReturnValidatorSetUpdates(context.Context) (updates []abci.ValidatorUpdate, err error)
|
|
}
|
|
|
|
// InitGenesis sets supply information for genesis.
|
|
//
|
|
// CONTRACT: all types of accounts must have been already initialized/created
|
|
func InitGenesis(ctx sdk.Context, keeper *Keeper, data types.GenesisState) ([]abci.ValidatorUpdate, error) {
|
|
contractKeeper := NewGovPermissionKeeper(keeper)
|
|
err := keeper.SetParams(ctx, data.Params)
|
|
if err != nil {
|
|
return nil, errorsmod.Wrapf(err, "set params")
|
|
}
|
|
|
|
var maxCodeID uint64
|
|
for i, code := range data.Codes {
|
|
err := keeper.importCode(ctx, code.CodeID, code.CodeInfo, code.CodeBytes)
|
|
if err != nil {
|
|
return nil, errorsmod.Wrapf(err, "code %d with id: %d", i, code.CodeID)
|
|
}
|
|
if code.CodeID > maxCodeID {
|
|
maxCodeID = code.CodeID
|
|
}
|
|
if code.Pinned {
|
|
if err := contractKeeper.PinCode(ctx, code.CodeID); err != nil {
|
|
return nil, errorsmod.Wrapf(err, "contract number %d", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
for i, contract := range data.Contracts {
|
|
contractAddr, err := sdk.AccAddressFromBech32(contract.ContractAddress)
|
|
if err != nil {
|
|
return nil, errorsmod.Wrapf(err, "address in contract number %d", i)
|
|
}
|
|
err = keeper.importContract(ctx, contractAddr, &contract.ContractInfo, contract.ContractState, contract.ContractCodeHistory)
|
|
if err != nil {
|
|
return nil, errorsmod.Wrapf(err, "contract number %d", i)
|
|
}
|
|
}
|
|
|
|
for i, seq := range data.Sequences {
|
|
err := keeper.importAutoIncrementID(ctx, seq.IDKey, seq.Value)
|
|
if err != nil {
|
|
return nil, errorsmod.Wrapf(err, "sequence number %d", i)
|
|
}
|
|
}
|
|
|
|
// sanity check seq values
|
|
seqVal, err := keeper.PeekAutoIncrementID(ctx, types.KeySequenceCodeID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if seqVal <= maxCodeID {
|
|
return nil, errorsmod.Wrapf(types.ErrInvalid, "seq %s with value: %d must be greater than: %d ", string(types.KeySequenceCodeID), seqVal, maxCodeID)
|
|
}
|
|
// ensure next classic address is unused so that we know the sequence is good
|
|
rCtx, _ := ctx.CacheContext()
|
|
seqVal, err = keeper.PeekAutoIncrementID(rCtx, types.KeySequenceInstanceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
addr := keeper.ClassicAddressGenerator()(rCtx, seqVal, nil)
|
|
if keeper.HasContractInfo(ctx, addr) {
|
|
return nil, errorsmod.Wrapf(types.ErrInvalid, "value: %d for seq %s was used already", seqVal, string(types.KeySequenceInstanceID))
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// ExportGenesis returns a GenesisState for a given context and keeper.
|
|
func ExportGenesis(ctx sdk.Context, keeper *Keeper) *types.GenesisState {
|
|
var genState types.GenesisState
|
|
|
|
genState.Params = keeper.GetParams(ctx)
|
|
|
|
keeper.IterateCodeInfos(ctx, func(codeID uint64, info types.CodeInfo) bool {
|
|
bytecode, err := keeper.GetByteCode(ctx, codeID)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
genState.Codes = append(genState.Codes, types.Code{
|
|
CodeID: codeID,
|
|
CodeInfo: info,
|
|
CodeBytes: bytecode,
|
|
Pinned: keeper.IsPinnedCode(ctx, codeID),
|
|
})
|
|
return false
|
|
})
|
|
|
|
keeper.IterateContractInfo(ctx, func(addr sdk.AccAddress, contract types.ContractInfo) bool {
|
|
var state []types.Model
|
|
keeper.IterateContractState(ctx, addr, func(key, value []byte) bool {
|
|
state = append(state, types.Model{Key: key, Value: value})
|
|
return false
|
|
})
|
|
|
|
contractCodeHistory := keeper.GetContractHistory(ctx, addr)
|
|
|
|
genState.Contracts = append(genState.Contracts, types.Contract{
|
|
ContractAddress: addr.String(),
|
|
ContractInfo: contract,
|
|
ContractState: state,
|
|
ContractCodeHistory: contractCodeHistory,
|
|
})
|
|
return false
|
|
})
|
|
|
|
for _, k := range [][]byte{types.KeySequenceCodeID, types.KeySequenceInstanceID} {
|
|
id, err := keeper.PeekAutoIncrementID(ctx, k)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
genState.Sequences = append(genState.Sequences, types.Sequence{
|
|
IDKey: k,
|
|
Value: id,
|
|
})
|
|
}
|
|
|
|
return &genState
|
|
}
|