tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: oraclemanager/tx.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	types1 "github.com/rarimo/rarimo-core/x/rarimocore/types"
	types "github.com/rarimo/rarimo-core/x/tokenmanager/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type MsgStake struct {
	Index  *OracleIndex `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
	Amount string       `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
	From   string       `protobuf:"bytes,3,opt,name=from,proto3" json:"from,omitempty"`
}

func (m *MsgStake) Reset()         { *m = MsgStake{} }
func (m *MsgStake) String() string { return proto.CompactTextString(m) }
func (*MsgStake) ProtoMessage()    {}
func (*MsgStake) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{0}
}
func (m *MsgStake) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgStake) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgStake.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgStake) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgStake.Merge(m, src)
}
func (m *MsgStake) XXX_Size() int {
	return m.Size()
}
func (m *MsgStake) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgStake.DiscardUnknown(m)
}

var xxx_messageInfo_MsgStake proto.InternalMessageInfo

func (m *MsgStake) GetIndex() *OracleIndex {
	if m != nil {
		return m.Index
	}
	return nil
}

func (m *MsgStake) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func (m *MsgStake) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

type MsgStakeResponse struct {
}

func (m *MsgStakeResponse) Reset()         { *m = MsgStakeResponse{} }
func (m *MsgStakeResponse) String() string { return proto.CompactTextString(m) }
func (*MsgStakeResponse) ProtoMessage()    {}
func (*MsgStakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{1}
}
func (m *MsgStakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgStakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgStakeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgStakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgStakeResponse.Merge(m, src)
}
func (m *MsgStakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgStakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgStakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgStakeResponse proto.InternalMessageInfo

type MsgUnstake struct {
	Index  *OracleIndex `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
	Sender string       `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
}

func (m *MsgUnstake) Reset()         { *m = MsgUnstake{} }
func (m *MsgUnstake) String() string { return proto.CompactTextString(m) }
func (*MsgUnstake) ProtoMessage()    {}
func (*MsgUnstake) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{2}
}
func (m *MsgUnstake) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUnstake) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUnstake.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUnstake) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUnstake.Merge(m, src)
}
func (m *MsgUnstake) XXX_Size() int {
	return m.Size()
}
func (m *MsgUnstake) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUnstake.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUnstake proto.InternalMessageInfo

func (m *MsgUnstake) GetIndex() *OracleIndex {
	if m != nil {
		return m.Index
	}
	return nil
}

func (m *MsgUnstake) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

type MsgUnstakeResponse struct {
}

func (m *MsgUnstakeResponse) Reset()         { *m = MsgUnstakeResponse{} }
func (m *MsgUnstakeResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUnstakeResponse) ProtoMessage()    {}
func (*MsgUnstakeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{3}
}
func (m *MsgUnstakeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUnstakeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUnstakeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUnstakeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUnstakeResponse.Merge(m, src)
}
func (m *MsgUnstakeResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgUnstakeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUnstakeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUnstakeResponse proto.InternalMessageInfo

type MsgCreateTransferOp struct {
	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	// Information to identify transfer
	Tx      string `protobuf:"bytes,2,opt,name=tx,proto3" json:"tx,omitempty"`
	EventId string `protobuf:"bytes,3,opt,name=eventId,proto3" json:"eventId,omitempty"`
	Sender  string `protobuf:"bytes,4,opt,name=sender,proto3" json:"sender,omitempty"`
	// Information about deposit
	Receiver   string `protobuf:"bytes,5,opt,name=receiver,proto3" json:"receiver,omitempty"`
	Amount     string `protobuf:"bytes,6,opt,name=amount,proto3" json:"amount,omitempty"`
	BundleData string `protobuf:"bytes,7,opt,name=bundleData,proto3" json:"bundleData,omitempty"`
	BundleSalt string `protobuf:"bytes,8,opt,name=bundleSalt,proto3" json:"bundleSalt,omitempty"`
	// Information about current and target chains
	From types.OnChainItemIndex `protobuf:"bytes,9,opt,name=from,proto3" json:"from"`
	To   types.OnChainItemIndex `protobuf:"bytes,10,opt,name=to,proto3" json:"to"`
	Meta *types.ItemMetadata    `protobuf:"bytes,11,opt,name=meta,proto3" json:"meta,omitempty"`
}

func (m *MsgCreateTransferOp) Reset()         { *m = MsgCreateTransferOp{} }
func (m *MsgCreateTransferOp) String() string { return proto.CompactTextString(m) }
func (*MsgCreateTransferOp) ProtoMessage()    {}
func (*MsgCreateTransferOp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{4}
}
func (m *MsgCreateTransferOp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateTransferOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateTransferOp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateTransferOp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateTransferOp.Merge(m, src)
}
func (m *MsgCreateTransferOp) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateTransferOp) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateTransferOp.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateTransferOp proto.InternalMessageInfo

func (m *MsgCreateTransferOp) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgCreateTransferOp) GetTx() string {
	if m != nil {
		return m.Tx
	}
	return ""
}

func (m *MsgCreateTransferOp) GetEventId() string {
	if m != nil {
		return m.EventId
	}
	return ""
}

func (m *MsgCreateTransferOp) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgCreateTransferOp) GetReceiver() string {
	if m != nil {
		return m.Receiver
	}
	return ""
}

func (m *MsgCreateTransferOp) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func (m *MsgCreateTransferOp) GetBundleData() string {
	if m != nil {
		return m.BundleData
	}
	return ""
}

func (m *MsgCreateTransferOp) GetBundleSalt() string {
	if m != nil {
		return m.BundleSalt
	}
	return ""
}

func (m *MsgCreateTransferOp) GetFrom() types.OnChainItemIndex {
	if m != nil {
		return m.From
	}
	return types.OnChainItemIndex{}
}

func (m *MsgCreateTransferOp) GetTo() types.OnChainItemIndex {
	if m != nil {
		return m.To
	}
	return types.OnChainItemIndex{}
}

func (m *MsgCreateTransferOp) GetMeta() *types.ItemMetadata {
	if m != nil {
		return m.Meta
	}
	return nil
}

type MsgCreateTransferOpResponse struct {
}

func (m *MsgCreateTransferOpResponse) Reset()         { *m = MsgCreateTransferOpResponse{} }
func (m *MsgCreateTransferOpResponse) String() string { return proto.CompactTextString(m) }
func (*MsgCreateTransferOpResponse) ProtoMessage()    {}
func (*MsgCreateTransferOpResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{5}
}
func (m *MsgCreateTransferOpResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateTransferOpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateTransferOpResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateTransferOpResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateTransferOpResponse.Merge(m, src)
}
func (m *MsgCreateTransferOpResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateTransferOpResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateTransferOpResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateTransferOpResponse proto.InternalMessageInfo

type MsgCreateIdentityDefaultTransferOp struct {
	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	// Hex 0x
	Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty"`
	Chain    string `protobuf:"bytes,3,opt,name=chain,proto3" json:"chain,omitempty"`
	// Hex 0x
	GISTHash string `protobuf:"bytes,4,opt,name=GISTHash,proto3" json:"GISTHash,omitempty"`
	// Hex 0x
	Id string `protobuf:"bytes,5,opt,name=id,proto3" json:"id,omitempty"`
	// Hex 0x
	StateHash string `protobuf:"bytes,6,opt,name=stateHash,proto3" json:"stateHash,omitempty"`
	// Dec
	StateCreatedAtTimestamp string `protobuf:"bytes,7,opt,name=stateCreatedAtTimestamp,proto3" json:"stateCreatedAtTimestamp,omitempty"`
	StateCreatedAtBlock     string `protobuf:"bytes,8,opt,name=stateCreatedAtBlock,proto3" json:"stateCreatedAtBlock,omitempty"`
	// Hex 0x
	StateReplacedBy string `protobuf:"bytes,11,opt,name=stateReplacedBy,proto3" json:"stateReplacedBy,omitempty"`
	GISTReplacedBy  string `protobuf:"bytes,12,opt,name=GISTReplacedBy,proto3" json:"GISTReplacedBy,omitempty"`
	// Dec
	GISTCreatedAtTimestamp string `protobuf:"bytes,13,opt,name=GISTCreatedAtTimestamp,proto3" json:"GISTCreatedAtTimestamp,omitempty"`
	GISTCreatedAtBlock     string `protobuf:"bytes,14,opt,name=GISTCreatedAtBlock,proto3" json:"GISTCreatedAtBlock,omitempty"`
	// HEx 0x
	ReplacedStateHash string `protobuf:"bytes,17,opt,name=replacedStateHash,proto3" json:"replacedStateHash,omitempty"`
	ReplacedGISTtHash string `protobuf:"bytes,18,opt,name=replacedGISTtHash,proto3" json:"replacedGISTtHash,omitempty"`
}

func (m *MsgCreateIdentityDefaultTransferOp) Reset()         { *m = MsgCreateIdentityDefaultTransferOp{} }
func (m *MsgCreateIdentityDefaultTransferOp) String() string { return proto.CompactTextString(m) }
func (*MsgCreateIdentityDefaultTransferOp) ProtoMessage()    {}
func (*MsgCreateIdentityDefaultTransferOp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{6}
}
func (m *MsgCreateIdentityDefaultTransferOp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateIdentityDefaultTransferOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateIdentityDefaultTransferOp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateIdentityDefaultTransferOp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateIdentityDefaultTransferOp.Merge(m, src)
}
func (m *MsgCreateIdentityDefaultTransferOp) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateIdentityDefaultTransferOp) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateIdentityDefaultTransferOp.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateIdentityDefaultTransferOp proto.InternalMessageInfo

func (m *MsgCreateIdentityDefaultTransferOp) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetGISTHash() string {
	if m != nil {
		return m.GISTHash
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetStateHash() string {
	if m != nil {
		return m.StateHash
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetStateCreatedAtTimestamp() string {
	if m != nil {
		return m.StateCreatedAtTimestamp
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetStateCreatedAtBlock() string {
	if m != nil {
		return m.StateCreatedAtBlock
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetStateReplacedBy() string {
	if m != nil {
		return m.StateReplacedBy
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetGISTReplacedBy() string {
	if m != nil {
		return m.GISTReplacedBy
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetGISTCreatedAtTimestamp() string {
	if m != nil {
		return m.GISTCreatedAtTimestamp
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetGISTCreatedAtBlock() string {
	if m != nil {
		return m.GISTCreatedAtBlock
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetReplacedStateHash() string {
	if m != nil {
		return m.ReplacedStateHash
	}
	return ""
}

func (m *MsgCreateIdentityDefaultTransferOp) GetReplacedGISTtHash() string {
	if m != nil {
		return m.ReplacedGISTtHash
	}
	return ""
}

type MsgCreateIdentityDefaultTransferOpResponse struct {
}

func (m *MsgCreateIdentityDefaultTransferOpResponse) Reset() {
	*m = MsgCreateIdentityDefaultTransferOpResponse{}
}
func (m *MsgCreateIdentityDefaultTransferOpResponse) String() string {
	return proto.CompactTextString(m)
}
func (*MsgCreateIdentityDefaultTransferOpResponse) ProtoMessage() {}
func (*MsgCreateIdentityDefaultTransferOpResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{7}
}
func (m *MsgCreateIdentityDefaultTransferOpResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateIdentityDefaultTransferOpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateIdentityDefaultTransferOpResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateIdentityDefaultTransferOpResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateIdentityDefaultTransferOpResponse.Merge(m, src)
}
func (m *MsgCreateIdentityDefaultTransferOpResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateIdentityDefaultTransferOpResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateIdentityDefaultTransferOpResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateIdentityDefaultTransferOpResponse proto.InternalMessageInfo

type MsgCreateIdentityGISTTransferOp struct {
	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	// Hex 0x
	Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty"`
	Chain    string `protobuf:"bytes,3,opt,name=chain,proto3" json:"chain,omitempty"`
	// Hex 0x
	GISTHash string `protobuf:"bytes,4,opt,name=GISTHash,proto3" json:"GISTHash,omitempty"`
	// Dec
	GISTCreatedAtTimestamp string `protobuf:"bytes,5,opt,name=GISTCreatedAtTimestamp,proto3" json:"GISTCreatedAtTimestamp,omitempty"`
	GISTCreatedAtBlock     string `protobuf:"bytes,6,opt,name=GISTCreatedAtBlock,proto3" json:"GISTCreatedAtBlock,omitempty"`
	// HEx 0x
	ReplacedGISTtHash string `protobuf:"bytes,7,opt,name=replacedGISTtHash,proto3" json:"replacedGISTtHash,omitempty"`
}

func (m *MsgCreateIdentityGISTTransferOp) Reset()         { *m = MsgCreateIdentityGISTTransferOp{} }
func (m *MsgCreateIdentityGISTTransferOp) String() string { return proto.CompactTextString(m) }
func (*MsgCreateIdentityGISTTransferOp) ProtoMessage()    {}
func (*MsgCreateIdentityGISTTransferOp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{8}
}
func (m *MsgCreateIdentityGISTTransferOp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateIdentityGISTTransferOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateIdentityGISTTransferOp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateIdentityGISTTransferOp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateIdentityGISTTransferOp.Merge(m, src)
}
func (m *MsgCreateIdentityGISTTransferOp) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateIdentityGISTTransferOp) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateIdentityGISTTransferOp.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateIdentityGISTTransferOp proto.InternalMessageInfo

func (m *MsgCreateIdentityGISTTransferOp) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgCreateIdentityGISTTransferOp) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

func (m *MsgCreateIdentityGISTTransferOp) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

func (m *MsgCreateIdentityGISTTransferOp) GetGISTHash() string {
	if m != nil {
		return m.GISTHash
	}
	return ""
}

func (m *MsgCreateIdentityGISTTransferOp) GetGISTCreatedAtTimestamp() string {
	if m != nil {
		return m.GISTCreatedAtTimestamp
	}
	return ""
}

func (m *MsgCreateIdentityGISTTransferOp) GetGISTCreatedAtBlock() string {
	if m != nil {
		return m.GISTCreatedAtBlock
	}
	return ""
}

func (m *MsgCreateIdentityGISTTransferOp) GetReplacedGISTtHash() string {
	if m != nil {
		return m.ReplacedGISTtHash
	}
	return ""
}

type MsgCreateIdentityGISTTransferOpResponse struct {
}

func (m *MsgCreateIdentityGISTTransferOpResponse) Reset() {
	*m = MsgCreateIdentityGISTTransferOpResponse{}
}
func (m *MsgCreateIdentityGISTTransferOpResponse) String() string { return proto.CompactTextString(m) }
func (*MsgCreateIdentityGISTTransferOpResponse) ProtoMessage()    {}
func (*MsgCreateIdentityGISTTransferOpResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{9}
}
func (m *MsgCreateIdentityGISTTransferOpResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateIdentityGISTTransferOpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateIdentityGISTTransferOpResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateIdentityGISTTransferOpResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateIdentityGISTTransferOpResponse.Merge(m, src)
}
func (m *MsgCreateIdentityGISTTransferOpResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateIdentityGISTTransferOpResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateIdentityGISTTransferOpResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateIdentityGISTTransferOpResponse proto.InternalMessageInfo

type MsgCreateIdentityStateTransferOp struct {
	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	// Hex 0x
	Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty"`
	Chain    string `protobuf:"bytes,3,opt,name=chain,proto3" json:"chain,omitempty"`
	// Hex 0x
	Id string `protobuf:"bytes,5,opt,name=id,proto3" json:"id,omitempty"`
	// Hex 0x
	StateHash string `protobuf:"bytes,6,opt,name=stateHash,proto3" json:"stateHash,omitempty"`
	// Dec
	StateCreatedAtTimestamp string `protobuf:"bytes,7,opt,name=stateCreatedAtTimestamp,proto3" json:"stateCreatedAtTimestamp,omitempty"`
	StateCreatedAtBlock     string `protobuf:"bytes,8,opt,name=stateCreatedAtBlock,proto3" json:"stateCreatedAtBlock,omitempty"`
	// HEx 0x
	ReplacedStateHash string `protobuf:"bytes,17,opt,name=replacedStateHash,proto3" json:"replacedStateHash,omitempty"`
}

func (m *MsgCreateIdentityStateTransferOp) Reset()         { *m = MsgCreateIdentityStateTransferOp{} }
func (m *MsgCreateIdentityStateTransferOp) String() string { return proto.CompactTextString(m) }
func (*MsgCreateIdentityStateTransferOp) ProtoMessage()    {}
func (*MsgCreateIdentityStateTransferOp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{10}
}
func (m *MsgCreateIdentityStateTransferOp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateIdentityStateTransferOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateIdentityStateTransferOp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateIdentityStateTransferOp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateIdentityStateTransferOp.Merge(m, src)
}
func (m *MsgCreateIdentityStateTransferOp) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateIdentityStateTransferOp) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateIdentityStateTransferOp.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateIdentityStateTransferOp proto.InternalMessageInfo

func (m *MsgCreateIdentityStateTransferOp) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgCreateIdentityStateTransferOp) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

func (m *MsgCreateIdentityStateTransferOp) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

func (m *MsgCreateIdentityStateTransferOp) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *MsgCreateIdentityStateTransferOp) GetStateHash() string {
	if m != nil {
		return m.StateHash
	}
	return ""
}

func (m *MsgCreateIdentityStateTransferOp) GetStateCreatedAtTimestamp() string {
	if m != nil {
		return m.StateCreatedAtTimestamp
	}
	return ""
}

func (m *MsgCreateIdentityStateTransferOp) GetStateCreatedAtBlock() string {
	if m != nil {
		return m.StateCreatedAtBlock
	}
	return ""
}

func (m *MsgCreateIdentityStateTransferOp) GetReplacedStateHash() string {
	if m != nil {
		return m.ReplacedStateHash
	}
	return ""
}

type MsgCreateIdentityStateTransferOpResponse struct {
}

func (m *MsgCreateIdentityStateTransferOpResponse) Reset() {
	*m = MsgCreateIdentityStateTransferOpResponse{}
}
func (m *MsgCreateIdentityStateTransferOpResponse) String() string { return proto.CompactTextString(m) }
func (*MsgCreateIdentityStateTransferOpResponse) ProtoMessage()    {}
func (*MsgCreateIdentityStateTransferOpResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{11}
}
func (m *MsgCreateIdentityStateTransferOpResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateIdentityStateTransferOpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateIdentityStateTransferOpResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateIdentityStateTransferOpResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateIdentityStateTransferOpResponse.Merge(m, src)
}
func (m *MsgCreateIdentityStateTransferOpResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateIdentityStateTransferOpResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateIdentityStateTransferOpResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateIdentityStateTransferOpResponse proto.InternalMessageInfo

type MsgCreateWorldCoinIdentityTransferOp struct {
	Creator  string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	Contract string `protobuf:"bytes,2,opt,name=contract,proto3" json:"contract,omitempty"`
	Chain    string `protobuf:"bytes,3,opt,name=chain,proto3" json:"chain,omitempty"`
	// Hex 0x uint256
	PrevState string `protobuf:"bytes,4,opt,name=prevState,proto3" json:"prevState,omitempty"`
	// Hex 0x uint256
	State string `protobuf:"bytes,5,opt,name=state,proto3" json:"state,omitempty"`
	// Dec uint256
	Timestamp   string `protobuf:"bytes,6,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	BlockNumber uint64 `protobuf:"varint,7,opt,name=blockNumber,proto3" json:"blockNumber,omitempty"`
}

func (m *MsgCreateWorldCoinIdentityTransferOp) Reset()         { *m = MsgCreateWorldCoinIdentityTransferOp{} }
func (m *MsgCreateWorldCoinIdentityTransferOp) String() string { return proto.CompactTextString(m) }
func (*MsgCreateWorldCoinIdentityTransferOp) ProtoMessage()    {}
func (*MsgCreateWorldCoinIdentityTransferOp) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{12}
}
func (m *MsgCreateWorldCoinIdentityTransferOp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateWorldCoinIdentityTransferOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateWorldCoinIdentityTransferOp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateWorldCoinIdentityTransferOp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateWorldCoinIdentityTransferOp.Merge(m, src)
}
func (m *MsgCreateWorldCoinIdentityTransferOp) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateWorldCoinIdentityTransferOp) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateWorldCoinIdentityTransferOp.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateWorldCoinIdentityTransferOp proto.InternalMessageInfo

func (m *MsgCreateWorldCoinIdentityTransferOp) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgCreateWorldCoinIdentityTransferOp) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

func (m *MsgCreateWorldCoinIdentityTransferOp) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

func (m *MsgCreateWorldCoinIdentityTransferOp) GetPrevState() string {
	if m != nil {
		return m.PrevState
	}
	return ""
}

func (m *MsgCreateWorldCoinIdentityTransferOp) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *MsgCreateWorldCoinIdentityTransferOp) GetTimestamp() string {
	if m != nil {
		return m.Timestamp
	}
	return ""
}

func (m *MsgCreateWorldCoinIdentityTransferOp) GetBlockNumber() uint64 {
	if m != nil {
		return m.BlockNumber
	}
	return 0
}

type MsgCreateWorldCoinIdentityTransferOpResponse struct {
}

func (m *MsgCreateWorldCoinIdentityTransferOpResponse) Reset() {
	*m = MsgCreateWorldCoinIdentityTransferOpResponse{}
}
func (m *MsgCreateWorldCoinIdentityTransferOpResponse) String() string {
	return proto.CompactTextString(m)
}
func (*MsgCreateWorldCoinIdentityTransferOpResponse) ProtoMessage() {}
func (*MsgCreateWorldCoinIdentityTransferOpResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{13}
}
func (m *MsgCreateWorldCoinIdentityTransferOpResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreateWorldCoinIdentityTransferOpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreateWorldCoinIdentityTransferOpResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreateWorldCoinIdentityTransferOpResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreateWorldCoinIdentityTransferOpResponse.Merge(m, src)
}
func (m *MsgCreateWorldCoinIdentityTransferOpResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreateWorldCoinIdentityTransferOpResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreateWorldCoinIdentityTransferOpResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreateWorldCoinIdentityTransferOpResponse proto.InternalMessageInfo

type MsgVote struct {
	Index     *OracleIndex    `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
	Operation string          `protobuf:"bytes,2,opt,name=operation,proto3" json:"operation,omitempty"`
	Vote      types1.VoteType `protobuf:"varint,3,opt,name=vote,proto3,enum=rarimo.rarimocore.rarimocore.VoteType" json:"vote,omitempty"`
}

func (m *MsgVote) Reset()         { *m = MsgVote{} }
func (m *MsgVote) String() string { return proto.CompactTextString(m) }
func (*MsgVote) ProtoMessage()    {}
func (*MsgVote) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{14}
}
func (m *MsgVote) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgVote.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgVote) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgVote.Merge(m, src)
}
func (m *MsgVote) XXX_Size() int {
	return m.Size()
}
func (m *MsgVote) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgVote.DiscardUnknown(m)
}

var xxx_messageInfo_MsgVote proto.InternalMessageInfo

func (m *MsgVote) GetIndex() *OracleIndex {
	if m != nil {
		return m.Index
	}
	return nil
}

func (m *MsgVote) GetOperation() string {
	if m != nil {
		return m.Operation
	}
	return ""
}

func (m *MsgVote) GetVote() types1.VoteType {
	if m != nil {
		return m.Vote
	}
	return types1.VoteType_YES
}

type MsgVoteResponse struct {
}

func (m *MsgVoteResponse) Reset()         { *m = MsgVoteResponse{} }
func (m *MsgVoteResponse) String() string { return proto.CompactTextString(m) }
func (*MsgVoteResponse) ProtoMessage()    {}
func (*MsgVoteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{15}
}
func (m *MsgVoteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgVoteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgVoteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgVoteResponse.Merge(m, src)
}
func (m *MsgVoteResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgVoteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgVoteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgVoteResponse proto.InternalMessageInfo

type MsgUnjail struct {
	Index *OracleIndex `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
}

func (m *MsgUnjail) Reset()         { *m = MsgUnjail{} }
func (m *MsgUnjail) String() string { return proto.CompactTextString(m) }
func (*MsgUnjail) ProtoMessage()    {}
func (*MsgUnjail) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{16}
}
func (m *MsgUnjail) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUnjail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUnjail.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUnjail) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUnjail.Merge(m, src)
}
func (m *MsgUnjail) XXX_Size() int {
	return m.Size()
}
func (m *MsgUnjail) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUnjail.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUnjail proto.InternalMessageInfo

func (m *MsgUnjail) GetIndex() *OracleIndex {
	if m != nil {
		return m.Index
	}
	return nil
}

type MsgUnjailResponse struct {
}

func (m *MsgUnjailResponse) Reset()         { *m = MsgUnjailResponse{} }
func (m *MsgUnjailResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUnjailResponse) ProtoMessage()    {}
func (*MsgUnjailResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d374eae837d744eb, []int{17}
}
func (m *MsgUnjailResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUnjailResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUnjailResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgUnjailResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUnjailResponse.Merge(m, src)
}
func (m *MsgUnjailResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgUnjailResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUnjailResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUnjailResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgStake)(nil), "rarimo.rarimocore.oraclemanager.MsgStake")
	proto.RegisterType((*MsgStakeResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgStakeResponse")
	proto.RegisterType((*MsgUnstake)(nil), "rarimo.rarimocore.oraclemanager.MsgUnstake")
	proto.RegisterType((*MsgUnstakeResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgUnstakeResponse")
	proto.RegisterType((*MsgCreateTransferOp)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateTransferOp")
	proto.RegisterType((*MsgCreateTransferOpResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateTransferOpResponse")
	proto.RegisterType((*MsgCreateIdentityDefaultTransferOp)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateIdentityDefaultTransferOp")
	proto.RegisterType((*MsgCreateIdentityDefaultTransferOpResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateIdentityDefaultTransferOpResponse")
	proto.RegisterType((*MsgCreateIdentityGISTTransferOp)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateIdentityGISTTransferOp")
	proto.RegisterType((*MsgCreateIdentityGISTTransferOpResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateIdentityGISTTransferOpResponse")
	proto.RegisterType((*MsgCreateIdentityStateTransferOp)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateIdentityStateTransferOp")
	proto.RegisterType((*MsgCreateIdentityStateTransferOpResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateIdentityStateTransferOpResponse")
	proto.RegisterType((*MsgCreateWorldCoinIdentityTransferOp)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateWorldCoinIdentityTransferOp")
	proto.RegisterType((*MsgCreateWorldCoinIdentityTransferOpResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgCreateWorldCoinIdentityTransferOpResponse")
	proto.RegisterType((*MsgVote)(nil), "rarimo.rarimocore.oraclemanager.MsgVote")
	proto.RegisterType((*MsgVoteResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgVoteResponse")
	proto.RegisterType((*MsgUnjail)(nil), "rarimo.rarimocore.oraclemanager.MsgUnjail")
	proto.RegisterType((*MsgUnjailResponse)(nil), "rarimo.rarimocore.oraclemanager.MsgUnjailResponse")
}

func init() { proto.RegisterFile("oraclemanager/tx.proto", fileDescriptor_d374eae837d744eb) }

var fileDescriptor_d374eae837d744eb = []byte{
	// 1064 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcf, 0x6e, 0x23, 0xc5,
	0x13, 0xce, 0x38, 0xfe, 0x13, 0x57, 0x7e, 0xbf, 0x2c, 0xe9, 0x84, 0xc4, 0x1a, 0x82, 0x13, 0x0d,
	0xab, 0xe0, 0x0d, 0xc1, 0x0e, 0x09, 0x42, 0x08, 0x71, 0xd8, 0x75, 0x16, 0x58, 0x83, 0x4c, 0x24,
	0x27, 0x80, 0xc4, 0xad, 0x3d, 0xd3, 0xb1, 0x87, 0x78, 0xa6, 0xad, 0x9e, 0x76, 0xe4, 0xf0, 0x0e,
	0x48, 0xbc, 0x01, 0x12, 0x17, 0xce, 0x48, 0x88, 0x03, 0x70, 0xe0, 0xb8, 0xc7, 0x3d, 0x72, 0x42,
	0x28, 0x91, 0x78, 0x0e, 0xd4, 0x3d, 0x3d, 0xed, 0xb1, 0x63, 0xc7, 0x93, 0x8d, 0x57, 0x70, 0xf2,
	0x54, 0xd5, 0x57, 0x55, 0xdf, 0x7c, 0x55, 0xe9, 0xb4, 0x0d, 0x6b, 0x94, 0x61, 0xbb, 0x43, 0x3c,
	0xec, 0xe3, 0x16, 0x61, 0x15, 0xde, 0x2f, 0x77, 0x19, 0xe5, 0x14, 0x6d, 0x32, 0xcc, 0x5c, 0x8f,
	0x96, 0xc3, 0x0f, 0x9b, 0x32, 0x52, 0x1e, 0x42, 0x9a, 0xeb, 0x9c, 0x9e, 0x11, 0x3f, 0xca, 0x73,
	0x39, 0xf1, 0xc2, 0x4c, 0xf3, 0xe5, 0x41, 0x4a, 0xe5, 0x9c, 0x72, 0xa2, 0xdc, 0xe6, 0x70, 0xa3,
	0xd0, 0x52, 0xb1, 0xd5, 0x16, 0x6d, 0x51, 0xf9, 0x58, 0x11, 0x4f, 0xa1, 0xd7, 0xfa, 0x1a, 0x16,
	0xea, 0x41, 0xeb, 0x98, 0xe3, 0x33, 0x82, 0xaa, 0x90, 0x71, 0x7d, 0x87, 0xf4, 0x0b, 0xc6, 0x96,
	0x51, 0x5a, 0xdc, 0xdf, 0x2d, 0x4f, 0xa1, 0x57, 0x3e, 0x92, 0x56, 0x4d, 0xe4, 0x34, 0xc2, 0x54,
	0xb4, 0x06, 0x59, 0xec, 0xd1, 0x9e, 0xcf, 0x0b, 0xa9, 0x2d, 0xa3, 0x94, 0x6f, 0x28, 0x0b, 0x21,
	0x48, 0x9f, 0x32, 0xea, 0x15, 0xe6, 0xa5, 0x57, 0x3e, 0x5b, 0x08, 0x5e, 0x8a, 0x7a, 0x37, 0x48,
	0xd0, 0xa5, 0x7e, 0x40, 0xac, 0x36, 0x40, 0x3d, 0x68, 0x7d, 0xe6, 0x07, 0xb3, 0x64, 0x14, 0x10,
	0xdf, 0x21, 0x2c, 0x62, 0x14, 0x5a, 0xd6, 0x2a, 0xa0, 0x41, 0x27, 0xdd, 0xff, 0xd7, 0x79, 0x58,
	0xa9, 0x07, 0xad, 0x43, 0x46, 0x30, 0x27, 0x27, 0x0c, 0xfb, 0xc1, 0x29, 0x61, 0x47, 0x5d, 0x54,
	0x80, 0x9c, 0x2d, 0x7c, 0x94, 0x49, 0x2e, 0xf9, 0x46, 0x64, 0xa2, 0x25, 0x48, 0xf1, 0xbe, 0xaa,
	0x9d, 0xe2, 0x7d, 0x81, 0x24, 0xe7, 0xc4, 0xe7, 0x35, 0x47, 0xbd, 0x6c, 0x64, 0xc6, 0x98, 0xa4,
	0xe3, 0x4c, 0x90, 0x09, 0x0b, 0x8c, 0xd8, 0xc4, 0x3d, 0x27, 0xac, 0x90, 0x91, 0x11, 0x6d, 0xc7,
	0xf4, 0xcc, 0x0e, 0xe9, 0x59, 0x04, 0x68, 0xf6, 0x7c, 0xa7, 0x43, 0x1e, 0x63, 0x8e, 0x0b, 0x39,
	0x19, 0x8b, 0x79, 0x06, 0xf1, 0x63, 0xdc, 0xe1, 0x85, 0x85, 0x78, 0x5c, 0x78, 0xd0, 0xc7, 0x6a,
	0x1e, 0x79, 0x29, 0xec, 0xde, 0x18, 0x61, 0xe3, 0xab, 0x57, 0x3e, 0xf2, 0x0f, 0xdb, 0xd8, 0xf5,
	0x6b, 0x9c, 0x78, 0x52, 0xdc, 0x6a, 0xfa, 0xe9, 0x9f, 0x9b, 0x73, 0xe1, 0x1c, 0xd1, 0x87, 0x90,
	0xe2, 0xb4, 0x00, 0x77, 0xaa, 0x94, 0xe2, 0x14, 0x3d, 0x84, 0xb4, 0x47, 0x38, 0x2e, 0x2c, 0x4e,
	0x1c, 0xf6, 0x50, 0x25, 0x51, 0xa2, 0x4e, 0x38, 0x76, 0x30, 0xc7, 0x0d, 0x99, 0x69, 0xbd, 0x0a,
	0xaf, 0x8c, 0x19, 0x9e, 0x1e, 0xee, 0x6f, 0x69, 0xb0, 0x74, 0xbc, 0xe6, 0x10, 0x9f, 0xbb, 0xfc,
	0xe2, 0x31, 0x39, 0xc5, 0xbd, 0x0e, 0x4f, 0x34, 0x6b, 0x13, 0x16, 0x6c, 0xea, 0x73, 0x86, 0xed,
	0x68, 0xbf, 0xb5, 0x8d, 0x56, 0x21, 0x63, 0x8b, 0x37, 0x53, 0x53, 0x0f, 0x0d, 0x91, 0xf1, 0x51,
	0xed, 0xf8, 0xe4, 0x09, 0x0e, 0xda, 0x6a, 0xea, 0xda, 0x16, 0x9b, 0xe3, 0x3a, 0x6a, 0xe2, 0x29,
	0xd7, 0x41, 0x1b, 0x90, 0x0f, 0x38, 0xe6, 0x44, 0x82, 0xc3, 0x71, 0x0f, 0x1c, 0xe8, 0x5d, 0x58,
	0x97, 0x46, 0xc8, 0xde, 0x79, 0xc4, 0x4f, 0x5c, 0x8f, 0x04, 0x1c, 0x7b, 0x5d, 0x35, 0xfe, 0x49,
	0x61, 0xb4, 0x07, 0x2b, 0xc3, 0xa1, 0x6a, 0x87, 0xda, 0x67, 0x6a, 0x29, 0xc6, 0x85, 0x50, 0x09,
	0xee, 0x49, 0x77, 0x83, 0x74, 0x3b, 0xd8, 0x26, 0x4e, 0xf5, 0x42, 0x0e, 0x25, 0xdf, 0x18, 0x75,
	0xa3, 0x6d, 0x58, 0x12, 0xef, 0x13, 0x03, 0xfe, 0x4f, 0x02, 0x47, 0xbc, 0xe8, 0x1d, 0x58, 0x13,
	0x9e, 0x31, 0xe4, 0xff, 0x2f, 0xf1, 0x13, 0xa2, 0xa8, 0x0c, 0x68, 0x28, 0x12, 0x52, 0x5f, 0x92,
	0x39, 0x63, 0x22, 0x68, 0x17, 0x96, 0x99, 0xea, 0x7a, 0xac, 0xb5, 0x5c, 0x96, 0xf0, 0xeb, 0x81,
	0x38, 0x5a, 0xd4, 0xe2, 0x12, 0x8d, 0x86, 0xd1, 0x3a, 0x60, 0xed, 0xc2, 0xce, 0xf4, 0xed, 0xd1,
	0xcb, 0xf6, 0x5d, 0x0a, 0x36, 0xaf, 0xc1, 0x45, 0xb1, 0x7f, 0x61, 0xd3, 0x26, 0xab, 0x9f, 0x79,
	0x0e, 0xf5, 0xb3, 0x49, 0xd4, 0x1f, 0xe8, 0x99, 0x9b, 0xa4, 0xe7, 0x03, 0x78, 0x7d, 0x8a, 0x40,
	0x5a, 0xcc, 0x9f, 0x53, 0xb0, 0x75, 0x0d, 0x2b, 0xe7, 0xf8, 0x82, 0xd4, 0xfc, 0xef, 0xfe, 0x6d,
	0xde, 0x6a, 0xc3, 0xad, 0x1d, 0x28, 0x4d, 0xd3, 0x4d, 0x8b, 0xfc, 0xb7, 0x01, 0xf7, 0x35, 0xf8,
	0x0b, 0xca, 0x3a, 0xce, 0x21, 0x75, 0xfd, 0x28, 0xeb, 0x05, 0x09, 0xbd, 0x01, 0xf9, 0x2e, 0x23,
	0xe7, 0x92, 0x93, 0xda, 0xdb, 0x81, 0x43, 0xe4, 0x48, 0x0d, 0xd4, 0x24, 0x42, 0x43, 0xe4, 0x70,
	0x2d, 0xb0, 0x1a, 0x86, 0x76, 0xa0, 0x2d, 0x58, 0x6c, 0x0a, 0xa5, 0x3e, 0xed, 0x79, 0x4d, 0xc2,
	0xe4, 0x00, 0xd2, 0x8d, 0xb8, 0xcb, 0x2a, 0xc3, 0x6e, 0x92, 0xf7, 0xd4, 0xc2, 0xfc, 0x60, 0x40,
	0xae, 0x1e, 0xb4, 0x3e, 0xa7, 0x7c, 0x36, 0x57, 0x92, 0x0d, 0xc8, 0xd3, 0x2e, 0x61, 0x98, 0xbb,
	0xd4, 0x57, 0x32, 0x0d, 0x1c, 0xe8, 0x3d, 0x48, 0x8b, 0x2b, 0x9d, 0x94, 0x69, 0x69, 0x7f, 0x7b,
	0x4c, 0x83, 0xd8, 0xa3, 0xe0, 0x74, 0x72, 0xd1, 0x25, 0x0d, 0x99, 0x63, 0x2d, 0xc3, 0x3d, 0x45,
	0x54, 0x93, 0x3f, 0x82, 0xbc, 0xbc, 0xe7, 0x7c, 0x85, 0xdd, 0xce, 0x2c, 0xd8, 0x5b, 0x2b, 0xb0,
	0xac, 0x0b, 0x46, 0x5d, 0xf6, 0xbf, 0x07, 0x98, 0xaf, 0x07, 0x2d, 0x44, 0x20, 0x13, 0x5e, 0x26,
	0x1f, 0x4c, 0x2d, 0x1d, 0xdd, 0xfd, 0xcc, 0xb7, 0x12, 0x43, 0xa3, 0x76, 0xe8, 0x0c, 0x72, 0xd1,
	0x1d, 0xf1, 0x8d, 0x24, 0xd9, 0x0a, 0x6c, 0x1e, 0xdc, 0x02, 0xac, 0x9b, 0x7d, 0x63, 0xc0, 0xfa,
	0xe8, 0x9d, 0x22, 0x1a, 0xd6, 0xdb, 0x49, 0x0a, 0x8e, 0x26, 0x9b, 0xef, 0x3f, 0x4f, 0x96, 0xe6,
	0xf3, 0x8b, 0x01, 0xdb, 0x53, 0xfe, 0x0b, 0x45, 0xf4, 0x0e, 0x93, 0x37, 0x9a, 0x58, 0xcb, 0xfc,
	0x64, 0x06, 0x45, 0x34, 0xf9, 0x1f, 0x0d, 0x78, 0xed, 0xa6, 0x23, 0x3f, 0x62, 0xfe, 0xf0, 0xf6,
	0x4d, 0x87, 0x0b, 0x99, 0x4f, 0xee, 0x5a, 0x41, 0x73, 0xfe, 0xc9, 0x80, 0xfb, 0x37, 0x1e, 0xa1,
	0x11, 0xe9, 0x47, 0xb7, 0x6f, 0x39, 0x52, 0xc9, 0xac, 0xdd, 0xb9, 0x84, 0xa6, 0xfd, 0xbb, 0x01,
	0xa5, 0xa9, 0x87, 0x5c, 0x44, 0xfd, 0x83, 0xe4, 0x7d, 0x6f, 0xa8, 0x66, 0xd6, 0x67, 0x52, 0x46,
	0xbf, 0x42, 0x13, 0xd2, 0xf2, 0xd4, 0x2d, 0x25, 0x29, 0x2b, 0x90, 0xe6, 0x5e, 0x52, 0xa4, 0xee,
	0xd1, 0x86, 0xac, 0x3a, 0x1d, 0x77, 0x92, 0x9d, 0x0e, 0x02, 0x6b, 0xee, 0x27, 0xc7, 0x46, 0x9d,
	0xaa, 0xf5, 0xa7, 0x97, 0x45, 0xe3, 0xd9, 0x65, 0xd1, 0xf8, 0xeb, 0xb2, 0x68, 0x7c, 0x7b, 0x55,
	0x9c, 0x7b, 0x76, 0x55, 0x9c, 0xfb, 0xe3, 0xaa, 0x38, 0xf7, 0xe5, 0x41, 0xcb, 0xe5, 0xed, 0x5e,
	0xb3, 0x6c, 0x53, 0xaf, 0x12, 0x16, 0x54, 0x1f, 0x6f, 0xca, 0xaf, 0xf8, 0xfd, 0xca, 0xc8, 0x2f,
	0x08, 0x17, 0x5d, 0x12, 0x34, 0xb3, 0xf2, 0x2b, 0xfc, 0xc1, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff,
	0x92, 0x07, 0x98, 0xaf, 0x5f, 0x10, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	Stake(ctx context.Context, in *MsgStake, opts ...grpc.CallOption) (*MsgStakeResponse, error)
	Unstake(ctx context.Context, in *MsgUnstake, opts ...grpc.CallOption) (*MsgUnstakeResponse, error)
	CreateTransferOperation(ctx context.Context, in *MsgCreateTransferOp, opts ...grpc.CallOption) (*MsgCreateTransferOpResponse, error)
	CreateIdentityDefaultTransferOperation(ctx context.Context, in *MsgCreateIdentityDefaultTransferOp, opts ...grpc.CallOption) (*MsgCreateIdentityDefaultTransferOpResponse, error)
	CreateIdentityGISTTransferOperation(ctx context.Context, in *MsgCreateIdentityGISTTransferOp, opts ...grpc.CallOption) (*MsgCreateIdentityGISTTransferOpResponse, error)
	CreateIdentityStateTransferOperation(ctx context.Context, in *MsgCreateIdentityStateTransferOp, opts ...grpc.CallOption) (*MsgCreateIdentityStateTransferOpResponse, error)
	CreateWorldCoinIdentityTransferOperation(ctx context.Context, in *MsgCreateWorldCoinIdentityTransferOp, opts ...grpc.CallOption) (*MsgCreateWorldCoinIdentityTransferOpResponse, error)
	Vote(ctx context.Context, in *MsgVote, opts ...grpc.CallOption) (*MsgVoteResponse, error)
	Unjail(ctx context.Context, in *MsgUnjail, opts ...grpc.CallOption) (*MsgUnjailResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) Stake(ctx context.Context, in *MsgStake, opts ...grpc.CallOption) (*MsgStakeResponse, error) {
	out := new(MsgStakeResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/Stake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Unstake(ctx context.Context, in *MsgUnstake, opts ...grpc.CallOption) (*MsgUnstakeResponse, error) {
	out := new(MsgUnstakeResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/Unstake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateTransferOperation(ctx context.Context, in *MsgCreateTransferOp, opts ...grpc.CallOption) (*MsgCreateTransferOpResponse, error) {
	out := new(MsgCreateTransferOpResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/CreateTransferOperation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateIdentityDefaultTransferOperation(ctx context.Context, in *MsgCreateIdentityDefaultTransferOp, opts ...grpc.CallOption) (*MsgCreateIdentityDefaultTransferOpResponse, error) {
	out := new(MsgCreateIdentityDefaultTransferOpResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/CreateIdentityDefaultTransferOperation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateIdentityGISTTransferOperation(ctx context.Context, in *MsgCreateIdentityGISTTransferOp, opts ...grpc.CallOption) (*MsgCreateIdentityGISTTransferOpResponse, error) {
	out := new(MsgCreateIdentityGISTTransferOpResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/CreateIdentityGISTTransferOperation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateIdentityStateTransferOperation(ctx context.Context, in *MsgCreateIdentityStateTransferOp, opts ...grpc.CallOption) (*MsgCreateIdentityStateTransferOpResponse, error) {
	out := new(MsgCreateIdentityStateTransferOpResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/CreateIdentityStateTransferOperation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateWorldCoinIdentityTransferOperation(ctx context.Context, in *MsgCreateWorldCoinIdentityTransferOp, opts ...grpc.CallOption) (*MsgCreateWorldCoinIdentityTransferOpResponse, error) {
	out := new(MsgCreateWorldCoinIdentityTransferOpResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/CreateWorldCoinIdentityTransferOperation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Vote(ctx context.Context, in *MsgVote, opts ...grpc.CallOption) (*MsgVoteResponse, error) {
	out := new(MsgVoteResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/Vote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Unjail(ctx context.Context, in *MsgUnjail, opts ...grpc.CallOption) (*MsgUnjailResponse, error) {
	out := new(MsgUnjailResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.oraclemanager.Msg/Unjail", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	Stake(context.Context, *MsgStake) (*MsgStakeResponse, error)
	Unstake(context.Context, *MsgUnstake) (*MsgUnstakeResponse, error)
	CreateTransferOperation(context.Context, *MsgCreateTransferOp) (*MsgCreateTransferOpResponse, error)
	CreateIdentityDefaultTransferOperation(context.Context, *MsgCreateIdentityDefaultTransferOp) (*MsgCreateIdentityDefaultTransferOpResponse, error)
	CreateIdentityGISTTransferOperation(context.Context, *MsgCreateIdentityGISTTransferOp) (*MsgCreateIdentityGISTTransferOpResponse, error)
	CreateIdentityStateTransferOperation(context.Context, *MsgCreateIdentityStateTransferOp) (*MsgCreateIdentityStateTransferOpResponse, error)
	CreateWorldCoinIdentityTransferOperation(context.Context, *MsgCreateWorldCoinIdentityTransferOp) (*MsgCreateWorldCoinIdentityTransferOpResponse, error)
	Vote(context.Context, *MsgVote) (*MsgVoteResponse, error)
	Unjail(context.Context, *MsgUnjail) (*MsgUnjailResponse, error)
}

// UnimplementedMsgServer can be embedded to have forward compatible implementations.
type UnimplementedMsgServer struct {
}

func (*UnimplementedMsgServer) Stake(ctx context.Context, req *MsgStake) (*MsgStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Stake not implemented")
}
func (*UnimplementedMsgServer) Unstake(ctx context.Context, req *MsgUnstake) (*MsgUnstakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Unstake not implemented")
}
func (*UnimplementedMsgServer) CreateTransferOperation(ctx context.Context, req *MsgCreateTransferOp) (*MsgCreateTransferOpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTransferOperation not implemented")
}
func (*UnimplementedMsgServer) CreateIdentityDefaultTransferOperation(ctx context.Context, req *MsgCreateIdentityDefaultTransferOp) (*MsgCreateIdentityDefaultTransferOpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateIdentityDefaultTransferOperation not implemented")
}
func (*UnimplementedMsgServer) CreateIdentityGISTTransferOperation(ctx context.Context, req *MsgCreateIdentityGISTTransferOp) (*MsgCreateIdentityGISTTransferOpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateIdentityGISTTransferOperation not implemented")
}
func (*UnimplementedMsgServer) CreateIdentityStateTransferOperation(ctx context.Context, req *MsgCreateIdentityStateTransferOp) (*MsgCreateIdentityStateTransferOpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateIdentityStateTransferOperation not implemented")
}
func (*UnimplementedMsgServer) CreateWorldCoinIdentityTransferOperation(ctx context.Context, req *MsgCreateWorldCoinIdentityTransferOp) (*MsgCreateWorldCoinIdentityTransferOpResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateWorldCoinIdentityTransferOperation not implemented")
}
func (*UnimplementedMsgServer) Vote(ctx context.Context, req *MsgVote) (*MsgVoteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Vote not implemented")
}
func (*UnimplementedMsgServer) Unjail(ctx context.Context, req *MsgUnjail) (*MsgUnjailResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Unjail not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_Stake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgStake)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Stake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/Stake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Stake(ctx, req.(*MsgStake))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Unstake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUnstake)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Unstake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/Unstake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Unstake(ctx, req.(*MsgUnstake))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CreateTransferOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateTransferOp)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateTransferOperation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/CreateTransferOperation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateTransferOperation(ctx, req.(*MsgCreateTransferOp))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CreateIdentityDefaultTransferOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateIdentityDefaultTransferOp)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateIdentityDefaultTransferOperation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/CreateIdentityDefaultTransferOperation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateIdentityDefaultTransferOperation(ctx, req.(*MsgCreateIdentityDefaultTransferOp))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CreateIdentityGISTTransferOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateIdentityGISTTransferOp)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateIdentityGISTTransferOperation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/CreateIdentityGISTTransferOperation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateIdentityGISTTransferOperation(ctx, req.(*MsgCreateIdentityGISTTransferOp))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CreateIdentityStateTransferOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateIdentityStateTransferOp)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateIdentityStateTransferOperation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/CreateIdentityStateTransferOperation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateIdentityStateTransferOperation(ctx, req.(*MsgCreateIdentityStateTransferOp))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CreateWorldCoinIdentityTransferOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateWorldCoinIdentityTransferOp)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateWorldCoinIdentityTransferOperation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/CreateWorldCoinIdentityTransferOperation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateWorldCoinIdentityTransferOperation(ctx, req.(*MsgCreateWorldCoinIdentityTransferOp))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Vote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgVote)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Vote(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/Vote",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Vote(ctx, req.(*MsgVote))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Unjail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUnjail)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Unjail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.oraclemanager.Msg/Unjail",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Unjail(ctx, req.(*MsgUnjail))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rarimo.rarimocore.oraclemanager.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Stake",
			Handler:    _Msg_Stake_Handler,
		},
		{
			MethodName: "Unstake",
			Handler:    _Msg_Unstake_Handler,
		},
		{
			MethodName: "CreateTransferOperation",
			Handler:    _Msg_CreateTransferOperation_Handler,
		},
		{
			MethodName: "CreateIdentityDefaultTransferOperation",
			Handler:    _Msg_CreateIdentityDefaultTransferOperation_Handler,
		},
		{
			MethodName: "CreateIdentityGISTTransferOperation",
			Handler:    _Msg_CreateIdentityGISTTransferOperation_Handler,
		},
		{
			MethodName: "CreateIdentityStateTransferOperation",
			Handler:    _Msg_CreateIdentityStateTransferOperation_Handler,
		},
		{
			MethodName: "CreateWorldCoinIdentityTransferOperation",
			Handler:    _Msg_CreateWorldCoinIdentityTransferOperation_Handler,
		},
		{
			MethodName: "Vote",
			Handler:    _Msg_Vote_Handler,
		},
		{
			MethodName: "Unjail",
			Handler:    _Msg_Unjail_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "oraclemanager/tx.proto",
}

func (m *MsgStake) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgStake) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgStake) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Amount) > 0 {
		i -= len(m.Amount)
		copy(dAtA[i:], m.Amount)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Amount)))
		i--
		dAtA[i] = 0x12
	}
	if m.Index != nil {
		{
			size, err := m.Index.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgStakeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgStakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgUnstake) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUnstake) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUnstake) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x12
	}
	if m.Index != nil {
		{
			size, err := m.Index.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgUnstakeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUnstakeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUnstakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgCreateTransferOp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateTransferOp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateTransferOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Meta != nil {
		{
			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	{
		size, err := m.To.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	{
		size, err := m.From.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	if len(m.BundleSalt) > 0 {
		i -= len(m.BundleSalt)
		copy(dAtA[i:], m.BundleSalt)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BundleSalt)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.BundleData) > 0 {
		i -= len(m.BundleData)
		copy(dAtA[i:], m.BundleData)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BundleData)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Amount) > 0 {
		i -= len(m.Amount)
		copy(dAtA[i:], m.Amount)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Amount)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.EventId) > 0 {
		i -= len(m.EventId)
		copy(dAtA[i:], m.EventId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.EventId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Tx) > 0 {
		i -= len(m.Tx)
		copy(dAtA[i:], m.Tx)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Tx)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgCreateTransferOpResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateTransferOpResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateTransferOpResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgCreateIdentityDefaultTransferOp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateIdentityDefaultTransferOp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateIdentityDefaultTransferOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ReplacedGISTtHash) > 0 {
		i -= len(m.ReplacedGISTtHash)
		copy(dAtA[i:], m.ReplacedGISTtHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ReplacedGISTtHash)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.ReplacedStateHash) > 0 {
		i -= len(m.ReplacedStateHash)
		copy(dAtA[i:], m.ReplacedStateHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ReplacedStateHash)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.GISTCreatedAtBlock) > 0 {
		i -= len(m.GISTCreatedAtBlock)
		copy(dAtA[i:], m.GISTCreatedAtBlock)
		i = encodeVarintTx(dAtA, i, uint64(len(m.GISTCreatedAtBlock)))
		i--
		dAtA[i] = 0x72
	}
	if len(m.GISTCreatedAtTimestamp) > 0 {
		i -= len(m.GISTCreatedAtTimestamp)
		copy(dAtA[i:], m.GISTCreatedAtTimestamp)
		i = encodeVarintTx(dAtA, i, uint64(len(m.GISTCreatedAtTimestamp)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.GISTReplacedBy) > 0 {
		i -= len(m.GISTReplacedBy)
		copy(dAtA[i:], m.GISTReplacedBy)
		i = encodeVarintTx(dAtA, i, uint64(len(m.GISTReplacedBy)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.StateReplacedBy) > 0 {
		i -= len(m.StateReplacedBy)
		copy(dAtA[i:], m.StateReplacedBy)
		i = encodeVarintTx(dAtA, i, uint64(len(m.StateReplacedBy)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.StateCreatedAtBlock) > 0 {
		i -= len(m.StateCreatedAtBlock)
		copy(dAtA[i:], m.StateCreatedAtBlock)
		i = encodeVarintTx(dAtA, i, uint64(len(m.StateCreatedAtBlock)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.StateCreatedAtTimestamp) > 0 {
		i -= len(m.StateCreatedAtTimestamp)
		copy(dAtA[i:], m.StateCreatedAtTimestamp)
		i = encodeVarintTx(dAtA, i, uint64(len(m.StateCreatedAtTimestamp)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.StateHash) > 0 {
		i -= len(m.StateHash)
		copy(dAtA[i:], m.StateHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.StateHash)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.GISTHash) > 0 {
		i -= len(m.GISTHash)
		copy(dAtA[i:], m.GISTHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.GISTHash)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Contract) > 0 {
		i -= len(m.Contract)
		copy(dAtA[i:], m.Contract)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Contract)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgCreateIdentityDefaultTransferOpResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateIdentityDefaultTransferOpResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateIdentityDefaultTransferOpResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgCreateIdentityGISTTransferOp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateIdentityGISTTransferOp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateIdentityGISTTransferOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ReplacedGISTtHash) > 0 {
		i -= len(m.ReplacedGISTtHash)
		copy(dAtA[i:], m.ReplacedGISTtHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ReplacedGISTtHash)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.GISTCreatedAtBlock) > 0 {
		i -= len(m.GISTCreatedAtBlock)
		copy(dAtA[i:], m.GISTCreatedAtBlock)
		i = encodeVarintTx(dAtA, i, uint64(len(m.GISTCreatedAtBlock)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.GISTCreatedAtTimestamp) > 0 {
		i -= len(m.GISTCreatedAtTimestamp)
		copy(dAtA[i:], m.GISTCreatedAtTimestamp)
		i = encodeVarintTx(dAtA, i, uint64(len(m.GISTCreatedAtTimestamp)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.GISTHash) > 0 {
		i -= len(m.GISTHash)
		copy(dAtA[i:], m.GISTHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.GISTHash)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Contract) > 0 {
		i -= len(m.Contract)
		copy(dAtA[i:], m.Contract)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Contract)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgCreateIdentityGISTTransferOpResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateIdentityGISTTransferOpResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateIdentityGISTTransferOpResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgCreateIdentityStateTransferOp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateIdentityStateTransferOp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateIdentityStateTransferOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ReplacedStateHash) > 0 {
		i -= len(m.ReplacedStateHash)
		copy(dAtA[i:], m.ReplacedStateHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ReplacedStateHash)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.StateCreatedAtBlock) > 0 {
		i -= len(m.StateCreatedAtBlock)
		copy(dAtA[i:], m.StateCreatedAtBlock)
		i = encodeVarintTx(dAtA, i, uint64(len(m.StateCreatedAtBlock)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.StateCreatedAtTimestamp) > 0 {
		i -= len(m.StateCreatedAtTimestamp)
		copy(dAtA[i:], m.StateCreatedAtTimestamp)
		i = encodeVarintTx(dAtA, i, uint64(len(m.StateCreatedAtTimestamp)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.StateHash) > 0 {
		i -= len(m.StateHash)
		copy(dAtA[i:], m.StateHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.StateHash)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Contract) > 0 {
		i -= len(m.Contract)
		copy(dAtA[i:], m.Contract)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Contract)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgCreateIdentityStateTransferOpResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateIdentityStateTransferOpResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateIdentityStateTransferOpResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgCreateWorldCoinIdentityTransferOp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateWorldCoinIdentityTransferOp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateWorldCoinIdentityTransferOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BlockNumber != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.BlockNumber))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Timestamp) > 0 {
		i -= len(m.Timestamp)
		copy(dAtA[i:], m.Timestamp)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Timestamp)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.State) > 0 {
		i -= len(m.State)
		copy(dAtA[i:], m.State)
		i = encodeVarintTx(dAtA, i, uint64(len(m.State)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.PrevState) > 0 {
		i -= len(m.PrevState)
		copy(dAtA[i:], m.PrevState)
		i = encodeVarintTx(dAtA, i, uint64(len(m.PrevState)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Contract) > 0 {
		i -= len(m.Contract)
		copy(dAtA[i:], m.Contract)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Contract)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgCreateWorldCoinIdentityTransferOpResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgCreateWorldCoinIdentityTransferOpResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgCreateWorldCoinIdentityTransferOpResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgVote) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgVote) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgVote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Vote != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Vote))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Operation) > 0 {
		i -= len(m.Operation)
		copy(dAtA[i:], m.Operation)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Operation)))
		i--
		dAtA[i] = 0x12
	}
	if m.Index != nil {
		{
			size, err := m.Index.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgVoteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgVoteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgVoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgUnjail) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUnjail) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUnjail) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != nil {
		{
			size, err := m.Index.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgUnjailResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MsgUnjailResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUnjailResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgStake) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != nil {
		l = m.Index.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Amount)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.From)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgUnstake) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != nil {
		l = m.Index.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgUnstakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgCreateTransferOp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Tx)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.EventId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Amount)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.BundleData)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.BundleSalt)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.From.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.To.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.Meta != nil {
		l = m.Meta.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgCreateTransferOpResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgCreateIdentityDefaultTransferOp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.GISTHash)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.StateHash)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.StateCreatedAtTimestamp)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.StateCreatedAtBlock)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.StateReplacedBy)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.GISTReplacedBy)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.GISTCreatedAtTimestamp)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.GISTCreatedAtBlock)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ReplacedStateHash)
	if l > 0 {
		n += 2 + l + sovTx(uint64(l))
	}
	l = len(m.ReplacedGISTtHash)
	if l > 0 {
		n += 2 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgCreateIdentityDefaultTransferOpResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgCreateIdentityGISTTransferOp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.GISTHash)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.GISTCreatedAtTimestamp)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.GISTCreatedAtBlock)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ReplacedGISTtHash)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgCreateIdentityGISTTransferOpResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgCreateIdentityStateTransferOp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.StateHash)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.StateCreatedAtTimestamp)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.StateCreatedAtBlock)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ReplacedStateHash)
	if l > 0 {
		n += 2 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgCreateIdentityStateTransferOpResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgCreateWorldCoinIdentityTransferOp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.PrevState)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.State)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Timestamp)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.BlockNumber != 0 {
		n += 1 + sovTx(uint64(m.BlockNumber))
	}
	return n
}

func (m *MsgCreateWorldCoinIdentityTransferOpResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgVote) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != nil {
		l = m.Index.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Operation)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Vote != 0 {
		n += 1 + sovTx(uint64(m.Vote))
	}
	return n
}

func (m *MsgVoteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgUnjail) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != nil {
		l = m.Index.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgUnjailResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovTx(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTx(x uint64) (n int) {
	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgStake) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgStake: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgStake: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Index == nil {
				m.Index = &OracleIndex{}
			}
			if err := m.Index.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgStakeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUnstake) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUnstake: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnstake: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Index == nil {
				m.Index = &OracleIndex{}
			}
			if err := m.Index.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUnstakeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUnstakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnstakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateTransferOp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateTransferOp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateTransferOp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tx = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BundleData", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BundleData = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BundleSalt", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BundleSalt = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.From.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Meta == nil {
				m.Meta = &types.ItemMetadata{}
			}
			if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateTransferOpResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateTransferOpResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateTransferOpResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateIdentityDefaultTransferOp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateIdentityDefaultTransferOp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateIdentityDefaultTransferOp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contract = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GISTHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GISTHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateCreatedAtTimestamp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateCreatedAtTimestamp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateCreatedAtBlock", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateCreatedAtBlock = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateReplacedBy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateReplacedBy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GISTReplacedBy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GISTReplacedBy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GISTCreatedAtTimestamp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GISTCreatedAtTimestamp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GISTCreatedAtBlock", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GISTCreatedAtBlock = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplacedStateHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplacedStateHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplacedGISTtHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplacedGISTtHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateIdentityDefaultTransferOpResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateIdentityDefaultTransferOpResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateIdentityDefaultTransferOpResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateIdentityGISTTransferOp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateIdentityGISTTransferOp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateIdentityGISTTransferOp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contract = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GISTHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GISTHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GISTCreatedAtTimestamp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GISTCreatedAtTimestamp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GISTCreatedAtBlock", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GISTCreatedAtBlock = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplacedGISTtHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplacedGISTtHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateIdentityGISTTransferOpResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateIdentityGISTTransferOpResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateIdentityGISTTransferOpResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateIdentityStateTransferOp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateIdentityStateTransferOp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateIdentityStateTransferOp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contract = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateCreatedAtTimestamp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateCreatedAtTimestamp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateCreatedAtBlock", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateCreatedAtBlock = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplacedStateHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplacedStateHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateIdentityStateTransferOpResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateIdentityStateTransferOpResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateIdentityStateTransferOpResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateWorldCoinIdentityTransferOp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateWorldCoinIdentityTransferOp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateWorldCoinIdentityTransferOp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contract = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevState", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrevState = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.State = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timestamp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType)
			}
			m.BlockNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateWorldCoinIdentityTransferOpResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateWorldCoinIdentityTransferOpResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateWorldCoinIdentityTransferOpResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgVote) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgVote: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgVote: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Index == nil {
				m.Index = &OracleIndex{}
			}
			if err := m.Index.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Operation = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType)
			}
			m.Vote = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Vote |= types1.VoteType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgVoteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgVoteResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgVoteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUnjail) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUnjail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnjail: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Index == nil {
				m.Index = &OracleIndex{}
			}
			if err := m.Index.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUnjailResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUnjailResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnjailResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTx(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTx
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTx
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTx
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTx
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)