/
genesis.go
106 lines (93 loc) · 3.43 KB
/
genesis.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
package types
import (
wasmcli "github.com/CosmWasm/wasmd/x/wasm/client/cli"
wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)
// defined via in protobuf package structure. Note the leading `/`
const furyaExtType = "/confio.twasm.v1beta1.FuryaContractDetails"
func (g GenesisState) ValidateBasic() error {
wasmState := g.RawWasmState()
if err := wasmState.ValidateBasic(); err != nil {
return sdkerrors.Wrap(err, "wasm")
}
for _, c := range wasmState.Contracts {
if c.ContractInfo.Extension != nil {
if furyaExtType != c.ContractInfo.Extension.TypeUrl {
return sdkerrors.Wrapf(wasmtypes.ErrInvalidGenesis, "invalid extension type: %s, contract %s", c.ContractInfo.Extension.TypeUrl, c.ContractAddress)
}
}
}
uniqueAddr := make(map[string]struct{}, len(g.PrivilegedContractAddresses))
for i, a := range g.PrivilegedContractAddresses {
if _, err := sdk.AccAddressFromBech32(a); err != nil {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "privileged contract [%d, %s]: %s", i, a, err.Error())
}
if _, exists := uniqueAddr[a]; exists {
return sdkerrors.Wrapf(wasmtypes.ErrDuplicate, "privileged contract %s", a)
}
uniqueAddr[a] = struct{}{}
}
uniquePinnedCodeIDs := make(map[uint64]struct{}, len(g.PinnedCodeIDs))
for _, code := range g.PinnedCodeIDs {
if _, exists := uniquePinnedCodeIDs[code]; exists {
return sdkerrors.Wrapf(wasmtypes.ErrDuplicate, "pinned codeID %d", code)
}
uniquePinnedCodeIDs[code] = struct{}{}
}
genesisCodes := wasmcli.GetAllCodes(&wasmState)
for _, code := range genesisCodes {
delete(uniquePinnedCodeIDs, code.CodeID)
}
if len(uniquePinnedCodeIDs) > 0 {
return sdkerrors.Wrapf(wasmtypes.ErrInvalidGenesis, "%d pinned codeIDs not found in genesis codeIDs", len(uniquePinnedCodeIDs))
}
genesisContracts := wasmcli.GetAllContracts(&wasmState)
for _, contract := range genesisContracts {
delete(uniqueAddr, contract.ContractAddress)
}
if len(uniqueAddr) > 0 {
return sdkerrors.Wrapf(wasmtypes.ErrInvalidGenesis, "%d privileged contract addresses not found in genesis contract addresses", len(uniqueAddr))
}
return nil
}
// RawWasmState convert to wasm genesis state for vanilla import.
// Custom data models for privileged contracts are not included
func (g GenesisState) RawWasmState() wasmtypes.GenesisState {
contracts := make([]wasmtypes.Contract, len(g.Contracts))
for i, v := range g.Contracts {
var s []wasmtypes.Model
if m := v.GetKvModel(); m != nil {
s = m.Models
}
contracts[i] = wasmtypes.Contract{
ContractAddress: v.ContractAddress,
ContractInfo: v.ContractInfo,
ContractState: s,
}
}
return wasmtypes.GenesisState{
Params: g.Params,
Codes: g.Codes,
Contracts: contracts,
Sequences: g.Sequences,
GenMsgs: g.GenMsgs,
}
}
var _ codectypes.UnpackInterfacesMessage = GenesisState{}
// UnpackInterfaces implements codectypes.UnpackInterfaces
func (g GenesisState) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
for _, v := range g.Contracts {
if err := v.UnpackInterfaces(unpacker); err != nil {
return err
}
}
return nil
}
var _ codectypes.UnpackInterfacesMessage = &Contract{}
// UnpackInterfaces implements codectypes.UnpackInterfaces
func (m *Contract) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
return m.ContractInfo.UnpackInterfaces(unpacker)
}