gravity.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: gravity/v1/gravity.proto

package types

import (
	fmt "fmt"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types1 "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/regen-network/cosmos-proto"
	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

// EthereumEventVoteRecord is an event that is pending of confirmation by 2/3 of
// the signer set. The event is then attested and executed in the state machine
// once the required threshold is met.
type EthereumEventVoteRecord struct {
	Event    *types.Any `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`
	Votes    []string   `protobuf:"bytes,2,rep,name=votes,proto3" json:"votes,omitempty"`
	Accepted bool       `protobuf:"varint,3,opt,name=accepted,proto3" json:"accepted,omitempty"`
}

func (m *EthereumEventVoteRecord) Reset()         { *m = EthereumEventVoteRecord{} }
func (m *EthereumEventVoteRecord) String() string { return proto.CompactTextString(m) }
func (*EthereumEventVoteRecord) ProtoMessage()    {}
func (*EthereumEventVoteRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{0}
}
func (m *EthereumEventVoteRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EthereumEventVoteRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EthereumEventVoteRecord.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 *EthereumEventVoteRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EthereumEventVoteRecord.Merge(m, src)
}
func (m *EthereumEventVoteRecord) XXX_Size() int {
	return m.Size()
}
func (m *EthereumEventVoteRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_EthereumEventVoteRecord.DiscardUnknown(m)
}

var xxx_messageInfo_EthereumEventVoteRecord proto.InternalMessageInfo

func (m *EthereumEventVoteRecord) GetEvent() *types.Any {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *EthereumEventVoteRecord) GetVotes() []string {
	if m != nil {
		return m.Votes
	}
	return nil
}

func (m *EthereumEventVoteRecord) GetAccepted() bool {
	if m != nil {
		return m.Accepted
	}
	return false
}

// LatestEthereumBlockHeight defines the latest observed ethereum block height
// and the corresponding timestamp value in nanoseconds.
type LatestEthereumBlockHeight struct {
	EthereumHeight uint64 `protobuf:"varint,1,opt,name=ethereum_height,json=ethereumHeight,proto3" json:"ethereum_height,omitempty"`
	CosmosHeight   uint64 `protobuf:"varint,2,opt,name=cosmos_height,json=cosmosHeight,proto3" json:"cosmos_height,omitempty"`
}

func (m *LatestEthereumBlockHeight) Reset()         { *m = LatestEthereumBlockHeight{} }
func (m *LatestEthereumBlockHeight) String() string { return proto.CompactTextString(m) }
func (*LatestEthereumBlockHeight) ProtoMessage()    {}
func (*LatestEthereumBlockHeight) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{1}
}
func (m *LatestEthereumBlockHeight) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LatestEthereumBlockHeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LatestEthereumBlockHeight.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 *LatestEthereumBlockHeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LatestEthereumBlockHeight.Merge(m, src)
}
func (m *LatestEthereumBlockHeight) XXX_Size() int {
	return m.Size()
}
func (m *LatestEthereumBlockHeight) XXX_DiscardUnknown() {
	xxx_messageInfo_LatestEthereumBlockHeight.DiscardUnknown(m)
}

var xxx_messageInfo_LatestEthereumBlockHeight proto.InternalMessageInfo

func (m *LatestEthereumBlockHeight) GetEthereumHeight() uint64 {
	if m != nil {
		return m.EthereumHeight
	}
	return 0
}

func (m *LatestEthereumBlockHeight) GetCosmosHeight() uint64 {
	if m != nil {
		return m.CosmosHeight
	}
	return 0
}

// EthereumSigner represents a cosmos validator with its corresponding bridge
// operator ethereum address and its staking consensus power.
type EthereumSigner struct {
	Power           uint64 `protobuf:"varint,1,opt,name=power,proto3" json:"power,omitempty"`
	EthereumAddress string `protobuf:"bytes,2,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"`
}

func (m *EthereumSigner) Reset()         { *m = EthereumSigner{} }
func (m *EthereumSigner) String() string { return proto.CompactTextString(m) }
func (*EthereumSigner) ProtoMessage()    {}
func (*EthereumSigner) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{2}
}
func (m *EthereumSigner) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EthereumSigner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EthereumSigner.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 *EthereumSigner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EthereumSigner.Merge(m, src)
}
func (m *EthereumSigner) XXX_Size() int {
	return m.Size()
}
func (m *EthereumSigner) XXX_DiscardUnknown() {
	xxx_messageInfo_EthereumSigner.DiscardUnknown(m)
}

var xxx_messageInfo_EthereumSigner proto.InternalMessageInfo

func (m *EthereumSigner) GetPower() uint64 {
	if m != nil {
		return m.Power
	}
	return 0
}

func (m *EthereumSigner) GetEthereumAddress() string {
	if m != nil {
		return m.EthereumAddress
	}
	return ""
}

// SignerSetTx is the Ethereum Bridge multisig set that relays
// transactions the two chains. The staking validators keep ethereum keys which
// are used to check signatures on Ethereum in order to get significant gas
// savings.
type SignerSetTx struct {
	Nonce   uint64          `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Height  uint64          `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	Signers EthereumSigners `protobuf:"bytes,3,rep,name=signers,proto3,castrepeated=EthereumSigners" json:"signers,omitempty"`
}

func (m *SignerSetTx) Reset()         { *m = SignerSetTx{} }
func (m *SignerSetTx) String() string { return proto.CompactTextString(m) }
func (*SignerSetTx) ProtoMessage()    {}
func (*SignerSetTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{3}
}
func (m *SignerSetTx) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignerSetTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignerSetTx.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 *SignerSetTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignerSetTx.Merge(m, src)
}
func (m *SignerSetTx) XXX_Size() int {
	return m.Size()
}
func (m *SignerSetTx) XXX_DiscardUnknown() {
	xxx_messageInfo_SignerSetTx.DiscardUnknown(m)
}

var xxx_messageInfo_SignerSetTx proto.InternalMessageInfo

func (m *SignerSetTx) GetNonce() uint64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *SignerSetTx) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *SignerSetTx) GetSigners() EthereumSigners {
	if m != nil {
		return m.Signers
	}
	return nil
}

// BatchTx represents a batch of transactions going from Cosmos to Ethereum.
// Batch txs are are identified by a unique hash and the token contract that is
// shared by all the SendToEthereum
type BatchTx struct {
	BatchNonce    uint64            `protobuf:"varint,1,opt,name=batch_nonce,json=batchNonce,proto3" json:"batch_nonce,omitempty"`
	Timeout       uint64            `protobuf:"varint,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
	Transactions  []*SendToEthereum `protobuf:"bytes,3,rep,name=transactions,proto3" json:"transactions,omitempty"`
	TokenContract string            `protobuf:"bytes,4,opt,name=token_contract,json=tokenContract,proto3" json:"token_contract,omitempty"`
	Height        uint64            `protobuf:"varint,5,opt,name=height,proto3" json:"height,omitempty"`
}

func (m *BatchTx) Reset()         { *m = BatchTx{} }
func (m *BatchTx) String() string { return proto.CompactTextString(m) }
func (*BatchTx) ProtoMessage()    {}
func (*BatchTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{4}
}
func (m *BatchTx) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BatchTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BatchTx.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 *BatchTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BatchTx.Merge(m, src)
}
func (m *BatchTx) XXX_Size() int {
	return m.Size()
}
func (m *BatchTx) XXX_DiscardUnknown() {
	xxx_messageInfo_BatchTx.DiscardUnknown(m)
}

var xxx_messageInfo_BatchTx proto.InternalMessageInfo

func (m *BatchTx) GetBatchNonce() uint64 {
	if m != nil {
		return m.BatchNonce
	}
	return 0
}

func (m *BatchTx) GetTimeout() uint64 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *BatchTx) GetTransactions() []*SendToEthereum {
	if m != nil {
		return m.Transactions
	}
	return nil
}

func (m *BatchTx) GetTokenContract() string {
	if m != nil {
		return m.TokenContract
	}
	return ""
}

func (m *BatchTx) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

// SendToEthereum represents an individual SendToEthereum from Cosmos to
// Ethereum
type SendToEthereum struct {
	Id                uint64     `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Sender            string     `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
	EthereumRecipient string     `protobuf:"bytes,3,opt,name=ethereum_recipient,json=ethereumRecipient,proto3" json:"ethereum_recipient,omitempty"`
	Erc20Token        ERC20Token `protobuf:"bytes,4,opt,name=erc20_token,json=erc20Token,proto3" json:"erc20_token"`
	Erc20Fee          ERC20Token `protobuf:"bytes,5,opt,name=erc20_fee,json=erc20Fee,proto3" json:"erc20_fee"`
}

func (m *SendToEthereum) Reset()         { *m = SendToEthereum{} }
func (m *SendToEthereum) String() string { return proto.CompactTextString(m) }
func (*SendToEthereum) ProtoMessage()    {}
func (*SendToEthereum) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{5}
}
func (m *SendToEthereum) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SendToEthereum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SendToEthereum.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 *SendToEthereum) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendToEthereum.Merge(m, src)
}
func (m *SendToEthereum) XXX_Size() int {
	return m.Size()
}
func (m *SendToEthereum) XXX_DiscardUnknown() {
	xxx_messageInfo_SendToEthereum.DiscardUnknown(m)
}

var xxx_messageInfo_SendToEthereum proto.InternalMessageInfo

func (m *SendToEthereum) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

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

func (m *SendToEthereum) GetEthereumRecipient() string {
	if m != nil {
		return m.EthereumRecipient
	}
	return ""
}

func (m *SendToEthereum) GetErc20Token() ERC20Token {
	if m != nil {
		return m.Erc20Token
	}
	return ERC20Token{}
}

func (m *SendToEthereum) GetErc20Fee() ERC20Token {
	if m != nil {
		return m.Erc20Fee
	}
	return ERC20Token{}
}

// ContractCallTx represents an individual arbitrary logic call transaction
// from Cosmos to Ethereum.
type ContractCallTx struct {
	InvalidationNonce uint64       `protobuf:"varint,1,opt,name=invalidation_nonce,json=invalidationNonce,proto3" json:"invalidation_nonce,omitempty"`
	InvalidationScope []byte       `protobuf:"bytes,2,opt,name=invalidation_scope,json=invalidationScope,proto3" json:"invalidation_scope,omitempty"`
	Address           string       `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
	Payload           []byte       `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"`
	Timeout           uint64       `protobuf:"varint,5,opt,name=timeout,proto3" json:"timeout,omitempty"`
	Tokens            []ERC20Token `protobuf:"bytes,6,rep,name=tokens,proto3" json:"tokens"`
	Fees              []ERC20Token `protobuf:"bytes,7,rep,name=fees,proto3" json:"fees"`
	Height            uint64       `protobuf:"varint,8,opt,name=height,proto3" json:"height,omitempty"`
}

func (m *ContractCallTx) Reset()         { *m = ContractCallTx{} }
func (m *ContractCallTx) String() string { return proto.CompactTextString(m) }
func (*ContractCallTx) ProtoMessage()    {}
func (*ContractCallTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{6}
}
func (m *ContractCallTx) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContractCallTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ContractCallTx.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 *ContractCallTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContractCallTx.Merge(m, src)
}
func (m *ContractCallTx) XXX_Size() int {
	return m.Size()
}
func (m *ContractCallTx) XXX_DiscardUnknown() {
	xxx_messageInfo_ContractCallTx.DiscardUnknown(m)
}

var xxx_messageInfo_ContractCallTx proto.InternalMessageInfo

func (m *ContractCallTx) GetInvalidationNonce() uint64 {
	if m != nil {
		return m.InvalidationNonce
	}
	return 0
}

func (m *ContractCallTx) GetInvalidationScope() []byte {
	if m != nil {
		return m.InvalidationScope
	}
	return nil
}

func (m *ContractCallTx) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *ContractCallTx) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *ContractCallTx) GetTimeout() uint64 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *ContractCallTx) GetTokens() []ERC20Token {
	if m != nil {
		return m.Tokens
	}
	return nil
}

func (m *ContractCallTx) GetFees() []ERC20Token {
	if m != nil {
		return m.Fees
	}
	return nil
}

func (m *ContractCallTx) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

type ERC20Token struct {
	Contract string                                 `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty"`
	Amount   github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
}

func (m *ERC20Token) Reset()         { *m = ERC20Token{} }
func (m *ERC20Token) String() string { return proto.CompactTextString(m) }
func (*ERC20Token) ProtoMessage()    {}
func (*ERC20Token) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{7}
}
func (m *ERC20Token) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ERC20Token) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ERC20Token.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 *ERC20Token) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ERC20Token.Merge(m, src)
}
func (m *ERC20Token) XXX_Size() int {
	return m.Size()
}
func (m *ERC20Token) XXX_DiscardUnknown() {
	xxx_messageInfo_ERC20Token.DiscardUnknown(m)
}

var xxx_messageInfo_ERC20Token proto.InternalMessageInfo

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

type IDSet struct {
	Ids []uint64 `protobuf:"varint,1,rep,packed,name=ids,proto3" json:"ids,omitempty"`
}

func (m *IDSet) Reset()         { *m = IDSet{} }
func (m *IDSet) String() string { return proto.CompactTextString(m) }
func (*IDSet) ProtoMessage()    {}
func (*IDSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{8}
}
func (m *IDSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IDSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IDSet.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 *IDSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IDSet.Merge(m, src)
}
func (m *IDSet) XXX_Size() int {
	return m.Size()
}
func (m *IDSet) XXX_DiscardUnknown() {
	xxx_messageInfo_IDSet.DiscardUnknown(m)
}

var xxx_messageInfo_IDSet proto.InternalMessageInfo

func (m *IDSet) GetIds() []uint64 {
	if m != nil {
		return m.Ids
	}
	return nil
}

type CommunityPoolEthereumSpendProposal struct {
	Title       string      `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Description string      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	Recipient   string      `protobuf:"bytes,3,opt,name=recipient,proto3" json:"recipient,omitempty"`
	Amount      types1.Coin `protobuf:"bytes,4,opt,name=amount,proto3" json:"amount"`
	BridgeFee   types1.Coin `protobuf:"bytes,5,opt,name=bridge_fee,json=bridgeFee,proto3" json:"bridge_fee"`
}

func (m *CommunityPoolEthereumSpendProposal) Reset()      { *m = CommunityPoolEthereumSpendProposal{} }
func (*CommunityPoolEthereumSpendProposal) ProtoMessage() {}
func (*CommunityPoolEthereumSpendProposal) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{9}
}
func (m *CommunityPoolEthereumSpendProposal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CommunityPoolEthereumSpendProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CommunityPoolEthereumSpendProposal.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 *CommunityPoolEthereumSpendProposal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommunityPoolEthereumSpendProposal.Merge(m, src)
}
func (m *CommunityPoolEthereumSpendProposal) XXX_Size() int {
	return m.Size()
}
func (m *CommunityPoolEthereumSpendProposal) XXX_DiscardUnknown() {
	xxx_messageInfo_CommunityPoolEthereumSpendProposal.DiscardUnknown(m)
}

var xxx_messageInfo_CommunityPoolEthereumSpendProposal proto.InternalMessageInfo

// This format of the community spend Ethereum proposal is specifically for
// the CLI to allow simple text serialization.
type CommunityPoolEthereumSpendProposalForCLI struct {
	Title       string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty" yaml:"title"`
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	Recipient   string `protobuf:"bytes,3,opt,name=recipient,proto3" json:"recipient,omitempty" yaml:"recipient"`
	Amount      string `protobuf:"bytes,4,opt,name=amount,proto3" json:"amount,omitempty" yaml:"amount"`
	BridgeFee   string `protobuf:"bytes,5,opt,name=bridge_fee,json=bridgeFee,proto3" json:"bridge_fee,omitempty" yaml:"bridge_fee"`
	Deposit     string `protobuf:"bytes,6,opt,name=deposit,proto3" json:"deposit,omitempty" yaml:"deposit"`
}

func (m *CommunityPoolEthereumSpendProposalForCLI) Reset() {
	*m = CommunityPoolEthereumSpendProposalForCLI{}
}
func (m *CommunityPoolEthereumSpendProposalForCLI) String() string { return proto.CompactTextString(m) }
func (*CommunityPoolEthereumSpendProposalForCLI) ProtoMessage()    {}
func (*CommunityPoolEthereumSpendProposalForCLI) Descriptor() ([]byte, []int) {
	return fileDescriptor_1715a041eadeb531, []int{10}
}
func (m *CommunityPoolEthereumSpendProposalForCLI) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CommunityPoolEthereumSpendProposalForCLI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CommunityPoolEthereumSpendProposalForCLI.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 *CommunityPoolEthereumSpendProposalForCLI) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommunityPoolEthereumSpendProposalForCLI.Merge(m, src)
}
func (m *CommunityPoolEthereumSpendProposalForCLI) XXX_Size() int {
	return m.Size()
}
func (m *CommunityPoolEthereumSpendProposalForCLI) XXX_DiscardUnknown() {
	xxx_messageInfo_CommunityPoolEthereumSpendProposalForCLI.DiscardUnknown(m)
}

var xxx_messageInfo_CommunityPoolEthereumSpendProposalForCLI proto.InternalMessageInfo

func init() {
	proto.RegisterType((*EthereumEventVoteRecord)(nil), "gravity.v1.EthereumEventVoteRecord")
	proto.RegisterType((*LatestEthereumBlockHeight)(nil), "gravity.v1.LatestEthereumBlockHeight")
	proto.RegisterType((*EthereumSigner)(nil), "gravity.v1.EthereumSigner")
	proto.RegisterType((*SignerSetTx)(nil), "gravity.v1.SignerSetTx")
	proto.RegisterType((*BatchTx)(nil), "gravity.v1.BatchTx")
	proto.RegisterType((*SendToEthereum)(nil), "gravity.v1.SendToEthereum")
	proto.RegisterType((*ContractCallTx)(nil), "gravity.v1.ContractCallTx")
	proto.RegisterType((*ERC20Token)(nil), "gravity.v1.ERC20Token")
	proto.RegisterType((*IDSet)(nil), "gravity.v1.IDSet")
	proto.RegisterType((*CommunityPoolEthereumSpendProposal)(nil), "gravity.v1.CommunityPoolEthereumSpendProposal")
	proto.RegisterType((*CommunityPoolEthereumSpendProposalForCLI)(nil), "gravity.v1.CommunityPoolEthereumSpendProposalForCLI")
}

func init() { proto.RegisterFile("gravity/v1/gravity.proto", fileDescriptor_1715a041eadeb531) }

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

func (m *EthereumEventVoteRecord) 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 *EthereumEventVoteRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EthereumEventVoteRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Accepted {
		i--
		if m.Accepted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Votes) > 0 {
		for iNdEx := len(m.Votes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Votes[iNdEx])
			copy(dAtA[i:], m.Votes[iNdEx])
			i = encodeVarintGravity(dAtA, i, uint64(len(m.Votes[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGravity(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LatestEthereumBlockHeight) 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 *LatestEthereumBlockHeight) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LatestEthereumBlockHeight) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CosmosHeight != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.CosmosHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.EthereumHeight != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.EthereumHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EthereumSigner) 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 *EthereumSigner) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EthereumSigner) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EthereumAddress) > 0 {
		i -= len(m.EthereumAddress)
		copy(dAtA[i:], m.EthereumAddress)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.EthereumAddress)))
		i--
		dAtA[i] = 0x12
	}
	if m.Power != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.Power))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SignerSetTx) 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 *SignerSetTx) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SignerSetTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signers) > 0 {
		for iNdEx := len(m.Signers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Signers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGravity(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Height != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x10
	}
	if m.Nonce != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BatchTx) 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 *BatchTx) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x28
	}
	if len(m.TokenContract) > 0 {
		i -= len(m.TokenContract)
		copy(dAtA[i:], m.TokenContract)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.TokenContract)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Transactions) > 0 {
		for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Transactions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGravity(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Timeout != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x10
	}
	if m.BatchNonce != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.BatchNonce))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SendToEthereum) 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 *SendToEthereum) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SendToEthereum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Erc20Fee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGravity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.Erc20Token.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGravity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.EthereumRecipient) > 0 {
		i -= len(m.EthereumRecipient)
		copy(dAtA[i:], m.EthereumRecipient)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.EthereumRecipient)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ContractCallTx) 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 *ContractCallTx) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ContractCallTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x40
	}
	if len(m.Fees) > 0 {
		for iNdEx := len(m.Fees) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Fees[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGravity(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Tokens) > 0 {
		for iNdEx := len(m.Tokens) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tokens[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGravity(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.Timeout != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.InvalidationScope) > 0 {
		i -= len(m.InvalidationScope)
		copy(dAtA[i:], m.InvalidationScope)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.InvalidationScope)))
		i--
		dAtA[i] = 0x12
	}
	if m.InvalidationNonce != 0 {
		i = encodeVarintGravity(dAtA, i, uint64(m.InvalidationNonce))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ERC20Token) 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 *ERC20Token) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ERC20Token) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGravity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Contract) > 0 {
		i -= len(m.Contract)
		copy(dAtA[i:], m.Contract)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Contract)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IDSet) 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 *IDSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IDSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		dAtA5 := make([]byte, len(m.Ids)*10)
		var j4 int
		for _, num := range m.Ids {
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		i -= j4
		copy(dAtA[i:], dAtA5[:j4])
		i = encodeVarintGravity(dAtA, i, uint64(j4))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CommunityPoolEthereumSpendProposal) 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 *CommunityPoolEthereumSpendProposal) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommunityPoolEthereumSpendProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.BridgeFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGravity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGravity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Recipient) > 0 {
		i -= len(m.Recipient)
		copy(dAtA[i:], m.Recipient)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Recipient)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CommunityPoolEthereumSpendProposalForCLI) 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 *CommunityPoolEthereumSpendProposalForCLI) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommunityPoolEthereumSpendProposalForCLI) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Deposit) > 0 {
		i -= len(m.Deposit)
		copy(dAtA[i:], m.Deposit)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Deposit)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.BridgeFee) > 0 {
		i -= len(m.BridgeFee)
		copy(dAtA[i:], m.BridgeFee)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.BridgeFee)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Amount) > 0 {
		i -= len(m.Amount)
		copy(dAtA[i:], m.Amount)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Amount)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Recipient) > 0 {
		i -= len(m.Recipient)
		copy(dAtA[i:], m.Recipient)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Recipient)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintGravity(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintGravity(dAtA []byte, offset int, v uint64) int {
	offset -= sovGravity(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *EthereumEventVoteRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovGravity(uint64(l))
	}
	if len(m.Votes) > 0 {
		for _, s := range m.Votes {
			l = len(s)
			n += 1 + l + sovGravity(uint64(l))
		}
	}
	if m.Accepted {
		n += 2
	}
	return n
}

func (m *LatestEthereumBlockHeight) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EthereumHeight != 0 {
		n += 1 + sovGravity(uint64(m.EthereumHeight))
	}
	if m.CosmosHeight != 0 {
		n += 1 + sovGravity(uint64(m.CosmosHeight))
	}
	return n
}

func (m *EthereumSigner) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Power != 0 {
		n += 1 + sovGravity(uint64(m.Power))
	}
	l = len(m.EthereumAddress)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	return n
}

func (m *SignerSetTx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Nonce != 0 {
		n += 1 + sovGravity(uint64(m.Nonce))
	}
	if m.Height != 0 {
		n += 1 + sovGravity(uint64(m.Height))
	}
	if len(m.Signers) > 0 {
		for _, e := range m.Signers {
			l = e.Size()
			n += 1 + l + sovGravity(uint64(l))
		}
	}
	return n
}

func (m *BatchTx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BatchNonce != 0 {
		n += 1 + sovGravity(uint64(m.BatchNonce))
	}
	if m.Timeout != 0 {
		n += 1 + sovGravity(uint64(m.Timeout))
	}
	if len(m.Transactions) > 0 {
		for _, e := range m.Transactions {
			l = e.Size()
			n += 1 + l + sovGravity(uint64(l))
		}
	}
	l = len(m.TokenContract)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	if m.Height != 0 {
		n += 1 + sovGravity(uint64(m.Height))
	}
	return n
}

func (m *SendToEthereum) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovGravity(uint64(m.Id))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.EthereumRecipient)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = m.Erc20Token.Size()
	n += 1 + l + sovGravity(uint64(l))
	l = m.Erc20Fee.Size()
	n += 1 + l + sovGravity(uint64(l))
	return n
}

func (m *ContractCallTx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InvalidationNonce != 0 {
		n += 1 + sovGravity(uint64(m.InvalidationNonce))
	}
	l = len(m.InvalidationScope)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	if m.Timeout != 0 {
		n += 1 + sovGravity(uint64(m.Timeout))
	}
	if len(m.Tokens) > 0 {
		for _, e := range m.Tokens {
			l = e.Size()
			n += 1 + l + sovGravity(uint64(l))
		}
	}
	if len(m.Fees) > 0 {
		for _, e := range m.Fees {
			l = e.Size()
			n += 1 + l + sovGravity(uint64(l))
		}
	}
	if m.Height != 0 {
		n += 1 + sovGravity(uint64(m.Height))
	}
	return n
}

func (m *ERC20Token) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovGravity(uint64(l))
	return n
}

func (m *IDSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		l = 0
		for _, e := range m.Ids {
			l += sovGravity(uint64(e))
		}
		n += 1 + sovGravity(uint64(l)) + l
	}
	return n
}

func (m *CommunityPoolEthereumSpendProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.Recipient)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovGravity(uint64(l))
	l = m.BridgeFee.Size()
	n += 1 + l + sovGravity(uint64(l))
	return n
}

func (m *CommunityPoolEthereumSpendProposalForCLI) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.Recipient)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.Amount)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.BridgeFee)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	l = len(m.Deposit)
	if l > 0 {
		n += 1 + l + sovGravity(uint64(l))
	}
	return n
}

func sovGravity(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGravity(x uint64) (n int) {
	return sovGravity(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *EthereumEventVoteRecord) 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 ErrIntOverflowGravity
			}
			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: EthereumEventVoteRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EthereumEventVoteRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Event == nil {
				m.Event = &types.Any{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Votes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Votes = append(m.Votes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accepted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Accepted = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LatestEthereumBlockHeight) 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 ErrIntOverflowGravity
			}
			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: LatestEthereumBlockHeight: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LatestEthereumBlockHeight: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumHeight", wireType)
			}
			m.EthereumHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EthereumHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CosmosHeight", wireType)
			}
			m.CosmosHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CosmosHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EthereumSigner) 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 ErrIntOverflowGravity
			}
			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: EthereumSigner: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EthereumSigner: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
			}
			m.Power = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Power |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EthereumAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SignerSetTx) 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 ErrIntOverflowGravity
			}
			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: SignerSetTx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signers = append(m.Signers, &EthereumSigner{})
			if err := m.Signers[len(m.Signers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BatchTx) 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 ErrIntOverflowGravity
			}
			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: BatchTx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchNonce", wireType)
			}
			m.BatchNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BatchNonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Transactions = append(m.Transactions, &SendToEthereum{})
			if err := m.Transactions[len(m.Transactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenContract", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenContract = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SendToEthereum) 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 ErrIntOverflowGravity
			}
			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: SendToEthereum: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SendToEthereum: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumRecipient", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EthereumRecipient = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20Token", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Erc20Token.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20Fee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Erc20Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContractCallTx) 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 ErrIntOverflowGravity
			}
			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: ContractCallTx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationNonce", wireType)
			}
			m.InvalidationNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InvalidationNonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationScope", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InvalidationScope = append(m.InvalidationScope[:0], dAtA[iNdEx:postIndex]...)
			if m.InvalidationScope == nil {
				m.InvalidationScope = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tokens", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tokens = append(m.Tokens, ERC20Token{})
			if err := m.Tokens[len(m.Tokens)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fees", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fees = append(m.Fees, ERC20Token{})
			if err := m.Fees[len(m.Fees)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ERC20Token) 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 ErrIntOverflowGravity
			}
			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: ERC20Token: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ERC20Token: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contract = string(dAtA[iNdEx:postIndex])
			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 ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IDSet) 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 ErrIntOverflowGravity
			}
			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: IDSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IDSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGravity
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Ids = append(m.Ids, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGravity
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthGravity
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthGravity
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Ids) == 0 {
					m.Ids = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGravity
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Ids = append(m.Ids, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CommunityPoolEthereumSpendProposal) 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 ErrIntOverflowGravity
			}
			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: CommunityPoolEthereumSpendProposal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommunityPoolEthereumSpendProposal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Recipient = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BridgeFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGravity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BridgeFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CommunityPoolEthereumSpendProposalForCLI) 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 ErrIntOverflowGravity
			}
			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: CommunityPoolEthereumSpendProposalForCLI: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommunityPoolEthereumSpendProposalForCLI: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Recipient = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BridgeFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BridgeFee = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deposit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGravity
				}
				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 ErrInvalidLengthGravity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGravity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Deposit = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGravity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGravity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGravity(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, ErrIntOverflowGravity
			}
			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, ErrIntOverflowGravity
				}
				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, ErrIntOverflowGravity
				}
				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, ErrInvalidLengthGravity
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGravity
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGravity
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGravity        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGravity          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGravity = fmt.Errorf("proto: unexpected end of group")
)