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

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	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

// MsgUpdateParams is the Msg/UpdateParams request type.
type MsgUpdateParams struct {
	// authority is the address that controls the module (defaults to x/gov unless overwritten).
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// NOTE: All parameters must be supplied.
	Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo

func (m *MsgUpdateParams) GetAuthority() string {
	if m != nil {
		return m.Authority
	}
	return ""
}

func (m *MsgUpdateParams) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

// MsgUpdateParamsResponse defines the response structure for executing a
// MsgUpdateParams message.
type MsgUpdateParamsResponse struct {
}

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

var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo

type MsgInitRollup struct {
	Creator   string   `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	Moniker   string   `protobuf:"bytes,2,opt,name=moniker,proto3" json:"moniker,omitempty"`
	ChainId   string   `protobuf:"bytes,3,opt,name=chainId,proto3" json:"chainId,omitempty"`
	DenomName string   `protobuf:"bytes,4,opt,name=denomName,proto3" json:"denomName,omitempty"`
	DaType    string   `protobuf:"bytes,5,opt,name=daType,proto3" json:"daType,omitempty"`
	Keys      []string `protobuf:"bytes,6,rep,name=keys,proto3" json:"keys,omitempty"`
	Supply    []uint64 `protobuf:"varint,7,rep,packed,name=supply,proto3" json:"supply,omitempty"`
	// cosmos.base.v1beta1.Coin genesisSupply  = 8 [(gogoproto.nullable) = false];
	AclContractAddress     string `protobuf:"bytes,8,opt,name=aclContractAddress,proto3" json:"aclContractAddress,omitempty"`
	KmsVerifierAddress     string `protobuf:"bytes,9,opt,name=kmsVerifierAddress,proto3" json:"kmsVerifierAddress,omitempty"`
	TfheExecutorAddress    string `protobuf:"bytes,10,opt,name=tfheExecutorAddress,proto3" json:"tfheExecutorAddress,omitempty"`
	GatewayContractAddress string `protobuf:"bytes,11,opt,name=gatewayContractAddress,proto3" json:"gatewayContractAddress,omitempty"`
	AscContractAddress     string `protobuf:"bytes,12,opt,name=ascContractAddress,proto3" json:"ascContractAddress,omitempty"`
	RelayerGAddress        string `protobuf:"bytes,13,opt,name=relayerGAddress,proto3" json:"relayerGAddress,omitempty"`
	RelayerASCAddress      string `protobuf:"bytes,14,opt,name=relayerASCAddress,proto3" json:"relayerASCAddress,omitempty"`
}

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

var xxx_messageInfo_MsgInitRollup proto.InternalMessageInfo

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

func (m *MsgInitRollup) GetMoniker() string {
	if m != nil {
		return m.Moniker
	}
	return ""
}

func (m *MsgInitRollup) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *MsgInitRollup) GetDenomName() string {
	if m != nil {
		return m.DenomName
	}
	return ""
}

func (m *MsgInitRollup) GetDaType() string {
	if m != nil {
		return m.DaType
	}
	return ""
}

func (m *MsgInitRollup) GetKeys() []string {
	if m != nil {
		return m.Keys
	}
	return nil
}

func (m *MsgInitRollup) GetSupply() []uint64 {
	if m != nil {
		return m.Supply
	}
	return nil
}

func (m *MsgInitRollup) GetAclContractAddress() string {
	if m != nil {
		return m.AclContractAddress
	}
	return ""
}

func (m *MsgInitRollup) GetKmsVerifierAddress() string {
	if m != nil {
		return m.KmsVerifierAddress
	}
	return ""
}

func (m *MsgInitRollup) GetTfheExecutorAddress() string {
	if m != nil {
		return m.TfheExecutorAddress
	}
	return ""
}

func (m *MsgInitRollup) GetGatewayContractAddress() string {
	if m != nil {
		return m.GatewayContractAddress
	}
	return ""
}

func (m *MsgInitRollup) GetAscContractAddress() string {
	if m != nil {
		return m.AscContractAddress
	}
	return ""
}

func (m *MsgInitRollup) GetRelayerGAddress() string {
	if m != nil {
		return m.RelayerGAddress
	}
	return ""
}

func (m *MsgInitRollup) GetRelayerASCAddress() string {
	if m != nil {
		return m.RelayerASCAddress
	}
	return ""
}

type MsgInitRollupResponse struct {
	RollupId string `protobuf:"bytes,1,opt,name=rollupId,proto3" json:"rollupId,omitempty"`
	Status   bool   `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"`
}

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

var xxx_messageInfo_MsgInitRollupResponse proto.InternalMessageInfo

func (m *MsgInitRollupResponse) GetRollupId() string {
	if m != nil {
		return m.RollupId
	}
	return ""
}

func (m *MsgInitRollupResponse) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

type MsgInitProver struct {
	Creator               string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	RollupId              string `protobuf:"bytes,2,opt,name=rollupId,proto3" json:"rollupId,omitempty"`
	ProverVerificationKey []byte `protobuf:"bytes,3,opt,name=proverVerificationKey,proto3" json:"proverVerificationKey,omitempty"`
	ProverType            string `protobuf:"bytes,4,opt,name=proverType,proto3" json:"proverType,omitempty"`
	ProverEndpoint        string `protobuf:"bytes,5,opt,name=proverEndpoint,proto3" json:"proverEndpoint,omitempty"`
}

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

var xxx_messageInfo_MsgInitProver proto.InternalMessageInfo

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

func (m *MsgInitProver) GetRollupId() string {
	if m != nil {
		return m.RollupId
	}
	return ""
}

func (m *MsgInitProver) GetProverVerificationKey() []byte {
	if m != nil {
		return m.ProverVerificationKey
	}
	return nil
}

func (m *MsgInitProver) GetProverType() string {
	if m != nil {
		return m.ProverType
	}
	return ""
}

func (m *MsgInitProver) GetProverEndpoint() string {
	if m != nil {
		return m.ProverEndpoint
	}
	return ""
}

type MsgInitProverResponse struct {
	Status bool `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
}

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

var xxx_messageInfo_MsgInitProverResponse proto.InternalMessageInfo

func (m *MsgInitProverResponse) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

type MsgSubmitBatchMetadata struct {
	Creator      string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	BatchNo      uint64 `protobuf:"varint,2,opt,name=batchNo,proto3" json:"batchNo,omitempty"`
	RollupId     string `protobuf:"bytes,3,opt,name=rollupId,proto3" json:"rollupId,omitempty"`
	DaName       string `protobuf:"bytes,4,opt,name=daName,proto3" json:"daName,omitempty"`
	DaCommitment string `protobuf:"bytes,5,opt,name=daCommitment,proto3" json:"daCommitment,omitempty"`
	DaHash       string `protobuf:"bytes,6,opt,name=daHash,proto3" json:"daHash,omitempty"`
	DaPointer    string `protobuf:"bytes,7,opt,name=daPointer,proto3" json:"daPointer,omitempty"`
	DaNamespace  string `protobuf:"bytes,8,opt,name=daNamespace,proto3" json:"daNamespace,omitempty"`
}

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

var xxx_messageInfo_MsgSubmitBatchMetadata proto.InternalMessageInfo

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

func (m *MsgSubmitBatchMetadata) GetBatchNo() uint64 {
	if m != nil {
		return m.BatchNo
	}
	return 0
}

func (m *MsgSubmitBatchMetadata) GetRollupId() string {
	if m != nil {
		return m.RollupId
	}
	return ""
}

func (m *MsgSubmitBatchMetadata) GetDaName() string {
	if m != nil {
		return m.DaName
	}
	return ""
}

func (m *MsgSubmitBatchMetadata) GetDaCommitment() string {
	if m != nil {
		return m.DaCommitment
	}
	return ""
}

func (m *MsgSubmitBatchMetadata) GetDaHash() string {
	if m != nil {
		return m.DaHash
	}
	return ""
}

func (m *MsgSubmitBatchMetadata) GetDaPointer() string {
	if m != nil {
		return m.DaPointer
	}
	return ""
}

func (m *MsgSubmitBatchMetadata) GetDaNamespace() string {
	if m != nil {
		return m.DaNamespace
	}
	return ""
}

type MsgSubmitBatchMetadataResponse struct {
	Status bool `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
}

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

var xxx_messageInfo_MsgSubmitBatchMetadataResponse proto.InternalMessageInfo

func (m *MsgSubmitBatchMetadataResponse) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

type MsgSubmitBatch struct {
	Creator                string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	RollupId               string `protobuf:"bytes,2,opt,name=rollupId,proto3" json:"rollupId,omitempty"`
	BatchNo                uint64 `protobuf:"varint,3,opt,name=batchNo,proto3" json:"batchNo,omitempty"`
	MerkleRootHash         string `protobuf:"bytes,4,opt,name=merkleRootHash,proto3" json:"merkleRootHash,omitempty"`
	PreviousMerkleRootHash string `protobuf:"bytes,5,opt,name=previousMerkleRootHash,proto3" json:"previousMerkleRootHash,omitempty"`
	ZkProof                []byte `protobuf:"bytes,6,opt,name=zkProof,proto3" json:"zkProof,omitempty"`
	PublicWitness          []byte `protobuf:"bytes,7,opt,name=publicWitness,proto3" json:"publicWitness,omitempty"`
}

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

var xxx_messageInfo_MsgSubmitBatch proto.InternalMessageInfo

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

func (m *MsgSubmitBatch) GetRollupId() string {
	if m != nil {
		return m.RollupId
	}
	return ""
}

func (m *MsgSubmitBatch) GetBatchNo() uint64 {
	if m != nil {
		return m.BatchNo
	}
	return 0
}

func (m *MsgSubmitBatch) GetMerkleRootHash() string {
	if m != nil {
		return m.MerkleRootHash
	}
	return ""
}

func (m *MsgSubmitBatch) GetPreviousMerkleRootHash() string {
	if m != nil {
		return m.PreviousMerkleRootHash
	}
	return ""
}

func (m *MsgSubmitBatch) GetZkProof() []byte {
	if m != nil {
		return m.ZkProof
	}
	return nil
}

func (m *MsgSubmitBatch) GetPublicWitness() []byte {
	if m != nil {
		return m.PublicWitness
	}
	return nil
}

type MsgSubmitBatchResponse struct {
	Status bool `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
}

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

var xxx_messageInfo_MsgSubmitBatchResponse proto.InternalMessageInfo

func (m *MsgSubmitBatchResponse) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

func init() {
	proto.RegisterType((*MsgUpdateParams)(nil), "junction.rollup.MsgUpdateParams")
	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "junction.rollup.MsgUpdateParamsResponse")
	proto.RegisterType((*MsgInitRollup)(nil), "junction.rollup.MsgInitRollup")
	proto.RegisterType((*MsgInitRollupResponse)(nil), "junction.rollup.MsgInitRollupResponse")
	proto.RegisterType((*MsgInitProver)(nil), "junction.rollup.MsgInitProver")
	proto.RegisterType((*MsgInitProverResponse)(nil), "junction.rollup.MsgInitProverResponse")
	proto.RegisterType((*MsgSubmitBatchMetadata)(nil), "junction.rollup.MsgSubmitBatchMetadata")
	proto.RegisterType((*MsgSubmitBatchMetadataResponse)(nil), "junction.rollup.MsgSubmitBatchMetadataResponse")
	proto.RegisterType((*MsgSubmitBatch)(nil), "junction.rollup.MsgSubmitBatch")
	proto.RegisterType((*MsgSubmitBatchResponse)(nil), "junction.rollup.MsgSubmitBatchResponse")
}

func init() { proto.RegisterFile("junction/rollup/tx.proto", fileDescriptor_5eb3f045172f2068) }

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

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
	out := new(MsgUpdateParamsResponse)
	err := c.cc.Invoke(ctx, "/junction.rollup.Msg/UpdateParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) InitRollup(ctx context.Context, in *MsgInitRollup, opts ...grpc.CallOption) (*MsgInitRollupResponse, error) {
	out := new(MsgInitRollupResponse)
	err := c.cc.Invoke(ctx, "/junction.rollup.Msg/InitRollup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) InitProver(ctx context.Context, in *MsgInitProver, opts ...grpc.CallOption) (*MsgInitProverResponse, error) {
	out := new(MsgInitProverResponse)
	err := c.cc.Invoke(ctx, "/junction.rollup.Msg/InitProver", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SubmitBatchMetadata(ctx context.Context, in *MsgSubmitBatchMetadata, opts ...grpc.CallOption) (*MsgSubmitBatchMetadataResponse, error) {
	out := new(MsgSubmitBatchMetadataResponse)
	err := c.cc.Invoke(ctx, "/junction.rollup.Msg/SubmitBatchMetadata", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SubmitBatch(ctx context.Context, in *MsgSubmitBatch, opts ...grpc.CallOption) (*MsgSubmitBatchResponse, error) {
	out := new(MsgSubmitBatchResponse)
	err := c.cc.Invoke(ctx, "/junction.rollup.Msg/SubmitBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// UpdateParams defines a (governance) operation for updating the module
	// parameters. The authority defaults to the x/gov module account.
	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
	InitRollup(context.Context, *MsgInitRollup) (*MsgInitRollupResponse, error)
	InitProver(context.Context, *MsgInitProver) (*MsgInitProverResponse, error)
	SubmitBatchMetadata(context.Context, *MsgSubmitBatchMetadata) (*MsgSubmitBatchMetadataResponse, error)
	SubmitBatch(context.Context, *MsgSubmitBatch) (*MsgSubmitBatchResponse, error)
}

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

func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
}
func (*UnimplementedMsgServer) InitRollup(ctx context.Context, req *MsgInitRollup) (*MsgInitRollupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitRollup not implemented")
}
func (*UnimplementedMsgServer) InitProver(ctx context.Context, req *MsgInitProver) (*MsgInitProverResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitProver not implemented")
}
func (*UnimplementedMsgServer) SubmitBatchMetadata(ctx context.Context, req *MsgSubmitBatchMetadata) (*MsgSubmitBatchMetadataResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitBatchMetadata not implemented")
}
func (*UnimplementedMsgServer) SubmitBatch(ctx context.Context, req *MsgSubmitBatch) (*MsgSubmitBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitBatch not implemented")
}

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

func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/junction.rollup.Msg/UpdateParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_InitRollup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgInitRollup)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).InitRollup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/junction.rollup.Msg/InitRollup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).InitRollup(ctx, req.(*MsgInitRollup))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_InitProver_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgInitProver)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).InitProver(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/junction.rollup.Msg/InitProver",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).InitProver(ctx, req.(*MsgInitProver))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SubmitBatchMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSubmitBatchMetadata)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SubmitBatchMetadata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/junction.rollup.Msg/SubmitBatchMetadata",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SubmitBatchMetadata(ctx, req.(*MsgSubmitBatchMetadata))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SubmitBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSubmitBatch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SubmitBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/junction.rollup.Msg/SubmitBatch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SubmitBatch(ctx, req.(*MsgSubmitBatch))
	}
	return interceptor(ctx, in, info, handler)
}

var Msg_serviceDesc = _Msg_serviceDesc
var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "junction.rollup.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UpdateParams",
			Handler:    _Msg_UpdateParams_Handler,
		},
		{
			MethodName: "InitRollup",
			Handler:    _Msg_InitRollup_Handler,
		},
		{
			MethodName: "InitProver",
			Handler:    _Msg_InitProver_Handler,
		},
		{
			MethodName: "SubmitBatchMetadata",
			Handler:    _Msg_SubmitBatchMetadata_Handler,
		},
		{
			MethodName: "SubmitBatch",
			Handler:    _Msg_SubmitBatch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "junction/rollup/tx.proto",
}

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

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

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

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

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

func (m *MsgInitRollup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelayerASCAddress) > 0 {
		i -= len(m.RelayerASCAddress)
		copy(dAtA[i:], m.RelayerASCAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RelayerASCAddress)))
		i--
		dAtA[i] = 0x72
	}
	if len(m.RelayerGAddress) > 0 {
		i -= len(m.RelayerGAddress)
		copy(dAtA[i:], m.RelayerGAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RelayerGAddress)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.AscContractAddress) > 0 {
		i -= len(m.AscContractAddress)
		copy(dAtA[i:], m.AscContractAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.AscContractAddress)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.GatewayContractAddress) > 0 {
		i -= len(m.GatewayContractAddress)
		copy(dAtA[i:], m.GatewayContractAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.GatewayContractAddress)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.TfheExecutorAddress) > 0 {
		i -= len(m.TfheExecutorAddress)
		copy(dAtA[i:], m.TfheExecutorAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.TfheExecutorAddress)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.KmsVerifierAddress) > 0 {
		i -= len(m.KmsVerifierAddress)
		copy(dAtA[i:], m.KmsVerifierAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.KmsVerifierAddress)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.AclContractAddress) > 0 {
		i -= len(m.AclContractAddress)
		copy(dAtA[i:], m.AclContractAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.AclContractAddress)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Supply) > 0 {
		dAtA3 := make([]byte, len(m.Supply)*10)
		var j2 int
		for _, num := range m.Supply {
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		i -= j2
		copy(dAtA[i:], dAtA3[:j2])
		i = encodeVarintTx(dAtA, i, uint64(j2))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Keys) > 0 {
		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Keys[iNdEx])
			copy(dAtA[i:], m.Keys[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.Keys[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.DaType) > 0 {
		i -= len(m.DaType)
		copy(dAtA[i:], m.DaType)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DaType)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.DenomName) > 0 {
		i -= len(m.DenomName)
		copy(dAtA[i:], m.DenomName)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DenomName)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Moniker) > 0 {
		i -= len(m.Moniker)
		copy(dAtA[i:], m.Moniker)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Moniker)))
		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 *MsgInitRollupResponse) 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 *MsgInitRollupResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgInitRollupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status {
		i--
		if m.Status {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.RollupId) > 0 {
		i -= len(m.RollupId)
		copy(dAtA[i:], m.RollupId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RollupId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgInitProver) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ProverEndpoint) > 0 {
		i -= len(m.ProverEndpoint)
		copy(dAtA[i:], m.ProverEndpoint)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ProverEndpoint)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ProverType) > 0 {
		i -= len(m.ProverType)
		copy(dAtA[i:], m.ProverType)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ProverType)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ProverVerificationKey) > 0 {
		i -= len(m.ProverVerificationKey)
		copy(dAtA[i:], m.ProverVerificationKey)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ProverVerificationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RollupId) > 0 {
		i -= len(m.RollupId)
		copy(dAtA[i:], m.RollupId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RollupId)))
		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 *MsgInitProverResponse) 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 *MsgInitProverResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgInitProverResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status {
		i--
		if m.Status {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgSubmitBatchMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DaNamespace) > 0 {
		i -= len(m.DaNamespace)
		copy(dAtA[i:], m.DaNamespace)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DaNamespace)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.DaPointer) > 0 {
		i -= len(m.DaPointer)
		copy(dAtA[i:], m.DaPointer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DaPointer)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.DaHash) > 0 {
		i -= len(m.DaHash)
		copy(dAtA[i:], m.DaHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DaHash)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.DaCommitment) > 0 {
		i -= len(m.DaCommitment)
		copy(dAtA[i:], m.DaCommitment)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DaCommitment)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.DaName) > 0 {
		i -= len(m.DaName)
		copy(dAtA[i:], m.DaName)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DaName)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RollupId) > 0 {
		i -= len(m.RollupId)
		copy(dAtA[i:], m.RollupId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RollupId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.BatchNo != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.BatchNo))
		i--
		dAtA[i] = 0x10
	}
	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 *MsgSubmitBatchMetadataResponse) 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 *MsgSubmitBatchMetadataResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgSubmitBatchMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status {
		i--
		if m.Status {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgSubmitBatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PublicWitness) > 0 {
		i -= len(m.PublicWitness)
		copy(dAtA[i:], m.PublicWitness)
		i = encodeVarintTx(dAtA, i, uint64(len(m.PublicWitness)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ZkProof) > 0 {
		i -= len(m.ZkProof)
		copy(dAtA[i:], m.ZkProof)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ZkProof)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.PreviousMerkleRootHash) > 0 {
		i -= len(m.PreviousMerkleRootHash)
		copy(dAtA[i:], m.PreviousMerkleRootHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.PreviousMerkleRootHash)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.MerkleRootHash) > 0 {
		i -= len(m.MerkleRootHash)
		copy(dAtA[i:], m.MerkleRootHash)
		i = encodeVarintTx(dAtA, i, uint64(len(m.MerkleRootHash)))
		i--
		dAtA[i] = 0x22
	}
	if m.BatchNo != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.BatchNo))
		i--
		dAtA[i] = 0x18
	}
	if len(m.RollupId) > 0 {
		i -= len(m.RollupId)
		copy(dAtA[i:], m.RollupId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RollupId)))
		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 *MsgSubmitBatchResponse) 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 *MsgSubmitBatchResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgSubmitBatchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status {
		i--
		if m.Status {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	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 *MsgUpdateParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Authority)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Params.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

func (m *MsgInitRollup) 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.Moniker)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DenomName)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DaType)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Keys) > 0 {
		for _, s := range m.Keys {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.Supply) > 0 {
		l = 0
		for _, e := range m.Supply {
			l += sovTx(uint64(e))
		}
		n += 1 + sovTx(uint64(l)) + l
	}
	l = len(m.AclContractAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.KmsVerifierAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.TfheExecutorAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.GatewayContractAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.AscContractAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.RelayerGAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.RelayerASCAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgInitRollupResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RollupId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Status {
		n += 2
	}
	return n
}

func (m *MsgInitProver) 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.RollupId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ProverVerificationKey)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ProverType)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ProverEndpoint)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgInitProverResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status {
		n += 2
	}
	return n
}

func (m *MsgSubmitBatchMetadata) 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))
	}
	if m.BatchNo != 0 {
		n += 1 + sovTx(uint64(m.BatchNo))
	}
	l = len(m.RollupId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DaName)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DaCommitment)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DaHash)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DaPointer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DaNamespace)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgSubmitBatchMetadataResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status {
		n += 2
	}
	return n
}

func (m *MsgSubmitBatch) 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.RollupId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.BatchNo != 0 {
		n += 1 + sovTx(uint64(m.BatchNo))
	}
	l = len(m.MerkleRootHash)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.PreviousMerkleRootHash)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ZkProof)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.PublicWitness)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgSubmitBatchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status {
		n += 2
	}
	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 *MsgUpdateParams) 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: MsgUpdateParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Authority", 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.Authority = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", 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.Params.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 *MsgUpdateParamsResponse) 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: MsgUpdateParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateParamsResponse: 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 *MsgInitRollup) 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: MsgInitRollup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgInitRollup: 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 Moniker", 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.Moniker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", 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.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenomName", 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.DenomName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DaType", 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.DaType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keys", 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.Keys = append(m.Keys, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 7:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Supply = append(m.Supply, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				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.Supply) == 0 {
					m.Supply = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Supply = append(m.Supply, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Supply", wireType)
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AclContractAddress", 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.AclContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KmsVerifierAddress", 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.KmsVerifierAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TfheExecutorAddress", 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.TfheExecutorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayContractAddress", 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.GatewayContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AscContractAddress", 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.AscContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayerGAddress", 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.RelayerGAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayerASCAddress", 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.RelayerASCAddress = 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 *MsgInitRollupResponse) 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: MsgInitRollupResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgInitRollupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollupId", 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.RollupId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = bool(v != 0)
		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 *MsgInitProver) 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: MsgInitProver: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgInitProver: 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 RollupId", 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.RollupId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProverVerificationKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProverVerificationKey = append(m.ProverVerificationKey[:0], dAtA[iNdEx:postIndex]...)
			if m.ProverVerificationKey == nil {
				m.ProverVerificationKey = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProverType", 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.ProverType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProverEndpoint", 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.ProverEndpoint = 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 *MsgInitProverResponse) 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: MsgInitProverResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgInitProverResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = bool(v != 0)
		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 *MsgSubmitBatchMetadata) 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: MsgSubmitBatchMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSubmitBatchMetadata: 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchNo", wireType)
			}
			m.BatchNo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BatchNo |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollupId", 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.RollupId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DaName", 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.DaName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DaCommitment", 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.DaCommitment = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DaHash", 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.DaHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DaPointer", 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.DaPointer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DaNamespace", 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.DaNamespace = 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 *MsgSubmitBatchMetadataResponse) 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: MsgSubmitBatchMetadataResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSubmitBatchMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = bool(v != 0)
		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 *MsgSubmitBatch) 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: MsgSubmitBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSubmitBatch: 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 RollupId", 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.RollupId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchNo", wireType)
			}
			m.BatchNo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BatchNo |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MerkleRootHash", 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.MerkleRootHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousMerkleRootHash", 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.PreviousMerkleRootHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZkProof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ZkProof = append(m.ZkProof[:0], dAtA[iNdEx:postIndex]...)
			if m.ZkProof == nil {
				m.ZkProof = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicWitness", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicWitness = append(m.PublicWitness[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicWitness == nil {
				m.PublicWitness = []byte{}
			}
			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 *MsgSubmitBatchResponse) 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: MsgSubmitBatchResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSubmitBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = bool(v != 0)
		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")
)
