github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/wasm/keeper/genesis.go (about)

     1  package keeper
     2  
     3  import (
     4  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
     5  	sdkerrors "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types/errors"
     6  	abci "github.com/fibonacci-chain/fbc/libs/tendermint/abci/types"
     7  
     8  	"github.com/fibonacci-chain/fbc/x/wasm/types"
     9  )
    10  
    11  // ValidatorSetSource is a subset of the staking keeper
    12  type ValidatorSetSource interface {
    13  	ApplyAndReturnValidatorSetUpdates(sdk.Context) (updates []abci.ValidatorUpdate, err error)
    14  }
    15  
    16  // InitGenesis sets supply information for genesis.
    17  //
    18  // CONTRACT: all types of accounts must have been already initialized/created
    19  func InitGenesis(ctx sdk.Context, keeper *Keeper, data types.GenesisState, msgHandler sdk.Handler) ([]abci.ValidatorUpdate, error) {
    20  	contractKeeper := NewGovPermissionKeeper(keeper)
    21  	keeper.SetParams(ctx, data.Params)
    22  	var maxCodeID uint64
    23  	for i, code := range data.Codes {
    24  		err := keeper.importCode(ctx, code.CodeID, code.CodeInfo, code.CodeBytes)
    25  		if err != nil {
    26  			return nil, sdkerrors.Wrapf(err, "code %d with id: %d", i, code.CodeID)
    27  		}
    28  		if code.CodeID > maxCodeID {
    29  			maxCodeID = code.CodeID
    30  		}
    31  		if code.Pinned {
    32  			if err := contractKeeper.PinCode(ctx, code.CodeID); err != nil {
    33  				return nil, sdkerrors.Wrapf(err, "contract number %d", i)
    34  			}
    35  		}
    36  	}
    37  
    38  	var maxContractID int
    39  	for i, contract := range data.Contracts {
    40  		contractAddr, err := sdk.AccAddressFromBech32(contract.ContractAddress)
    41  		if err != nil {
    42  			return nil, sdkerrors.Wrapf(err, "address in contract number %d", i)
    43  		}
    44  		err = keeper.importContract(ctx, contractAddr, &contract.ContractInfo, contract.ContractState)
    45  		if err != nil {
    46  			return nil, sdkerrors.Wrapf(err, "contract number %d", i)
    47  		}
    48  		maxContractID = i + 1 // not ideal but max(contractID) is not persisted otherwise
    49  	}
    50  
    51  	for i, seq := range data.Sequences {
    52  		err := keeper.importAutoIncrementID(ctx, seq.IDKey, seq.Value)
    53  		if err != nil {
    54  			return nil, sdkerrors.Wrapf(err, "sequence number %d", i)
    55  		}
    56  	}
    57  
    58  	// sanity check seq values
    59  	seqVal := keeper.PeekAutoIncrementID(ctx, types.KeyLastCodeID)
    60  	if seqVal <= maxCodeID {
    61  		return nil, sdkerrors.Wrapf(types.ErrInvalid, "seq %s with value: %d must be greater than: %d ", string(types.KeyLastCodeID), seqVal, maxCodeID)
    62  	}
    63  	seqVal = keeper.PeekAutoIncrementID(ctx, types.KeyLastInstanceID)
    64  	if seqVal <= uint64(maxContractID) {
    65  		return nil, sdkerrors.Wrapf(types.ErrInvalid, "seq %s with value: %d must be greater than: %d ", string(types.KeyLastInstanceID), seqVal, maxContractID)
    66  	}
    67  
    68  	if len(data.GenMsgs) == 0 {
    69  		return nil, nil
    70  	}
    71  	for _, genTx := range data.GenMsgs {
    72  		msg := genTx.AsMsg()
    73  		if msg == nil {
    74  			return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "unknown message")
    75  		}
    76  		_, err := msgHandler(ctx, msg)
    77  		if err != nil {
    78  			return nil, sdkerrors.Wrap(err, "genesis")
    79  		}
    80  	}
    81  	return nil, nil
    82  }
    83  
    84  // ExportGenesis returns a GenesisState for a given context and keeper.
    85  func ExportGenesis(ctx sdk.Context, keeper *Keeper) *types.GenesisState {
    86  	var genState types.GenesisState
    87  
    88  	genState.Params = keeper.GetParams(ctx)
    89  
    90  	keeper.IterateCodeInfos(ctx, func(codeID uint64, info types.CodeInfo) bool {
    91  		bytecode, err := keeper.GetByteCode(ctx, codeID)
    92  		if err != nil {
    93  			panic(err)
    94  		}
    95  		genState.Codes = append(genState.Codes, types.Code{
    96  			CodeID:    codeID,
    97  			CodeInfo:  info,
    98  			CodeBytes: bytecode,
    99  			Pinned:    keeper.IsPinnedCode(ctx, codeID),
   100  		})
   101  		return false
   102  	})
   103  
   104  	keeper.IterateContractInfo(ctx, func(addr sdk.AccAddress, contract types.ContractInfo) bool {
   105  		var state []types.Model
   106  		keeper.IterateContractState(ctx, addr, func(key, value []byte) bool {
   107  			state = append(state, types.Model{Key: key, Value: value})
   108  			return false
   109  		})
   110  		// redact contract info
   111  		contract.Created = nil
   112  		genState.Contracts = append(genState.Contracts, types.Contract{
   113  			ContractAddress: addr.String(),
   114  			ContractInfo:    contract,
   115  			ContractState:   state,
   116  		})
   117  		return false
   118  	})
   119  
   120  	for _, k := range [][]byte{types.KeyLastCodeID, types.KeyLastInstanceID} {
   121  		genState.Sequences = append(genState.Sequences, types.Sequence{
   122  			IDKey: k,
   123  			Value: keeper.PeekAutoIncrementID(ctx, k),
   124  		})
   125  	}
   126  
   127  	return &genState
   128  }