Use wasm types from github.com/cosmoscontracts/wasmd v1.0.0-juno6

Author: Maxim

wasm/types/README.md

@@ -0,0 +1,24 @@
+## Referencing WASM types
+
+Please don't include `github.com/CosmWasm/wasmd` as an sdk-go project dependency, those types needed on the client side should be included in this repo directly.
+
+### Used types files:
+
+```
+wasm/types/ante.go
+wasm/types/codec.go
+wasm/types/errors.go
+wasm/types/events.go
+wasm/types/genesis.go
+wasm/types/genesis.pb.go
+wasm/types/ibc.pb.go
+wasm/types/params.go
+wasm/types/proposal.go
+wasm/types/proposal.pb.go
+wasm/types/query.pb.go
+wasm/types/query.pb.gw.go
+wasm/types/tx.go
+wasm/types/tx.pb.go
+wasm/types/types.go
+wasm/types/types.pb.go
+```

wasm/types/ante.go

@@ -0,0 +1,24 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type contextKey int
+
+const (
+	// private type creates an interface key for Context that cannot be accessed by any other package
+	contextKeyTXCount contextKey = iota
+)
+
+// WithTXCounter stores a transaction counter value in the context
+func WithTXCounter(ctx sdk.Context, counter uint32) sdk.Context {
+	return ctx.WithValue(contextKeyTXCount, counter)
+}
+
+// TXCounter returns the tx counter value and found bool from the context.
+// The result will be (0, false) for external queries or simulations where no counter available.
+func TXCounter(ctx sdk.Context) (uint32, bool) {
+	val, ok := ctx.Value(contextKeyTXCount).(uint32)
+	return val, ok
+}

wasm/types/codec.go

@@ -0,0 +1,70 @@
+package types
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/types"
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/msgservice"
+	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+)
+
+// RegisterLegacyAminoCodec registers the account types and interface
+func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { //nolint:staticcheck
+	cdc.RegisterConcrete(&MsgStoreCode{}, "wasm/MsgStoreCode", nil)
+	cdc.RegisterConcrete(&MsgInstantiateContract{}, "wasm/MsgInstantiateContract", nil)
+	cdc.RegisterConcrete(&MsgExecuteContract{}, "wasm/MsgExecuteContract", nil)
+	cdc.RegisterConcrete(&MsgMigrateContract{}, "wasm/MsgMigrateContract", nil)
+	cdc.RegisterConcrete(&MsgUpdateAdmin{}, "wasm/MsgUpdateAdmin", nil)
+	cdc.RegisterConcrete(&MsgClearAdmin{}, "wasm/MsgClearAdmin", nil)
+	cdc.RegisterConcrete(&PinCodesProposal{}, "wasm/PinCodesProposal", nil)
+	cdc.RegisterConcrete(&UnpinCodesProposal{}, "wasm/UnpinCodesProposal", nil)
+
+	cdc.RegisterConcrete(&StoreCodeProposal{}, "wasm/StoreCodeProposal", nil)
+	cdc.RegisterConcrete(&InstantiateContractProposal{}, "wasm/InstantiateContractProposal", nil)
+	cdc.RegisterConcrete(&MigrateContractProposal{}, "wasm/MigrateContractProposal", nil)
+	cdc.RegisterConcrete(&UpdateAdminProposal{}, "wasm/UpdateAdminProposal", nil)
+	cdc.RegisterConcrete(&ClearAdminProposal{}, "wasm/ClearAdminProposal", nil)
+}
+
+func RegisterInterfaces(registry types.InterfaceRegistry) {
+	registry.RegisterImplementations(
+		(*sdk.Msg)(nil),
+		&MsgStoreCode{},
+		&MsgInstantiateContract{},
+		&MsgExecuteContract{},
+		&MsgMigrateContract{},
+		&MsgUpdateAdmin{},
+		&MsgClearAdmin{},
+		&MsgIBCCloseChannel{},
+		&MsgIBCSend{},
+	)
+	registry.RegisterImplementations(
+		(*govtypes.Content)(nil),
+		&StoreCodeProposal{},
+		&InstantiateContractProposal{},
+		&MigrateContractProposal{},
+		&UpdateAdminProposal{},
+		&ClearAdminProposal{},
+		&PinCodesProposal{},
+		&UnpinCodesProposal{},
+	)
+
+	registry.RegisterInterface("ContractInfoExtension", (*ContractInfoExtension)(nil))
+
+	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
+}
+
+var (
+	amino = codec.NewLegacyAmino()
+
+	// ModuleCdc references the global x/wasm module codec.
+
+	ModuleCdc = codec.NewAminoCodec(amino)
+)
+
+func init() {
+	RegisterLegacyAminoCodec(amino)
+	cryptocodec.RegisterCrypto(amino)
+	amino.Seal()
+}

wasm/types/errors.go

@@ -0,0 +1,72 @@
+package types
+
+import (
+	sdkErrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// Codes for wasm contract errors
+var (
+	DefaultCodespace = ModuleName
+
+	// Note: never use code 1 for any errors - that is reserved for ErrInternal in the core cosmos sdk
+
+	// ErrCreateFailed error for wasm code that has already been uploaded or failed
+	ErrCreateFailed = sdkErrors.Register(DefaultCodespace, 2, "create wasm contract failed")
+
+	// ErrAccountExists error for a contract account that already exists
+	ErrAccountExists = sdkErrors.Register(DefaultCodespace, 3, "contract account already exists")
+
+	// ErrInstantiateFailed error for rust instantiate contract failure
+	ErrInstantiateFailed = sdkErrors.Register(DefaultCodespace, 4, "instantiate wasm contract failed")
+
+	// ErrExecuteFailed error for rust execution contract failure
+	ErrExecuteFailed = sdkErrors.Register(DefaultCodespace, 5, "execute wasm contract failed")
+
+	// ErrGasLimit error for out of gas
+	ErrGasLimit = sdkErrors.Register(DefaultCodespace, 6, "insufficient gas")
+
+	// ErrInvalidGenesis error for invalid genesis file syntax
+	ErrInvalidGenesis = sdkErrors.Register(DefaultCodespace, 7, "invalid genesis")
+
+	// ErrNotFound error for an entry not found in the store
+	ErrNotFound = sdkErrors.Register(DefaultCodespace, 8, "not found")
+
+	// ErrQueryFailed error for rust smart query contract failure
+	ErrQueryFailed = sdkErrors.Register(DefaultCodespace, 9, "query wasm contract failed")
+
+	// ErrInvalidMsg error when we cannot process the error returned from the contract
+	ErrInvalidMsg = sdkErrors.Register(DefaultCodespace, 10, "invalid CosmosMsg from the contract")
+
+	// ErrMigrationFailed error for rust execution contract failure
+	ErrMigrationFailed = sdkErrors.Register(DefaultCodespace, 11, "migrate wasm contract failed")
+
+	// ErrEmpty error for empty content
+	ErrEmpty = sdkErrors.Register(DefaultCodespace, 12, "empty")
+
+	// ErrLimit error for content that exceeds a limit
+	ErrLimit = sdkErrors.Register(DefaultCodespace, 13, "exceeds limit")
+
+	// ErrInvalid error for content that is invalid in this context
+	ErrInvalid = sdkErrors.Register(DefaultCodespace, 14, "invalid")
+
+	// ErrDuplicate error for content that exists
+	ErrDuplicate = sdkErrors.Register(DefaultCodespace, 15, "duplicate")
+
+	// ErrMaxIBCChannels error for maximum number of ibc channels reached
+	ErrMaxIBCChannels = sdkErrors.Register(DefaultCodespace, 16, "max transfer channels")
+
+	// ErrUnsupportedForContract error when a feature is used that is not supported for/ by this contract
+	ErrUnsupportedForContract = sdkErrors.Register(DefaultCodespace, 17, "unsupported for this contract")
+
+	// ErrPinContractFailed error for pinning contract failures
+	ErrPinContractFailed = sdkErrors.Register(DefaultCodespace, 18, "pinning contract failed")
+
+	// ErrUnpinContractFailed error for unpinning contract failures
+	ErrUnpinContractFailed = sdkErrors.Register(DefaultCodespace, 19, "unpinning contract failed")
+
+	// ErrUnknownMsg error by a message handler to show that it is not responsible for this message type
+	ErrUnknownMsg = sdkErrors.Register(DefaultCodespace, 20, "unknown message from the contract")
+
+	// ErrInvalidEvent error if an attribute/event from the contract is invalid
+	ErrInvalidEvent = sdkErrors.Register(DefaultCodespace, 21, "invalid event")
+)

wasm/types/events.go

@@ -0,0 +1,28 @@
+package types
+
+const (
+	// WasmModuleEventType is stored with any contract TX that returns non empty EventAttributes
+	WasmModuleEventType = "wasm"
+	// CustomContractEventPrefix contracts can create custom events. To not mix them with other system events they got the `wasm-` prefix.
+	CustomContractEventPrefix = "wasm-"
+
+	EventTypeStoreCode         = "store_code"
+	EventTypeInstantiate       = "instantiate"
+	EventTypeExecute           = "execute"
+	EventTypeMigrate           = "migrate"
+	EventTypePinCode           = "pin_code"
+	EventTypeUnpinCode         = "unpin_code"
+	EventTypeSudo              = "sudo"
+	EventTypeReply             = "reply"
+	EventTypeGovContractResult = "gov_contract_result"
+)
+
+// event attributes returned from contract execution
+const (
+	AttributeReservedPrefix = "_"
+
+	AttributeKeyContractAddr  = "_contract_address"
+	AttributeKeyCodeID        = "code_id"
+	AttributeKeyResultDataHex = "result"
+	AttributeKeyFeature       = "feature"
+)

wasm/types/genesis.go

@@ -0,0 +1,100 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+func (s Sequence) ValidateBasic() error {
+	if len(s.IDKey) == 0 {
+		return sdkerrors.Wrap(ErrEmpty, "id key")
+	}
+	return nil
+}
+
+func (s GenesisState) ValidateBasic() error {
+	if err := s.Params.ValidateBasic(); err != nil {
+		return sdkerrors.Wrap(err, "params")
+	}
+	for i := range s.Codes {
+		if err := s.Codes[i].ValidateBasic(); err != nil {
+			return sdkerrors.Wrapf(err, "code: %d", i)
+		}
+	}
+	for i := range s.Contracts {
+		if err := s.Contracts[i].ValidateBasic(); err != nil {
+			return sdkerrors.Wrapf(err, "contract: %d", i)
+		}
+	}
+	for i := range s.Sequences {
+		if err := s.Sequences[i].ValidateBasic(); err != nil {
+			return sdkerrors.Wrapf(err, "sequence: %d", i)
+		}
+	}
+	for i := range s.GenMsgs {
+		if err := s.GenMsgs[i].ValidateBasic(); err != nil {
+			return sdkerrors.Wrapf(err, "gen message: %d", i)
+		}
+	}
+	return nil
+}
+
+func (c Code) ValidateBasic() error {
+	if c.CodeID == 0 {
+		return sdkerrors.Wrap(ErrEmpty, "code id")
+	}
+	if err := c.CodeInfo.ValidateBasic(); err != nil {
+		return sdkerrors.Wrap(err, "code info")
+	}
+	if err := validateWasmCode(c.CodeBytes); err != nil {
+		return sdkerrors.Wrap(err, "code bytes")
+	}
+	return nil
+}
+
+func (c Contract) ValidateBasic() error {
+	if _, err := sdk.AccAddressFromBech32(c.ContractAddress); err != nil {
+		return sdkerrors.Wrap(err, "contract address")
+	}
+	if err := c.ContractInfo.ValidateBasic(); err != nil {
+		return sdkerrors.Wrap(err, "contract info")
+	}
+
+	if c.ContractInfo.Created != nil {
+		return sdkerrors.Wrap(ErrInvalid, "created must be empty")
+	}
+	for i := range c.ContractState {
+		if err := c.ContractState[i].ValidateBasic(); err != nil {
+			return sdkerrors.Wrapf(err, "contract state %d", i)
+		}
+	}
+	return nil
+}
+
+// AsMsg returns the underlying cosmos-sdk message instance. Null when can not be mapped to a known type.
+func (m GenesisState_GenMsgs) AsMsg() sdk.Msg {
+	if msg := m.GetStoreCode(); msg != nil {
+		return msg
+	}
+	if msg := m.GetInstantiateContract(); msg != nil {
+		return msg
+	}
+	if msg := m.GetExecuteContract(); msg != nil {
+		return msg
+	}
+	return nil
+}
+
+func (m GenesisState_GenMsgs) ValidateBasic() error {
+	msg := m.AsMsg()
+	if msg == nil {
+		return sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "unknown message")
+	}
+	return msg.ValidateBasic()
+}
+
+// ValidateGenesis performs basic validation of supply genesis data returning an
+// error for any failed validation criteria.
+func ValidateGenesis(data GenesisState) error {
+	return data.ValidateBasic()
+}