// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
package rollup

import (
	_ "cosmossdk.io/api/amino"
	_ "cosmossdk.io/api/cosmos/base/v1beta1"
	_ "cosmossdk.io/api/cosmos/msg/v1"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	runtime "github.com/cosmos/cosmos-proto/runtime"
	_ "github.com/cosmos/gogoproto/gogoproto"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoiface "google.golang.org/protobuf/runtime/protoiface"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	io "io"
	reflect "reflect"
	sync "sync"
)

var (
	md_MsgUpdateParams           protoreflect.MessageDescriptor
	fd_MsgUpdateParams_authority protoreflect.FieldDescriptor
	fd_MsgUpdateParams_params    protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgUpdateParams = File_junction_rollup_tx_proto.Messages().ByName("MsgUpdateParams")
	fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority")
	fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params")
}

var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil)

type fastReflection_MsgUpdateParams MsgUpdateParams

func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgUpdateParams)(x)
}

func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType
var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{}

type fastReflection_MsgUpdateParams_messageType struct{}

func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgUpdateParams)(nil)
}
func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgUpdateParams)
}
func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgUpdateParams
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgUpdateParams
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgUpdateParams) Type() protoreflect.MessageType {
	return _fastReflection_MsgUpdateParams_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message {
	return new(fastReflection_MsgUpdateParams)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage {
	return (*MsgUpdateParams)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Authority != "" {
		value := protoreflect.ValueOfString(x.Authority)
		if !f(fd_MsgUpdateParams_authority, value) {
			return
		}
	}
	if x.Params != nil {
		value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
		if !f(fd_MsgUpdateParams_params, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgUpdateParams.authority":
		return x.Authority != ""
	case "junction.rollup.MsgUpdateParams.params":
		return x.Params != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParams"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParams does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgUpdateParams.authority":
		x.Authority = ""
	case "junction.rollup.MsgUpdateParams.params":
		x.Params = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParams"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParams does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgUpdateParams.authority":
		value := x.Authority
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgUpdateParams.params":
		value := x.Params
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParams"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParams does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgUpdateParams.authority":
		x.Authority = value.Interface().(string)
	case "junction.rollup.MsgUpdateParams.params":
		x.Params = value.Message().Interface().(*Params)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParams"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParams does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgUpdateParams.params":
		if x.Params == nil {
			x.Params = new(Params)
		}
		return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
	case "junction.rollup.MsgUpdateParams.authority":
		panic(fmt.Errorf("field authority of message junction.rollup.MsgUpdateParams is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParams"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParams does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgUpdateParams.authority":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgUpdateParams.params":
		m := new(Params)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParams"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParams does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgUpdateParams", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgUpdateParams) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParams) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgUpdateParams) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgUpdateParams) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgUpdateParams)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Authority)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Params != nil {
			l = options.Size(x.Params)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgUpdateParams)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Params != nil {
			encoded, err := options.Marshal(x.Params)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Authority) > 0 {
			i -= len(x.Authority)
			copy(dAtA[i:], x.Authority)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgUpdateParams)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Authority = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Params == nil {
					x.Params = &Params{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_MsgUpdateParamsResponse protoreflect.MessageDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgUpdateParamsResponse = File_junction_rollup_tx_proto.Messages().ByName("MsgUpdateParamsResponse")
}

var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil)

type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse

func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgUpdateParamsResponse)(x)
}

func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType
var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{}

type fastReflection_MsgUpdateParamsResponse_messageType struct{}

func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgUpdateParamsResponse)(nil)
}
func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgUpdateParamsResponse)
}
func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgUpdateParamsResponse
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgUpdateParamsResponse
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgUpdateParamsResponse) Type() protoreflect.MessageType {
	return _fastReflection_MsgUpdateParamsResponse_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message {
	return new(fastReflection_MsgUpdateParamsResponse)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage {
	return (*MsgUpdateParamsResponse)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgUpdateParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParamsResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParamsResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParamsResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParamsResponse does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParamsResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParamsResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgUpdateParamsResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgUpdateParamsResponse does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgUpdateParamsResponse", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgUpdateParamsResponse) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgUpdateParamsResponse) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgUpdateParamsResponse) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgUpdateParamsResponse)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgUpdateParamsResponse)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgUpdateParamsResponse)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_MsgInitRollup_6_list)(nil)

type _MsgInitRollup_6_list struct {
	list *[]string
}

func (x *_MsgInitRollup_6_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_MsgInitRollup_6_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfString((*x.list)[i])
}

func (x *_MsgInitRollup_6_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.String()
	concreteValue := valueUnwrapped
	(*x.list)[i] = concreteValue
}

func (x *_MsgInitRollup_6_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.String()
	concreteValue := valueUnwrapped
	*x.list = append(*x.list, concreteValue)
}

func (x *_MsgInitRollup_6_list) AppendMutable() protoreflect.Value {
	panic(fmt.Errorf("AppendMutable can not be called on message MsgInitRollup at list field Keys as it is not of Message kind"))
}

func (x *_MsgInitRollup_6_list) Truncate(n int) {
	*x.list = (*x.list)[:n]
}

func (x *_MsgInitRollup_6_list) NewElement() protoreflect.Value {
	v := ""
	return protoreflect.ValueOfString(v)
}

func (x *_MsgInitRollup_6_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_MsgInitRollup_7_list)(nil)

type _MsgInitRollup_7_list struct {
	list *[]uint64
}

func (x *_MsgInitRollup_7_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_MsgInitRollup_7_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfUint64((*x.list)[i])
}

func (x *_MsgInitRollup_7_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Uint()
	concreteValue := valueUnwrapped
	(*x.list)[i] = concreteValue
}

func (x *_MsgInitRollup_7_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Uint()
	concreteValue := valueUnwrapped
	*x.list = append(*x.list, concreteValue)
}

func (x *_MsgInitRollup_7_list) AppendMutable() protoreflect.Value {
	panic(fmt.Errorf("AppendMutable can not be called on message MsgInitRollup at list field Supply as it is not of Message kind"))
}

func (x *_MsgInitRollup_7_list) Truncate(n int) {
	*x.list = (*x.list)[:n]
}

func (x *_MsgInitRollup_7_list) NewElement() protoreflect.Value {
	v := uint64(0)
	return protoreflect.ValueOfUint64(v)
}

func (x *_MsgInitRollup_7_list) IsValid() bool {
	return x.list != nil
}

var (
	md_MsgInitRollup                        protoreflect.MessageDescriptor
	fd_MsgInitRollup_creator                protoreflect.FieldDescriptor
	fd_MsgInitRollup_moniker                protoreflect.FieldDescriptor
	fd_MsgInitRollup_chainId                protoreflect.FieldDescriptor
	fd_MsgInitRollup_denomName              protoreflect.FieldDescriptor
	fd_MsgInitRollup_daType                 protoreflect.FieldDescriptor
	fd_MsgInitRollup_keys                   protoreflect.FieldDescriptor
	fd_MsgInitRollup_supply                 protoreflect.FieldDescriptor
	fd_MsgInitRollup_aclContractAddress     protoreflect.FieldDescriptor
	fd_MsgInitRollup_kmsVerifierAddress     protoreflect.FieldDescriptor
	fd_MsgInitRollup_tfheExecutorAddress    protoreflect.FieldDescriptor
	fd_MsgInitRollup_gatewayContractAddress protoreflect.FieldDescriptor
	fd_MsgInitRollup_ascContractAddress     protoreflect.FieldDescriptor
	fd_MsgInitRollup_relayerGAddress        protoreflect.FieldDescriptor
	fd_MsgInitRollup_relayerASCAddress      protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgInitRollup = File_junction_rollup_tx_proto.Messages().ByName("MsgInitRollup")
	fd_MsgInitRollup_creator = md_MsgInitRollup.Fields().ByName("creator")
	fd_MsgInitRollup_moniker = md_MsgInitRollup.Fields().ByName("moniker")
	fd_MsgInitRollup_chainId = md_MsgInitRollup.Fields().ByName("chainId")
	fd_MsgInitRollup_denomName = md_MsgInitRollup.Fields().ByName("denomName")
	fd_MsgInitRollup_daType = md_MsgInitRollup.Fields().ByName("daType")
	fd_MsgInitRollup_keys = md_MsgInitRollup.Fields().ByName("keys")
	fd_MsgInitRollup_supply = md_MsgInitRollup.Fields().ByName("supply")
	fd_MsgInitRollup_aclContractAddress = md_MsgInitRollup.Fields().ByName("aclContractAddress")
	fd_MsgInitRollup_kmsVerifierAddress = md_MsgInitRollup.Fields().ByName("kmsVerifierAddress")
	fd_MsgInitRollup_tfheExecutorAddress = md_MsgInitRollup.Fields().ByName("tfheExecutorAddress")
	fd_MsgInitRollup_gatewayContractAddress = md_MsgInitRollup.Fields().ByName("gatewayContractAddress")
	fd_MsgInitRollup_ascContractAddress = md_MsgInitRollup.Fields().ByName("ascContractAddress")
	fd_MsgInitRollup_relayerGAddress = md_MsgInitRollup.Fields().ByName("relayerGAddress")
	fd_MsgInitRollup_relayerASCAddress = md_MsgInitRollup.Fields().ByName("relayerASCAddress")
}

var _ protoreflect.Message = (*fastReflection_MsgInitRollup)(nil)

type fastReflection_MsgInitRollup MsgInitRollup

func (x *MsgInitRollup) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgInitRollup)(x)
}

func (x *MsgInitRollup) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[2]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgInitRollup_messageType fastReflection_MsgInitRollup_messageType
var _ protoreflect.MessageType = fastReflection_MsgInitRollup_messageType{}

type fastReflection_MsgInitRollup_messageType struct{}

func (x fastReflection_MsgInitRollup_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgInitRollup)(nil)
}
func (x fastReflection_MsgInitRollup_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgInitRollup)
}
func (x fastReflection_MsgInitRollup_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgInitRollup
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgInitRollup) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgInitRollup
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgInitRollup) Type() protoreflect.MessageType {
	return _fastReflection_MsgInitRollup_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgInitRollup) New() protoreflect.Message {
	return new(fastReflection_MsgInitRollup)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgInitRollup) Interface() protoreflect.ProtoMessage {
	return (*MsgInitRollup)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgInitRollup) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Creator != "" {
		value := protoreflect.ValueOfString(x.Creator)
		if !f(fd_MsgInitRollup_creator, value) {
			return
		}
	}
	if x.Moniker != "" {
		value := protoreflect.ValueOfString(x.Moniker)
		if !f(fd_MsgInitRollup_moniker, value) {
			return
		}
	}
	if x.ChainId != "" {
		value := protoreflect.ValueOfString(x.ChainId)
		if !f(fd_MsgInitRollup_chainId, value) {
			return
		}
	}
	if x.DenomName != "" {
		value := protoreflect.ValueOfString(x.DenomName)
		if !f(fd_MsgInitRollup_denomName, value) {
			return
		}
	}
	if x.DaType != "" {
		value := protoreflect.ValueOfString(x.DaType)
		if !f(fd_MsgInitRollup_daType, value) {
			return
		}
	}
	if len(x.Keys) != 0 {
		value := protoreflect.ValueOfList(&_MsgInitRollup_6_list{list: &x.Keys})
		if !f(fd_MsgInitRollup_keys, value) {
			return
		}
	}
	if len(x.Supply) != 0 {
		value := protoreflect.ValueOfList(&_MsgInitRollup_7_list{list: &x.Supply})
		if !f(fd_MsgInitRollup_supply, value) {
			return
		}
	}
	if x.AclContractAddress != "" {
		value := protoreflect.ValueOfString(x.AclContractAddress)
		if !f(fd_MsgInitRollup_aclContractAddress, value) {
			return
		}
	}
	if x.KmsVerifierAddress != "" {
		value := protoreflect.ValueOfString(x.KmsVerifierAddress)
		if !f(fd_MsgInitRollup_kmsVerifierAddress, value) {
			return
		}
	}
	if x.TfheExecutorAddress != "" {
		value := protoreflect.ValueOfString(x.TfheExecutorAddress)
		if !f(fd_MsgInitRollup_tfheExecutorAddress, value) {
			return
		}
	}
	if x.GatewayContractAddress != "" {
		value := protoreflect.ValueOfString(x.GatewayContractAddress)
		if !f(fd_MsgInitRollup_gatewayContractAddress, value) {
			return
		}
	}
	if x.AscContractAddress != "" {
		value := protoreflect.ValueOfString(x.AscContractAddress)
		if !f(fd_MsgInitRollup_ascContractAddress, value) {
			return
		}
	}
	if x.RelayerGAddress != "" {
		value := protoreflect.ValueOfString(x.RelayerGAddress)
		if !f(fd_MsgInitRollup_relayerGAddress, value) {
			return
		}
	}
	if x.RelayerASCAddress != "" {
		value := protoreflect.ValueOfString(x.RelayerASCAddress)
		if !f(fd_MsgInitRollup_relayerASCAddress, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgInitRollup) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollup.creator":
		return x.Creator != ""
	case "junction.rollup.MsgInitRollup.moniker":
		return x.Moniker != ""
	case "junction.rollup.MsgInitRollup.chainId":
		return x.ChainId != ""
	case "junction.rollup.MsgInitRollup.denomName":
		return x.DenomName != ""
	case "junction.rollup.MsgInitRollup.daType":
		return x.DaType != ""
	case "junction.rollup.MsgInitRollup.keys":
		return len(x.Keys) != 0
	case "junction.rollup.MsgInitRollup.supply":
		return len(x.Supply) != 0
	case "junction.rollup.MsgInitRollup.aclContractAddress":
		return x.AclContractAddress != ""
	case "junction.rollup.MsgInitRollup.kmsVerifierAddress":
		return x.KmsVerifierAddress != ""
	case "junction.rollup.MsgInitRollup.tfheExecutorAddress":
		return x.TfheExecutorAddress != ""
	case "junction.rollup.MsgInitRollup.gatewayContractAddress":
		return x.GatewayContractAddress != ""
	case "junction.rollup.MsgInitRollup.ascContractAddress":
		return x.AscContractAddress != ""
	case "junction.rollup.MsgInitRollup.relayerGAddress":
		return x.RelayerGAddress != ""
	case "junction.rollup.MsgInitRollup.relayerASCAddress":
		return x.RelayerASCAddress != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollup"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollup does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitRollup) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollup.creator":
		x.Creator = ""
	case "junction.rollup.MsgInitRollup.moniker":
		x.Moniker = ""
	case "junction.rollup.MsgInitRollup.chainId":
		x.ChainId = ""
	case "junction.rollup.MsgInitRollup.denomName":
		x.DenomName = ""
	case "junction.rollup.MsgInitRollup.daType":
		x.DaType = ""
	case "junction.rollup.MsgInitRollup.keys":
		x.Keys = nil
	case "junction.rollup.MsgInitRollup.supply":
		x.Supply = nil
	case "junction.rollup.MsgInitRollup.aclContractAddress":
		x.AclContractAddress = ""
	case "junction.rollup.MsgInitRollup.kmsVerifierAddress":
		x.KmsVerifierAddress = ""
	case "junction.rollup.MsgInitRollup.tfheExecutorAddress":
		x.TfheExecutorAddress = ""
	case "junction.rollup.MsgInitRollup.gatewayContractAddress":
		x.GatewayContractAddress = ""
	case "junction.rollup.MsgInitRollup.ascContractAddress":
		x.AscContractAddress = ""
	case "junction.rollup.MsgInitRollup.relayerGAddress":
		x.RelayerGAddress = ""
	case "junction.rollup.MsgInitRollup.relayerASCAddress":
		x.RelayerASCAddress = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollup"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollup does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgInitRollup) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgInitRollup.creator":
		value := x.Creator
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.moniker":
		value := x.Moniker
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.chainId":
		value := x.ChainId
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.denomName":
		value := x.DenomName
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.daType":
		value := x.DaType
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.keys":
		if len(x.Keys) == 0 {
			return protoreflect.ValueOfList(&_MsgInitRollup_6_list{})
		}
		listValue := &_MsgInitRollup_6_list{list: &x.Keys}
		return protoreflect.ValueOfList(listValue)
	case "junction.rollup.MsgInitRollup.supply":
		if len(x.Supply) == 0 {
			return protoreflect.ValueOfList(&_MsgInitRollup_7_list{})
		}
		listValue := &_MsgInitRollup_7_list{list: &x.Supply}
		return protoreflect.ValueOfList(listValue)
	case "junction.rollup.MsgInitRollup.aclContractAddress":
		value := x.AclContractAddress
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.kmsVerifierAddress":
		value := x.KmsVerifierAddress
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.tfheExecutorAddress":
		value := x.TfheExecutorAddress
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.gatewayContractAddress":
		value := x.GatewayContractAddress
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.ascContractAddress":
		value := x.AscContractAddress
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.relayerGAddress":
		value := x.RelayerGAddress
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollup.relayerASCAddress":
		value := x.RelayerASCAddress
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollup"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollup does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitRollup) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollup.creator":
		x.Creator = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.moniker":
		x.Moniker = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.chainId":
		x.ChainId = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.denomName":
		x.DenomName = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.daType":
		x.DaType = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.keys":
		lv := value.List()
		clv := lv.(*_MsgInitRollup_6_list)
		x.Keys = *clv.list
	case "junction.rollup.MsgInitRollup.supply":
		lv := value.List()
		clv := lv.(*_MsgInitRollup_7_list)
		x.Supply = *clv.list
	case "junction.rollup.MsgInitRollup.aclContractAddress":
		x.AclContractAddress = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.kmsVerifierAddress":
		x.KmsVerifierAddress = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.tfheExecutorAddress":
		x.TfheExecutorAddress = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.gatewayContractAddress":
		x.GatewayContractAddress = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.ascContractAddress":
		x.AscContractAddress = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.relayerGAddress":
		x.RelayerGAddress = value.Interface().(string)
	case "junction.rollup.MsgInitRollup.relayerASCAddress":
		x.RelayerASCAddress = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollup"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollup does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitRollup) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollup.keys":
		if x.Keys == nil {
			x.Keys = []string{}
		}
		value := &_MsgInitRollup_6_list{list: &x.Keys}
		return protoreflect.ValueOfList(value)
	case "junction.rollup.MsgInitRollup.supply":
		if x.Supply == nil {
			x.Supply = []uint64{}
		}
		value := &_MsgInitRollup_7_list{list: &x.Supply}
		return protoreflect.ValueOfList(value)
	case "junction.rollup.MsgInitRollup.creator":
		panic(fmt.Errorf("field creator of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.moniker":
		panic(fmt.Errorf("field moniker of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.chainId":
		panic(fmt.Errorf("field chainId of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.denomName":
		panic(fmt.Errorf("field denomName of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.daType":
		panic(fmt.Errorf("field daType of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.aclContractAddress":
		panic(fmt.Errorf("field aclContractAddress of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.kmsVerifierAddress":
		panic(fmt.Errorf("field kmsVerifierAddress of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.tfheExecutorAddress":
		panic(fmt.Errorf("field tfheExecutorAddress of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.gatewayContractAddress":
		panic(fmt.Errorf("field gatewayContractAddress of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.ascContractAddress":
		panic(fmt.Errorf("field ascContractAddress of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.relayerGAddress":
		panic(fmt.Errorf("field relayerGAddress of message junction.rollup.MsgInitRollup is not mutable"))
	case "junction.rollup.MsgInitRollup.relayerASCAddress":
		panic(fmt.Errorf("field relayerASCAddress of message junction.rollup.MsgInitRollup is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollup"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollup does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgInitRollup) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollup.creator":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.moniker":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.chainId":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.denomName":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.daType":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.keys":
		list := []string{}
		return protoreflect.ValueOfList(&_MsgInitRollup_6_list{list: &list})
	case "junction.rollup.MsgInitRollup.supply":
		list := []uint64{}
		return protoreflect.ValueOfList(&_MsgInitRollup_7_list{list: &list})
	case "junction.rollup.MsgInitRollup.aclContractAddress":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.kmsVerifierAddress":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.tfheExecutorAddress":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.gatewayContractAddress":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.ascContractAddress":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.relayerGAddress":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollup.relayerASCAddress":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollup"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollup does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgInitRollup) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgInitRollup", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgInitRollup) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitRollup) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgInitRollup) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgInitRollup) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgInitRollup)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Creator)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.Moniker)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.ChainId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.DenomName)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.DaType)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.Keys) > 0 {
			for _, s := range x.Keys {
				l = len(s)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.Supply) > 0 {
			l = 0
			for _, e := range x.Supply {
				l += runtime.Sov(uint64(e))
			}
			n += 1 + runtime.Sov(uint64(l)) + l
		}
		l = len(x.AclContractAddress)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.KmsVerifierAddress)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.TfheExecutorAddress)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.GatewayContractAddress)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.AscContractAddress)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.RelayerGAddress)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.RelayerASCAddress)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgInitRollup)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.RelayerASCAddress) > 0 {
			i -= len(x.RelayerASCAddress)
			copy(dAtA[i:], x.RelayerASCAddress)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RelayerASCAddress)))
			i--
			dAtA[i] = 0x72
		}
		if len(x.RelayerGAddress) > 0 {
			i -= len(x.RelayerGAddress)
			copy(dAtA[i:], x.RelayerGAddress)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RelayerGAddress)))
			i--
			dAtA[i] = 0x6a
		}
		if len(x.AscContractAddress) > 0 {
			i -= len(x.AscContractAddress)
			copy(dAtA[i:], x.AscContractAddress)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AscContractAddress)))
			i--
			dAtA[i] = 0x62
		}
		if len(x.GatewayContractAddress) > 0 {
			i -= len(x.GatewayContractAddress)
			copy(dAtA[i:], x.GatewayContractAddress)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GatewayContractAddress)))
			i--
			dAtA[i] = 0x5a
		}
		if len(x.TfheExecutorAddress) > 0 {
			i -= len(x.TfheExecutorAddress)
			copy(dAtA[i:], x.TfheExecutorAddress)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.TfheExecutorAddress)))
			i--
			dAtA[i] = 0x52
		}
		if len(x.KmsVerifierAddress) > 0 {
			i -= len(x.KmsVerifierAddress)
			copy(dAtA[i:], x.KmsVerifierAddress)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.KmsVerifierAddress)))
			i--
			dAtA[i] = 0x4a
		}
		if len(x.AclContractAddress) > 0 {
			i -= len(x.AclContractAddress)
			copy(dAtA[i:], x.AclContractAddress)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AclContractAddress)))
			i--
			dAtA[i] = 0x42
		}
		if len(x.Supply) > 0 {
			var pksize2 int
			for _, num := range x.Supply {
				pksize2 += runtime.Sov(uint64(num))
			}
			i -= pksize2
			j1 := i
			for _, num := range x.Supply {
				for num >= 1<<7 {
					dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
					num >>= 7
					j1++
				}
				dAtA[j1] = uint8(num)
				j1++
			}
			i = runtime.EncodeVarint(dAtA, i, uint64(pksize2))
			i--
			dAtA[i] = 0x3a
		}
		if len(x.Keys) > 0 {
			for iNdEx := len(x.Keys) - 1; iNdEx >= 0; iNdEx-- {
				i -= len(x.Keys[iNdEx])
				copy(dAtA[i:], x.Keys[iNdEx])
				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Keys[iNdEx])))
				i--
				dAtA[i] = 0x32
			}
		}
		if len(x.DaType) > 0 {
			i -= len(x.DaType)
			copy(dAtA[i:], x.DaType)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DaType)))
			i--
			dAtA[i] = 0x2a
		}
		if len(x.DenomName) > 0 {
			i -= len(x.DenomName)
			copy(dAtA[i:], x.DenomName)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DenomName)))
			i--
			dAtA[i] = 0x22
		}
		if len(x.ChainId) > 0 {
			i -= len(x.ChainId)
			copy(dAtA[i:], x.ChainId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.Moniker) > 0 {
			i -= len(x.Moniker)
			copy(dAtA[i:], x.Moniker)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Moniker)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Creator) > 0 {
			i -= len(x.Creator)
			copy(dAtA[i:], x.Creator)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgInitRollup)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitRollup: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitRollup: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Creator = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Moniker = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.ChainId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DenomName", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.DenomName = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DaType", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.DaType = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 6:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Keys = append(x.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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
						}
						if iNdEx >= l {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					x.Supply = append(x.Supply, v)
				} else if wireType == 2 {
					var packedLen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
						}
						if iNdEx >= l {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						packedLen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if packedLen < 0 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
					}
					postIndex := iNdEx + packedLen
					if postIndex < 0 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
					}
					if postIndex > l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					var elementCount int
					var count int
					for _, integer := range dAtA[iNdEx:postIndex] {
						if integer < 128 {
							count++
						}
					}
					elementCount = count
					if elementCount != 0 && len(x.Supply) == 0 {
						x.Supply = make([]uint64, 0, elementCount)
					}
					for iNdEx < postIndex {
						var v uint64
						for shift := uint(0); ; shift += 7 {
							if shift >= 64 {
								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
							}
							if iNdEx >= l {
								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
							}
							b := dAtA[iNdEx]
							iNdEx++
							v |= uint64(b&0x7F) << shift
							if b < 0x80 {
								break
							}
						}
						x.Supply = append(x.Supply, v)
					}
				} else {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Supply", wireType)
				}
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AclContractAddress", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.AclContractAddress = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field KmsVerifierAddress", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.KmsVerifierAddress = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 10:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TfheExecutorAddress", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.TfheExecutorAddress = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 11:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GatewayContractAddress", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.GatewayContractAddress = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 12:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AscContractAddress", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.AscContractAddress = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 13:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RelayerGAddress", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.RelayerGAddress = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 14:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RelayerASCAddress", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.RelayerASCAddress = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_MsgInitRollupResponse          protoreflect.MessageDescriptor
	fd_MsgInitRollupResponse_rollupId protoreflect.FieldDescriptor
	fd_MsgInitRollupResponse_status   protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgInitRollupResponse = File_junction_rollup_tx_proto.Messages().ByName("MsgInitRollupResponse")
	fd_MsgInitRollupResponse_rollupId = md_MsgInitRollupResponse.Fields().ByName("rollupId")
	fd_MsgInitRollupResponse_status = md_MsgInitRollupResponse.Fields().ByName("status")
}

var _ protoreflect.Message = (*fastReflection_MsgInitRollupResponse)(nil)

type fastReflection_MsgInitRollupResponse MsgInitRollupResponse

func (x *MsgInitRollupResponse) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgInitRollupResponse)(x)
}

func (x *MsgInitRollupResponse) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[3]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgInitRollupResponse_messageType fastReflection_MsgInitRollupResponse_messageType
var _ protoreflect.MessageType = fastReflection_MsgInitRollupResponse_messageType{}

type fastReflection_MsgInitRollupResponse_messageType struct{}

func (x fastReflection_MsgInitRollupResponse_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgInitRollupResponse)(nil)
}
func (x fastReflection_MsgInitRollupResponse_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgInitRollupResponse)
}
func (x fastReflection_MsgInitRollupResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgInitRollupResponse
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgInitRollupResponse) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgInitRollupResponse
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgInitRollupResponse) Type() protoreflect.MessageType {
	return _fastReflection_MsgInitRollupResponse_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgInitRollupResponse) New() protoreflect.Message {
	return new(fastReflection_MsgInitRollupResponse)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgInitRollupResponse) Interface() protoreflect.ProtoMessage {
	return (*MsgInitRollupResponse)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgInitRollupResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.RollupId != "" {
		value := protoreflect.ValueOfString(x.RollupId)
		if !f(fd_MsgInitRollupResponse_rollupId, value) {
			return
		}
	}
	if x.Status != false {
		value := protoreflect.ValueOfBool(x.Status)
		if !f(fd_MsgInitRollupResponse_status, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgInitRollupResponse) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollupResponse.rollupId":
		return x.RollupId != ""
	case "junction.rollup.MsgInitRollupResponse.status":
		return x.Status != false
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollupResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollupResponse does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitRollupResponse) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollupResponse.rollupId":
		x.RollupId = ""
	case "junction.rollup.MsgInitRollupResponse.status":
		x.Status = false
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollupResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollupResponse does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgInitRollupResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgInitRollupResponse.rollupId":
		value := x.RollupId
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitRollupResponse.status":
		value := x.Status
		return protoreflect.ValueOfBool(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollupResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollupResponse does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitRollupResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollupResponse.rollupId":
		x.RollupId = value.Interface().(string)
	case "junction.rollup.MsgInitRollupResponse.status":
		x.Status = value.Bool()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollupResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollupResponse does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitRollupResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollupResponse.rollupId":
		panic(fmt.Errorf("field rollupId of message junction.rollup.MsgInitRollupResponse is not mutable"))
	case "junction.rollup.MsgInitRollupResponse.status":
		panic(fmt.Errorf("field status of message junction.rollup.MsgInitRollupResponse is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollupResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollupResponse does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgInitRollupResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgInitRollupResponse.rollupId":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitRollupResponse.status":
		return protoreflect.ValueOfBool(false)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitRollupResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitRollupResponse does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgInitRollupResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgInitRollupResponse", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgInitRollupResponse) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitRollupResponse) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgInitRollupResponse) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgInitRollupResponse) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgInitRollupResponse)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.RollupId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Status {
			n += 2
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgInitRollupResponse)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Status {
			i--
			if x.Status {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x10
		}
		if len(x.RollupId) > 0 {
			i -= len(x.RollupId)
			copy(dAtA[i:], x.RollupId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RollupId)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgInitRollupResponse)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitRollupResponse: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitRollupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RollupId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.RollupId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
				}
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Status = bool(v != 0)
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_MsgInitProver                       protoreflect.MessageDescriptor
	fd_MsgInitProver_creator               protoreflect.FieldDescriptor
	fd_MsgInitProver_rollupId              protoreflect.FieldDescriptor
	fd_MsgInitProver_proverVerificationKey protoreflect.FieldDescriptor
	fd_MsgInitProver_proverType            protoreflect.FieldDescriptor
	fd_MsgInitProver_proverEndpoint        protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgInitProver = File_junction_rollup_tx_proto.Messages().ByName("MsgInitProver")
	fd_MsgInitProver_creator = md_MsgInitProver.Fields().ByName("creator")
	fd_MsgInitProver_rollupId = md_MsgInitProver.Fields().ByName("rollupId")
	fd_MsgInitProver_proverVerificationKey = md_MsgInitProver.Fields().ByName("proverVerificationKey")
	fd_MsgInitProver_proverType = md_MsgInitProver.Fields().ByName("proverType")
	fd_MsgInitProver_proverEndpoint = md_MsgInitProver.Fields().ByName("proverEndpoint")
}

var _ protoreflect.Message = (*fastReflection_MsgInitProver)(nil)

type fastReflection_MsgInitProver MsgInitProver

func (x *MsgInitProver) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgInitProver)(x)
}

func (x *MsgInitProver) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[4]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgInitProver_messageType fastReflection_MsgInitProver_messageType
var _ protoreflect.MessageType = fastReflection_MsgInitProver_messageType{}

type fastReflection_MsgInitProver_messageType struct{}

func (x fastReflection_MsgInitProver_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgInitProver)(nil)
}
func (x fastReflection_MsgInitProver_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgInitProver)
}
func (x fastReflection_MsgInitProver_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgInitProver
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgInitProver) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgInitProver
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgInitProver) Type() protoreflect.MessageType {
	return _fastReflection_MsgInitProver_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgInitProver) New() protoreflect.Message {
	return new(fastReflection_MsgInitProver)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgInitProver) Interface() protoreflect.ProtoMessage {
	return (*MsgInitProver)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgInitProver) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Creator != "" {
		value := protoreflect.ValueOfString(x.Creator)
		if !f(fd_MsgInitProver_creator, value) {
			return
		}
	}
	if x.RollupId != "" {
		value := protoreflect.ValueOfString(x.RollupId)
		if !f(fd_MsgInitProver_rollupId, value) {
			return
		}
	}
	if len(x.ProverVerificationKey) != 0 {
		value := protoreflect.ValueOfBytes(x.ProverVerificationKey)
		if !f(fd_MsgInitProver_proverVerificationKey, value) {
			return
		}
	}
	if x.ProverType != "" {
		value := protoreflect.ValueOfString(x.ProverType)
		if !f(fd_MsgInitProver_proverType, value) {
			return
		}
	}
	if x.ProverEndpoint != "" {
		value := protoreflect.ValueOfString(x.ProverEndpoint)
		if !f(fd_MsgInitProver_proverEndpoint, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgInitProver) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProver.creator":
		return x.Creator != ""
	case "junction.rollup.MsgInitProver.rollupId":
		return x.RollupId != ""
	case "junction.rollup.MsgInitProver.proverVerificationKey":
		return len(x.ProverVerificationKey) != 0
	case "junction.rollup.MsgInitProver.proverType":
		return x.ProverType != ""
	case "junction.rollup.MsgInitProver.proverEndpoint":
		return x.ProverEndpoint != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProver"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProver does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitProver) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProver.creator":
		x.Creator = ""
	case "junction.rollup.MsgInitProver.rollupId":
		x.RollupId = ""
	case "junction.rollup.MsgInitProver.proverVerificationKey":
		x.ProverVerificationKey = nil
	case "junction.rollup.MsgInitProver.proverType":
		x.ProverType = ""
	case "junction.rollup.MsgInitProver.proverEndpoint":
		x.ProverEndpoint = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProver"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProver does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgInitProver) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgInitProver.creator":
		value := x.Creator
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitProver.rollupId":
		value := x.RollupId
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitProver.proverVerificationKey":
		value := x.ProverVerificationKey
		return protoreflect.ValueOfBytes(value)
	case "junction.rollup.MsgInitProver.proverType":
		value := x.ProverType
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgInitProver.proverEndpoint":
		value := x.ProverEndpoint
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProver"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProver does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitProver) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProver.creator":
		x.Creator = value.Interface().(string)
	case "junction.rollup.MsgInitProver.rollupId":
		x.RollupId = value.Interface().(string)
	case "junction.rollup.MsgInitProver.proverVerificationKey":
		x.ProverVerificationKey = value.Bytes()
	case "junction.rollup.MsgInitProver.proverType":
		x.ProverType = value.Interface().(string)
	case "junction.rollup.MsgInitProver.proverEndpoint":
		x.ProverEndpoint = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProver"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProver does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitProver) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProver.creator":
		panic(fmt.Errorf("field creator of message junction.rollup.MsgInitProver is not mutable"))
	case "junction.rollup.MsgInitProver.rollupId":
		panic(fmt.Errorf("field rollupId of message junction.rollup.MsgInitProver is not mutable"))
	case "junction.rollup.MsgInitProver.proverVerificationKey":
		panic(fmt.Errorf("field proverVerificationKey of message junction.rollup.MsgInitProver is not mutable"))
	case "junction.rollup.MsgInitProver.proverType":
		panic(fmt.Errorf("field proverType of message junction.rollup.MsgInitProver is not mutable"))
	case "junction.rollup.MsgInitProver.proverEndpoint":
		panic(fmt.Errorf("field proverEndpoint of message junction.rollup.MsgInitProver is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProver"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProver does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgInitProver) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProver.creator":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitProver.rollupId":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitProver.proverVerificationKey":
		return protoreflect.ValueOfBytes(nil)
	case "junction.rollup.MsgInitProver.proverType":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgInitProver.proverEndpoint":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProver"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProver does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgInitProver) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgInitProver", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgInitProver) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitProver) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgInitProver) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgInitProver) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgInitProver)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Creator)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.RollupId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.ProverVerificationKey)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.ProverType)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.ProverEndpoint)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgInitProver)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.ProverEndpoint) > 0 {
			i -= len(x.ProverEndpoint)
			copy(dAtA[i:], x.ProverEndpoint)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProverEndpoint)))
			i--
			dAtA[i] = 0x2a
		}
		if len(x.ProverType) > 0 {
			i -= len(x.ProverType)
			copy(dAtA[i:], x.ProverType)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProverType)))
			i--
			dAtA[i] = 0x22
		}
		if len(x.ProverVerificationKey) > 0 {
			i -= len(x.ProverVerificationKey)
			copy(dAtA[i:], x.ProverVerificationKey)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProverVerificationKey)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.RollupId) > 0 {
			i -= len(x.RollupId)
			copy(dAtA[i:], x.RollupId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RollupId)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Creator) > 0 {
			i -= len(x.Creator)
			copy(dAtA[i:], x.Creator)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgInitProver)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitProver: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitProver: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Creator = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RollupId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.RollupId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProverVerificationKey", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.ProverVerificationKey = append(x.ProverVerificationKey[:0], dAtA[iNdEx:postIndex]...)
				if x.ProverVerificationKey == nil {
					x.ProverVerificationKey = []byte{}
				}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProverType", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.ProverType = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProverEndpoint", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.ProverEndpoint = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_MsgInitProverResponse        protoreflect.MessageDescriptor
	fd_MsgInitProverResponse_status protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgInitProverResponse = File_junction_rollup_tx_proto.Messages().ByName("MsgInitProverResponse")
	fd_MsgInitProverResponse_status = md_MsgInitProverResponse.Fields().ByName("status")
}

var _ protoreflect.Message = (*fastReflection_MsgInitProverResponse)(nil)

type fastReflection_MsgInitProverResponse MsgInitProverResponse

func (x *MsgInitProverResponse) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgInitProverResponse)(x)
}

func (x *MsgInitProverResponse) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[5]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgInitProverResponse_messageType fastReflection_MsgInitProverResponse_messageType
var _ protoreflect.MessageType = fastReflection_MsgInitProverResponse_messageType{}

type fastReflection_MsgInitProverResponse_messageType struct{}

func (x fastReflection_MsgInitProverResponse_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgInitProverResponse)(nil)
}
func (x fastReflection_MsgInitProverResponse_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgInitProverResponse)
}
func (x fastReflection_MsgInitProverResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgInitProverResponse
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgInitProverResponse) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgInitProverResponse
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgInitProverResponse) Type() protoreflect.MessageType {
	return _fastReflection_MsgInitProverResponse_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgInitProverResponse) New() protoreflect.Message {
	return new(fastReflection_MsgInitProverResponse)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgInitProverResponse) Interface() protoreflect.ProtoMessage {
	return (*MsgInitProverResponse)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgInitProverResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Status != false {
		value := protoreflect.ValueOfBool(x.Status)
		if !f(fd_MsgInitProverResponse_status, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgInitProverResponse) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProverResponse.status":
		return x.Status != false
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProverResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProverResponse does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitProverResponse) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProverResponse.status":
		x.Status = false
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProverResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProverResponse does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgInitProverResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgInitProverResponse.status":
		value := x.Status
		return protoreflect.ValueOfBool(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProverResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProverResponse does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitProverResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProverResponse.status":
		x.Status = value.Bool()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProverResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProverResponse does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitProverResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProverResponse.status":
		panic(fmt.Errorf("field status of message junction.rollup.MsgInitProverResponse is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProverResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProverResponse does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgInitProverResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgInitProverResponse.status":
		return protoreflect.ValueOfBool(false)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgInitProverResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgInitProverResponse does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgInitProverResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgInitProverResponse", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgInitProverResponse) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgInitProverResponse) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgInitProverResponse) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgInitProverResponse) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgInitProverResponse)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Status {
			n += 2
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgInitProverResponse)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Status {
			i--
			if x.Status {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgInitProverResponse)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitProverResponse: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitProverResponse: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
				}
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Status = bool(v != 0)
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_MsgSubmitBatchMetadata              protoreflect.MessageDescriptor
	fd_MsgSubmitBatchMetadata_creator      protoreflect.FieldDescriptor
	fd_MsgSubmitBatchMetadata_batchNo      protoreflect.FieldDescriptor
	fd_MsgSubmitBatchMetadata_rollupId     protoreflect.FieldDescriptor
	fd_MsgSubmitBatchMetadata_daName       protoreflect.FieldDescriptor
	fd_MsgSubmitBatchMetadata_daCommitment protoreflect.FieldDescriptor
	fd_MsgSubmitBatchMetadata_daHash       protoreflect.FieldDescriptor
	fd_MsgSubmitBatchMetadata_daPointer    protoreflect.FieldDescriptor
	fd_MsgSubmitBatchMetadata_daNamespace  protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgSubmitBatchMetadata = File_junction_rollup_tx_proto.Messages().ByName("MsgSubmitBatchMetadata")
	fd_MsgSubmitBatchMetadata_creator = md_MsgSubmitBatchMetadata.Fields().ByName("creator")
	fd_MsgSubmitBatchMetadata_batchNo = md_MsgSubmitBatchMetadata.Fields().ByName("batchNo")
	fd_MsgSubmitBatchMetadata_rollupId = md_MsgSubmitBatchMetadata.Fields().ByName("rollupId")
	fd_MsgSubmitBatchMetadata_daName = md_MsgSubmitBatchMetadata.Fields().ByName("daName")
	fd_MsgSubmitBatchMetadata_daCommitment = md_MsgSubmitBatchMetadata.Fields().ByName("daCommitment")
	fd_MsgSubmitBatchMetadata_daHash = md_MsgSubmitBatchMetadata.Fields().ByName("daHash")
	fd_MsgSubmitBatchMetadata_daPointer = md_MsgSubmitBatchMetadata.Fields().ByName("daPointer")
	fd_MsgSubmitBatchMetadata_daNamespace = md_MsgSubmitBatchMetadata.Fields().ByName("daNamespace")
}

var _ protoreflect.Message = (*fastReflection_MsgSubmitBatchMetadata)(nil)

type fastReflection_MsgSubmitBatchMetadata MsgSubmitBatchMetadata

func (x *MsgSubmitBatchMetadata) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgSubmitBatchMetadata)(x)
}

func (x *MsgSubmitBatchMetadata) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[6]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgSubmitBatchMetadata_messageType fastReflection_MsgSubmitBatchMetadata_messageType
var _ protoreflect.MessageType = fastReflection_MsgSubmitBatchMetadata_messageType{}

type fastReflection_MsgSubmitBatchMetadata_messageType struct{}

func (x fastReflection_MsgSubmitBatchMetadata_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgSubmitBatchMetadata)(nil)
}
func (x fastReflection_MsgSubmitBatchMetadata_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgSubmitBatchMetadata)
}
func (x fastReflection_MsgSubmitBatchMetadata_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgSubmitBatchMetadata
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgSubmitBatchMetadata) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgSubmitBatchMetadata
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgSubmitBatchMetadata) Type() protoreflect.MessageType {
	return _fastReflection_MsgSubmitBatchMetadata_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgSubmitBatchMetadata) New() protoreflect.Message {
	return new(fastReflection_MsgSubmitBatchMetadata)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgSubmitBatchMetadata) Interface() protoreflect.ProtoMessage {
	return (*MsgSubmitBatchMetadata)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgSubmitBatchMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Creator != "" {
		value := protoreflect.ValueOfString(x.Creator)
		if !f(fd_MsgSubmitBatchMetadata_creator, value) {
			return
		}
	}
	if x.BatchNo != uint64(0) {
		value := protoreflect.ValueOfUint64(x.BatchNo)
		if !f(fd_MsgSubmitBatchMetadata_batchNo, value) {
			return
		}
	}
	if x.RollupId != "" {
		value := protoreflect.ValueOfString(x.RollupId)
		if !f(fd_MsgSubmitBatchMetadata_rollupId, value) {
			return
		}
	}
	if x.DaName != "" {
		value := protoreflect.ValueOfString(x.DaName)
		if !f(fd_MsgSubmitBatchMetadata_daName, value) {
			return
		}
	}
	if x.DaCommitment != "" {
		value := protoreflect.ValueOfString(x.DaCommitment)
		if !f(fd_MsgSubmitBatchMetadata_daCommitment, value) {
			return
		}
	}
	if x.DaHash != "" {
		value := protoreflect.ValueOfString(x.DaHash)
		if !f(fd_MsgSubmitBatchMetadata_daHash, value) {
			return
		}
	}
	if x.DaPointer != "" {
		value := protoreflect.ValueOfString(x.DaPointer)
		if !f(fd_MsgSubmitBatchMetadata_daPointer, value) {
			return
		}
	}
	if x.DaNamespace != "" {
		value := protoreflect.ValueOfString(x.DaNamespace)
		if !f(fd_MsgSubmitBatchMetadata_daNamespace, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgSubmitBatchMetadata) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadata.creator":
		return x.Creator != ""
	case "junction.rollup.MsgSubmitBatchMetadata.batchNo":
		return x.BatchNo != uint64(0)
	case "junction.rollup.MsgSubmitBatchMetadata.rollupId":
		return x.RollupId != ""
	case "junction.rollup.MsgSubmitBatchMetadata.daName":
		return x.DaName != ""
	case "junction.rollup.MsgSubmitBatchMetadata.daCommitment":
		return x.DaCommitment != ""
	case "junction.rollup.MsgSubmitBatchMetadata.daHash":
		return x.DaHash != ""
	case "junction.rollup.MsgSubmitBatchMetadata.daPointer":
		return x.DaPointer != ""
	case "junction.rollup.MsgSubmitBatchMetadata.daNamespace":
		return x.DaNamespace != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadata"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadata does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchMetadata) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadata.creator":
		x.Creator = ""
	case "junction.rollup.MsgSubmitBatchMetadata.batchNo":
		x.BatchNo = uint64(0)
	case "junction.rollup.MsgSubmitBatchMetadata.rollupId":
		x.RollupId = ""
	case "junction.rollup.MsgSubmitBatchMetadata.daName":
		x.DaName = ""
	case "junction.rollup.MsgSubmitBatchMetadata.daCommitment":
		x.DaCommitment = ""
	case "junction.rollup.MsgSubmitBatchMetadata.daHash":
		x.DaHash = ""
	case "junction.rollup.MsgSubmitBatchMetadata.daPointer":
		x.DaPointer = ""
	case "junction.rollup.MsgSubmitBatchMetadata.daNamespace":
		x.DaNamespace = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadata"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadata does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgSubmitBatchMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadata.creator":
		value := x.Creator
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatchMetadata.batchNo":
		value := x.BatchNo
		return protoreflect.ValueOfUint64(value)
	case "junction.rollup.MsgSubmitBatchMetadata.rollupId":
		value := x.RollupId
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatchMetadata.daName":
		value := x.DaName
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatchMetadata.daCommitment":
		value := x.DaCommitment
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatchMetadata.daHash":
		value := x.DaHash
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatchMetadata.daPointer":
		value := x.DaPointer
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatchMetadata.daNamespace":
		value := x.DaNamespace
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadata"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadata does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadata.creator":
		x.Creator = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatchMetadata.batchNo":
		x.BatchNo = value.Uint()
	case "junction.rollup.MsgSubmitBatchMetadata.rollupId":
		x.RollupId = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatchMetadata.daName":
		x.DaName = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatchMetadata.daCommitment":
		x.DaCommitment = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatchMetadata.daHash":
		x.DaHash = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatchMetadata.daPointer":
		x.DaPointer = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatchMetadata.daNamespace":
		x.DaNamespace = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadata"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadata does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadata.creator":
		panic(fmt.Errorf("field creator of message junction.rollup.MsgSubmitBatchMetadata is not mutable"))
	case "junction.rollup.MsgSubmitBatchMetadata.batchNo":
		panic(fmt.Errorf("field batchNo of message junction.rollup.MsgSubmitBatchMetadata is not mutable"))
	case "junction.rollup.MsgSubmitBatchMetadata.rollupId":
		panic(fmt.Errorf("field rollupId of message junction.rollup.MsgSubmitBatchMetadata is not mutable"))
	case "junction.rollup.MsgSubmitBatchMetadata.daName":
		panic(fmt.Errorf("field daName of message junction.rollup.MsgSubmitBatchMetadata is not mutable"))
	case "junction.rollup.MsgSubmitBatchMetadata.daCommitment":
		panic(fmt.Errorf("field daCommitment of message junction.rollup.MsgSubmitBatchMetadata is not mutable"))
	case "junction.rollup.MsgSubmitBatchMetadata.daHash":
		panic(fmt.Errorf("field daHash of message junction.rollup.MsgSubmitBatchMetadata is not mutable"))
	case "junction.rollup.MsgSubmitBatchMetadata.daPointer":
		panic(fmt.Errorf("field daPointer of message junction.rollup.MsgSubmitBatchMetadata is not mutable"))
	case "junction.rollup.MsgSubmitBatchMetadata.daNamespace":
		panic(fmt.Errorf("field daNamespace of message junction.rollup.MsgSubmitBatchMetadata is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadata"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadata does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgSubmitBatchMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadata.creator":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatchMetadata.batchNo":
		return protoreflect.ValueOfUint64(uint64(0))
	case "junction.rollup.MsgSubmitBatchMetadata.rollupId":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatchMetadata.daName":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatchMetadata.daCommitment":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatchMetadata.daHash":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatchMetadata.daPointer":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatchMetadata.daNamespace":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadata"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadata does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgSubmitBatchMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgSubmitBatchMetadata", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgSubmitBatchMetadata) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchMetadata) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgSubmitBatchMetadata) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgSubmitBatchMetadata) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgSubmitBatchMetadata)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Creator)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.BatchNo != 0 {
			n += 1 + runtime.Sov(uint64(x.BatchNo))
		}
		l = len(x.RollupId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.DaName)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.DaCommitment)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.DaHash)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.DaPointer)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.DaNamespace)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgSubmitBatchMetadata)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.DaNamespace) > 0 {
			i -= len(x.DaNamespace)
			copy(dAtA[i:], x.DaNamespace)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DaNamespace)))
			i--
			dAtA[i] = 0x42
		}
		if len(x.DaPointer) > 0 {
			i -= len(x.DaPointer)
			copy(dAtA[i:], x.DaPointer)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DaPointer)))
			i--
			dAtA[i] = 0x3a
		}
		if len(x.DaHash) > 0 {
			i -= len(x.DaHash)
			copy(dAtA[i:], x.DaHash)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DaHash)))
			i--
			dAtA[i] = 0x32
		}
		if len(x.DaCommitment) > 0 {
			i -= len(x.DaCommitment)
			copy(dAtA[i:], x.DaCommitment)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DaCommitment)))
			i--
			dAtA[i] = 0x2a
		}
		if len(x.DaName) > 0 {
			i -= len(x.DaName)
			copy(dAtA[i:], x.DaName)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DaName)))
			i--
			dAtA[i] = 0x22
		}
		if len(x.RollupId) > 0 {
			i -= len(x.RollupId)
			copy(dAtA[i:], x.RollupId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RollupId)))
			i--
			dAtA[i] = 0x1a
		}
		if x.BatchNo != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.BatchNo))
			i--
			dAtA[i] = 0x10
		}
		if len(x.Creator) > 0 {
			i -= len(x.Creator)
			copy(dAtA[i:], x.Creator)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgSubmitBatchMetadata)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitBatchMetadata: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitBatchMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Creator = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BatchNo", wireType)
				}
				x.BatchNo = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.BatchNo |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RollupId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.RollupId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DaName", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.DaName = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DaCommitment", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.DaCommitment = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 6:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DaHash", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.DaHash = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DaPointer", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.DaPointer = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DaNamespace", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.DaNamespace = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_MsgSubmitBatchMetadataResponse        protoreflect.MessageDescriptor
	fd_MsgSubmitBatchMetadataResponse_status protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgSubmitBatchMetadataResponse = File_junction_rollup_tx_proto.Messages().ByName("MsgSubmitBatchMetadataResponse")
	fd_MsgSubmitBatchMetadataResponse_status = md_MsgSubmitBatchMetadataResponse.Fields().ByName("status")
}

var _ protoreflect.Message = (*fastReflection_MsgSubmitBatchMetadataResponse)(nil)

type fastReflection_MsgSubmitBatchMetadataResponse MsgSubmitBatchMetadataResponse

func (x *MsgSubmitBatchMetadataResponse) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgSubmitBatchMetadataResponse)(x)
}

func (x *MsgSubmitBatchMetadataResponse) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[7]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgSubmitBatchMetadataResponse_messageType fastReflection_MsgSubmitBatchMetadataResponse_messageType
var _ protoreflect.MessageType = fastReflection_MsgSubmitBatchMetadataResponse_messageType{}

type fastReflection_MsgSubmitBatchMetadataResponse_messageType struct{}

func (x fastReflection_MsgSubmitBatchMetadataResponse_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgSubmitBatchMetadataResponse)(nil)
}
func (x fastReflection_MsgSubmitBatchMetadataResponse_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgSubmitBatchMetadataResponse)
}
func (x fastReflection_MsgSubmitBatchMetadataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgSubmitBatchMetadataResponse
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgSubmitBatchMetadataResponse
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Type() protoreflect.MessageType {
	return _fastReflection_MsgSubmitBatchMetadataResponse_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) New() protoreflect.Message {
	return new(fastReflection_MsgSubmitBatchMetadataResponse)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Interface() protoreflect.ProtoMessage {
	return (*MsgSubmitBatchMetadataResponse)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Status != false {
		value := protoreflect.ValueOfBool(x.Status)
		if !f(fd_MsgSubmitBatchMetadataResponse_status, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadataResponse.status":
		return x.Status != false
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadataResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadataResponse does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadataResponse.status":
		x.Status = false
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadataResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadataResponse does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadataResponse.status":
		value := x.Status
		return protoreflect.ValueOfBool(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadataResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadataResponse does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadataResponse.status":
		x.Status = value.Bool()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadataResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadataResponse does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadataResponse.status":
		panic(fmt.Errorf("field status of message junction.rollup.MsgSubmitBatchMetadataResponse is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadataResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadataResponse does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchMetadataResponse.status":
		return protoreflect.ValueOfBool(false)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchMetadataResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchMetadataResponse does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgSubmitBatchMetadataResponse", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgSubmitBatchMetadataResponse) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgSubmitBatchMetadataResponse)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Status {
			n += 2
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgSubmitBatchMetadataResponse)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Status {
			i--
			if x.Status {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgSubmitBatchMetadataResponse)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitBatchMetadataResponse: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitBatchMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
				}
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Status = bool(v != 0)
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_MsgSubmitBatch                        protoreflect.MessageDescriptor
	fd_MsgSubmitBatch_creator                protoreflect.FieldDescriptor
	fd_MsgSubmitBatch_rollupId               protoreflect.FieldDescriptor
	fd_MsgSubmitBatch_batchNo                protoreflect.FieldDescriptor
	fd_MsgSubmitBatch_merkleRootHash         protoreflect.FieldDescriptor
	fd_MsgSubmitBatch_previousMerkleRootHash protoreflect.FieldDescriptor
	fd_MsgSubmitBatch_zkProof                protoreflect.FieldDescriptor
	fd_MsgSubmitBatch_publicWitness          protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgSubmitBatch = File_junction_rollup_tx_proto.Messages().ByName("MsgSubmitBatch")
	fd_MsgSubmitBatch_creator = md_MsgSubmitBatch.Fields().ByName("creator")
	fd_MsgSubmitBatch_rollupId = md_MsgSubmitBatch.Fields().ByName("rollupId")
	fd_MsgSubmitBatch_batchNo = md_MsgSubmitBatch.Fields().ByName("batchNo")
	fd_MsgSubmitBatch_merkleRootHash = md_MsgSubmitBatch.Fields().ByName("merkleRootHash")
	fd_MsgSubmitBatch_previousMerkleRootHash = md_MsgSubmitBatch.Fields().ByName("previousMerkleRootHash")
	fd_MsgSubmitBatch_zkProof = md_MsgSubmitBatch.Fields().ByName("zkProof")
	fd_MsgSubmitBatch_publicWitness = md_MsgSubmitBatch.Fields().ByName("publicWitness")
}

var _ protoreflect.Message = (*fastReflection_MsgSubmitBatch)(nil)

type fastReflection_MsgSubmitBatch MsgSubmitBatch

func (x *MsgSubmitBatch) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgSubmitBatch)(x)
}

func (x *MsgSubmitBatch) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[8]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgSubmitBatch_messageType fastReflection_MsgSubmitBatch_messageType
var _ protoreflect.MessageType = fastReflection_MsgSubmitBatch_messageType{}

type fastReflection_MsgSubmitBatch_messageType struct{}

func (x fastReflection_MsgSubmitBatch_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgSubmitBatch)(nil)
}
func (x fastReflection_MsgSubmitBatch_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgSubmitBatch)
}
func (x fastReflection_MsgSubmitBatch_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgSubmitBatch
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgSubmitBatch) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgSubmitBatch
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgSubmitBatch) Type() protoreflect.MessageType {
	return _fastReflection_MsgSubmitBatch_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgSubmitBatch) New() protoreflect.Message {
	return new(fastReflection_MsgSubmitBatch)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgSubmitBatch) Interface() protoreflect.ProtoMessage {
	return (*MsgSubmitBatch)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgSubmitBatch) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Creator != "" {
		value := protoreflect.ValueOfString(x.Creator)
		if !f(fd_MsgSubmitBatch_creator, value) {
			return
		}
	}
	if x.RollupId != "" {
		value := protoreflect.ValueOfString(x.RollupId)
		if !f(fd_MsgSubmitBatch_rollupId, value) {
			return
		}
	}
	if x.BatchNo != uint64(0) {
		value := protoreflect.ValueOfUint64(x.BatchNo)
		if !f(fd_MsgSubmitBatch_batchNo, value) {
			return
		}
	}
	if x.MerkleRootHash != "" {
		value := protoreflect.ValueOfString(x.MerkleRootHash)
		if !f(fd_MsgSubmitBatch_merkleRootHash, value) {
			return
		}
	}
	if x.PreviousMerkleRootHash != "" {
		value := protoreflect.ValueOfString(x.PreviousMerkleRootHash)
		if !f(fd_MsgSubmitBatch_previousMerkleRootHash, value) {
			return
		}
	}
	if len(x.ZkProof) != 0 {
		value := protoreflect.ValueOfBytes(x.ZkProof)
		if !f(fd_MsgSubmitBatch_zkProof, value) {
			return
		}
	}
	if len(x.PublicWitness) != 0 {
		value := protoreflect.ValueOfBytes(x.PublicWitness)
		if !f(fd_MsgSubmitBatch_publicWitness, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgSubmitBatch) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatch.creator":
		return x.Creator != ""
	case "junction.rollup.MsgSubmitBatch.rollupId":
		return x.RollupId != ""
	case "junction.rollup.MsgSubmitBatch.batchNo":
		return x.BatchNo != uint64(0)
	case "junction.rollup.MsgSubmitBatch.merkleRootHash":
		return x.MerkleRootHash != ""
	case "junction.rollup.MsgSubmitBatch.previousMerkleRootHash":
		return x.PreviousMerkleRootHash != ""
	case "junction.rollup.MsgSubmitBatch.zkProof":
		return len(x.ZkProof) != 0
	case "junction.rollup.MsgSubmitBatch.publicWitness":
		return len(x.PublicWitness) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatch"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatch does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatch) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatch.creator":
		x.Creator = ""
	case "junction.rollup.MsgSubmitBatch.rollupId":
		x.RollupId = ""
	case "junction.rollup.MsgSubmitBatch.batchNo":
		x.BatchNo = uint64(0)
	case "junction.rollup.MsgSubmitBatch.merkleRootHash":
		x.MerkleRootHash = ""
	case "junction.rollup.MsgSubmitBatch.previousMerkleRootHash":
		x.PreviousMerkleRootHash = ""
	case "junction.rollup.MsgSubmitBatch.zkProof":
		x.ZkProof = nil
	case "junction.rollup.MsgSubmitBatch.publicWitness":
		x.PublicWitness = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatch"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatch does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgSubmitBatch) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgSubmitBatch.creator":
		value := x.Creator
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatch.rollupId":
		value := x.RollupId
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatch.batchNo":
		value := x.BatchNo
		return protoreflect.ValueOfUint64(value)
	case "junction.rollup.MsgSubmitBatch.merkleRootHash":
		value := x.MerkleRootHash
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatch.previousMerkleRootHash":
		value := x.PreviousMerkleRootHash
		return protoreflect.ValueOfString(value)
	case "junction.rollup.MsgSubmitBatch.zkProof":
		value := x.ZkProof
		return protoreflect.ValueOfBytes(value)
	case "junction.rollup.MsgSubmitBatch.publicWitness":
		value := x.PublicWitness
		return protoreflect.ValueOfBytes(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatch"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatch does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatch) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatch.creator":
		x.Creator = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatch.rollupId":
		x.RollupId = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatch.batchNo":
		x.BatchNo = value.Uint()
	case "junction.rollup.MsgSubmitBatch.merkleRootHash":
		x.MerkleRootHash = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatch.previousMerkleRootHash":
		x.PreviousMerkleRootHash = value.Interface().(string)
	case "junction.rollup.MsgSubmitBatch.zkProof":
		x.ZkProof = value.Bytes()
	case "junction.rollup.MsgSubmitBatch.publicWitness":
		x.PublicWitness = value.Bytes()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatch"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatch does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatch) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatch.creator":
		panic(fmt.Errorf("field creator of message junction.rollup.MsgSubmitBatch is not mutable"))
	case "junction.rollup.MsgSubmitBatch.rollupId":
		panic(fmt.Errorf("field rollupId of message junction.rollup.MsgSubmitBatch is not mutable"))
	case "junction.rollup.MsgSubmitBatch.batchNo":
		panic(fmt.Errorf("field batchNo of message junction.rollup.MsgSubmitBatch is not mutable"))
	case "junction.rollup.MsgSubmitBatch.merkleRootHash":
		panic(fmt.Errorf("field merkleRootHash of message junction.rollup.MsgSubmitBatch is not mutable"))
	case "junction.rollup.MsgSubmitBatch.previousMerkleRootHash":
		panic(fmt.Errorf("field previousMerkleRootHash of message junction.rollup.MsgSubmitBatch is not mutable"))
	case "junction.rollup.MsgSubmitBatch.zkProof":
		panic(fmt.Errorf("field zkProof of message junction.rollup.MsgSubmitBatch is not mutable"))
	case "junction.rollup.MsgSubmitBatch.publicWitness":
		panic(fmt.Errorf("field publicWitness of message junction.rollup.MsgSubmitBatch is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatch"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatch does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgSubmitBatch) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatch.creator":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatch.rollupId":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatch.batchNo":
		return protoreflect.ValueOfUint64(uint64(0))
	case "junction.rollup.MsgSubmitBatch.merkleRootHash":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatch.previousMerkleRootHash":
		return protoreflect.ValueOfString("")
	case "junction.rollup.MsgSubmitBatch.zkProof":
		return protoreflect.ValueOfBytes(nil)
	case "junction.rollup.MsgSubmitBatch.publicWitness":
		return protoreflect.ValueOfBytes(nil)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatch"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatch does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgSubmitBatch) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgSubmitBatch", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgSubmitBatch) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatch) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgSubmitBatch) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgSubmitBatch) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgSubmitBatch)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Creator)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.RollupId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.BatchNo != 0 {
			n += 1 + runtime.Sov(uint64(x.BatchNo))
		}
		l = len(x.MerkleRootHash)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.PreviousMerkleRootHash)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.ZkProof)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.PublicWitness)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgSubmitBatch)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.PublicWitness) > 0 {
			i -= len(x.PublicWitness)
			copy(dAtA[i:], x.PublicWitness)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PublicWitness)))
			i--
			dAtA[i] = 0x3a
		}
		if len(x.ZkProof) > 0 {
			i -= len(x.ZkProof)
			copy(dAtA[i:], x.ZkProof)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ZkProof)))
			i--
			dAtA[i] = 0x32
		}
		if len(x.PreviousMerkleRootHash) > 0 {
			i -= len(x.PreviousMerkleRootHash)
			copy(dAtA[i:], x.PreviousMerkleRootHash)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PreviousMerkleRootHash)))
			i--
			dAtA[i] = 0x2a
		}
		if len(x.MerkleRootHash) > 0 {
			i -= len(x.MerkleRootHash)
			copy(dAtA[i:], x.MerkleRootHash)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MerkleRootHash)))
			i--
			dAtA[i] = 0x22
		}
		if x.BatchNo != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.BatchNo))
			i--
			dAtA[i] = 0x18
		}
		if len(x.RollupId) > 0 {
			i -= len(x.RollupId)
			copy(dAtA[i:], x.RollupId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RollupId)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Creator) > 0 {
			i -= len(x.Creator)
			copy(dAtA[i:], x.Creator)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgSubmitBatch)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitBatch: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitBatch: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Creator = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RollupId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.RollupId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BatchNo", wireType)
				}
				x.BatchNo = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.BatchNo |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MerkleRootHash", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.MerkleRootHash = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PreviousMerkleRootHash", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.PreviousMerkleRootHash = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 6:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ZkProof", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.ZkProof = append(x.ZkProof[:0], dAtA[iNdEx:postIndex]...)
				if x.ZkProof == nil {
					x.ZkProof = []byte{}
				}
				iNdEx = postIndex
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PublicWitness", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.PublicWitness = append(x.PublicWitness[:0], dAtA[iNdEx:postIndex]...)
				if x.PublicWitness == nil {
					x.PublicWitness = []byte{}
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_MsgSubmitBatchResponse        protoreflect.MessageDescriptor
	fd_MsgSubmitBatchResponse_status protoreflect.FieldDescriptor
)

func init() {
	file_junction_rollup_tx_proto_init()
	md_MsgSubmitBatchResponse = File_junction_rollup_tx_proto.Messages().ByName("MsgSubmitBatchResponse")
	fd_MsgSubmitBatchResponse_status = md_MsgSubmitBatchResponse.Fields().ByName("status")
}

var _ protoreflect.Message = (*fastReflection_MsgSubmitBatchResponse)(nil)

type fastReflection_MsgSubmitBatchResponse MsgSubmitBatchResponse

func (x *MsgSubmitBatchResponse) ProtoReflect() protoreflect.Message {
	return (*fastReflection_MsgSubmitBatchResponse)(x)
}

func (x *MsgSubmitBatchResponse) slowProtoReflect() protoreflect.Message {
	mi := &file_junction_rollup_tx_proto_msgTypes[9]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_MsgSubmitBatchResponse_messageType fastReflection_MsgSubmitBatchResponse_messageType
var _ protoreflect.MessageType = fastReflection_MsgSubmitBatchResponse_messageType{}

type fastReflection_MsgSubmitBatchResponse_messageType struct{}

func (x fastReflection_MsgSubmitBatchResponse_messageType) Zero() protoreflect.Message {
	return (*fastReflection_MsgSubmitBatchResponse)(nil)
}
func (x fastReflection_MsgSubmitBatchResponse_messageType) New() protoreflect.Message {
	return new(fastReflection_MsgSubmitBatchResponse)
}
func (x fastReflection_MsgSubmitBatchResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgSubmitBatchResponse
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_MsgSubmitBatchResponse) Descriptor() protoreflect.MessageDescriptor {
	return md_MsgSubmitBatchResponse
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_MsgSubmitBatchResponse) Type() protoreflect.MessageType {
	return _fastReflection_MsgSubmitBatchResponse_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_MsgSubmitBatchResponse) New() protoreflect.Message {
	return new(fastReflection_MsgSubmitBatchResponse)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_MsgSubmitBatchResponse) Interface() protoreflect.ProtoMessage {
	return (*MsgSubmitBatchResponse)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_MsgSubmitBatchResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Status != false {
		value := protoreflect.ValueOfBool(x.Status)
		if !f(fd_MsgSubmitBatchResponse_status, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_MsgSubmitBatchResponse) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchResponse.status":
		return x.Status != false
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchResponse does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchResponse) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchResponse.status":
		x.Status = false
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchResponse does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_MsgSubmitBatchResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "junction.rollup.MsgSubmitBatchResponse.status":
		value := x.Status
		return protoreflect.ValueOfBool(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchResponse does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchResponse.status":
		x.Status = value.Bool()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchResponse does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchResponse.status":
		panic(fmt.Errorf("field status of message junction.rollup.MsgSubmitBatchResponse is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchResponse does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_MsgSubmitBatchResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "junction.rollup.MsgSubmitBatchResponse.status":
		return protoreflect.ValueOfBool(false)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: junction.rollup.MsgSubmitBatchResponse"))
		}
		panic(fmt.Errorf("message junction.rollup.MsgSubmitBatchResponse does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_MsgSubmitBatchResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in junction.rollup.MsgSubmitBatchResponse", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_MsgSubmitBatchResponse) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_MsgSubmitBatchResponse) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_MsgSubmitBatchResponse) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_MsgSubmitBatchResponse) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*MsgSubmitBatchResponse)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Status {
			n += 2
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*MsgSubmitBatchResponse)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Status {
			i--
			if x.Status {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*MsgSubmitBatchResponse)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitBatchResponse: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
				}
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Status = bool(v != 0)
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.27.0
// 	protoc        (unknown)
// source: junction/rollup/tx.proto

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// MsgUpdateParams is the Msg/UpdateParams request type.
type MsgUpdateParams struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// 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,omitempty"`
}

func (x *MsgUpdateParams) Reset() {
	*x = MsgUpdateParams{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgUpdateParams) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgUpdateParams) ProtoMessage() {}

// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead.
func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{0}
}

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

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

// MsgUpdateParamsResponse defines the response structure for executing a
// MsgUpdateParams message.
type MsgUpdateParamsResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
}

func (x *MsgUpdateParamsResponse) Reset() {
	*x = MsgUpdateParamsResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgUpdateParamsResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgUpdateParamsResponse) ProtoMessage() {}

// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead.
func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{1}
}

type MsgInitRollup struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	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 (x *MsgInitRollup) Reset() {
	*x = MsgInitRollup{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgInitRollup) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgInitRollup) ProtoMessage() {}

// Deprecated: Use MsgInitRollup.ProtoReflect.Descriptor instead.
func (*MsgInitRollup) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{2}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type MsgInitRollupResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	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 (x *MsgInitRollupResponse) Reset() {
	*x = MsgInitRollupResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgInitRollupResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgInitRollupResponse) ProtoMessage() {}

// Deprecated: Use MsgInitRollupResponse.ProtoReflect.Descriptor instead.
func (*MsgInitRollupResponse) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{3}
}

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

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

type MsgInitProver struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	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 (x *MsgInitProver) Reset() {
	*x = MsgInitProver{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgInitProver) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgInitProver) ProtoMessage() {}

// Deprecated: Use MsgInitProver.ProtoReflect.Descriptor instead.
func (*MsgInitProver) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{4}
}

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

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

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

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

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

type MsgInitProverResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

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

func (x *MsgInitProverResponse) Reset() {
	*x = MsgInitProverResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[5]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgInitProverResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgInitProverResponse) ProtoMessage() {}

// Deprecated: Use MsgInitProverResponse.ProtoReflect.Descriptor instead.
func (*MsgInitProverResponse) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{5}
}

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

type MsgSubmitBatchMetadata struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	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 (x *MsgSubmitBatchMetadata) Reset() {
	*x = MsgSubmitBatchMetadata{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[6]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgSubmitBatchMetadata) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgSubmitBatchMetadata) ProtoMessage() {}

// Deprecated: Use MsgSubmitBatchMetadata.ProtoReflect.Descriptor instead.
func (*MsgSubmitBatchMetadata) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{6}
}

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

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

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

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

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

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

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

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

type MsgSubmitBatchMetadataResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

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

func (x *MsgSubmitBatchMetadataResponse) Reset() {
	*x = MsgSubmitBatchMetadataResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[7]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgSubmitBatchMetadataResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgSubmitBatchMetadataResponse) ProtoMessage() {}

// Deprecated: Use MsgSubmitBatchMetadataResponse.ProtoReflect.Descriptor instead.
func (*MsgSubmitBatchMetadataResponse) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{7}
}

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

type MsgSubmitBatch struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	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 (x *MsgSubmitBatch) Reset() {
	*x = MsgSubmitBatch{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[8]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgSubmitBatch) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgSubmitBatch) ProtoMessage() {}

// Deprecated: Use MsgSubmitBatch.ProtoReflect.Descriptor instead.
func (*MsgSubmitBatch) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{8}
}

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

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

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

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

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

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

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

type MsgSubmitBatchResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

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

func (x *MsgSubmitBatchResponse) Reset() {
	*x = MsgSubmitBatchResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_junction_rollup_tx_proto_msgTypes[9]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MsgSubmitBatchResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MsgSubmitBatchResponse) ProtoMessage() {}

// Deprecated: Use MsgSubmitBatchResponse.ProtoReflect.Descriptor instead.
func (*MsgSubmitBatchResponse) Descriptor() ([]byte, []int) {
	return file_junction_rollup_tx_proto_rawDescGZIP(), []int{9}
}

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

var File_junction_rollup_tx_proto protoreflect.FileDescriptor

var file_junction_rollup_tx_proto_rawDesc = []byte{
	0x0a, 0x18, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x72, 0x6f, 0x6c, 0x6c, 0x75,
	0x70, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x6a, 0x75, 0x6e, 0x63,
	0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x1a, 0x11, 0x61, 0x6d, 0x69,
	0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17,
	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73,
	0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f,
	0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69,
	0x6f, 0x6e, 0x2f, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73,
	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62,
	0x61, 0x73, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x69, 0x6e,
	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xbb, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, 0x70,
	0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75,
	0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2,
	0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
	0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69,
	0x74, 0x79, 0x12, 0x3a, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x72, 0x6f,
	0x6c, 0x6c, 0x75, 0x70, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde, 0x1f,
	0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x34,
	0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7,
	0xb0, 0x2a, 0x21, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, 0x2f, 0x72, 0x6f,
	0x6c, 0x6c, 0x75, 0x70, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61,
	0x72, 0x61, 0x6d, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74,
	0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
	0x9f, 0x04, 0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x75,
	0x70, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01,
	0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d,
	0x6f, 0x6e, 0x69, 0x6b, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f,
	0x6e, 0x69, 0x6b, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64,
	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12,
	0x1c, 0x0a, 0x09, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01,
	0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a,
	0x06, 0x64, 0x61, 0x54, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64,
	0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x06, 0x20,
	0x03, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x75, 0x70,
	0x70, 0x6c, 0x79, 0x18, 0x07, 0x20, 0x03, 0x28, 0x04, 0x52, 0x06, 0x73, 0x75, 0x70, 0x70, 0x6c,
	0x79, 0x12, 0x2e, 0x0a, 0x12, 0x61, 0x63, 0x6c, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74,
	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x61,
	0x63, 0x6c, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
	0x73, 0x12, 0x2e, 0x0a, 0x12, 0x6b, 0x6d, 0x73, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x65, 0x72,
	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6b,
	0x6d, 0x73, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
	0x73, 0x12, 0x30, 0x0a, 0x13, 0x74, 0x66, 0x68, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f,
	0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13,
	0x74, 0x66, 0x68, 0x65, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72,
	0x65, 0x73, 0x73, 0x12, 0x36, 0x0a, 0x16, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x43, 0x6f,
	0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x0b, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x16, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x43, 0x6f, 0x6e, 0x74,
	0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2e, 0x0a, 0x12, 0x61,
	0x73, 0x63, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
	0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x61, 0x73, 0x63, 0x43, 0x6f, 0x6e, 0x74,
	0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x28, 0x0a, 0x0f, 0x72,
	0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x47, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x0d,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x47, 0x41, 0x64,
	0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2c, 0x0a, 0x11, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72,
	0x41, 0x53, 0x43, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x11, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x41, 0x53, 0x43, 0x41, 0x64, 0x64, 0x72,
	0x65, 0x73, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
	0x72, 0x22, 0x4b, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x6f, 0x6c, 0x6c,
	0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x6f,
	0x6c, 0x6c, 0x75, 0x70, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x6f,
	0x6c, 0x6c, 0x75, 0x70, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
	0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xd1,
	0x01, 0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x72,
	0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x6f,
	0x6c, 0x6c, 0x75, 0x70, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x6f,
	0x6c, 0x6c, 0x75, 0x70, 0x49, 0x64, 0x12, 0x34, 0x0a, 0x15, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x72,
	0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x18,
	0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x15, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x56, 0x65, 0x72,
	0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x12, 0x1e, 0x0a, 0x0a,
	0x70, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x0a, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x26, 0x0a, 0x0e,
	0x70, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x05,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x45, 0x6e, 0x64, 0x70,
	0x6f, 0x69, 0x6e, 0x74, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74,
	0x6f, 0x72, 0x22, 0x2f, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x50, 0x72, 0x6f,
	0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73,
	0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61,
	0x74, 0x75, 0x73, 0x22, 0x8a, 0x02, 0x0a, 0x16, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69,
	0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x18,
	0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
	0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x74, 0x63,
	0x68, 0x4e, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68,
	0x4e, 0x6f, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x49, 0x64, 0x18, 0x03,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x49, 0x64, 0x12, 0x16,
	0x0a, 0x06, 0x64, 0x61, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
	0x64, 0x61, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x64, 0x61, 0x43, 0x6f, 0x6d, 0x6d,
	0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x61,
	0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x61,
	0x48, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x61, 0x48, 0x61,
	0x73, 0x68, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x18,
	0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x61, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72,
	0x12, 0x20, 0x0a, 0x0b, 0x64, 0x61, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18,
	0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x61, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
	0x63, 0x65, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
	0x22, 0x38, 0x0a, 0x1e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x61, 0x74,
	0x63, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
	0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01,
	0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x8e, 0x02, 0x0a, 0x0e, 0x4d,
	0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x18, 0x0a,
	0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
	0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x6f, 0x6c, 0x6c, 0x75,
	0x70, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x6f, 0x6c, 0x6c, 0x75,
	0x70, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4e, 0x6f, 0x18, 0x03,
	0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4e, 0x6f, 0x12, 0x26, 0x0a,
	0x0e, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x18,
	0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f,
	0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x36, 0x0a, 0x16, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75,
	0x73, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x18,
	0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x4d,
	0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x18, 0x0a,
	0x07, 0x7a, 0x6b, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07,
	0x7a, 0x6b, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x24, 0x0a, 0x0d, 0x70, 0x75, 0x62, 0x6c, 0x69,
	0x63, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d,
	0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x57, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x3a, 0x0c, 0x82,
	0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x30, 0x0a, 0x16, 0x4d,
	0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73,
	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x32, 0xde, 0x03,
	0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x5a, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50,
	0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x20, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
	0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74,
	0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x28, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69,
	0x6f, 0x6e, 0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64,
	0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
	0x65, 0x12, 0x54, 0x0a, 0x0a, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x12,
	0x1e, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75,
	0x70, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x1a,
	0x26, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75,
	0x70, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x52,
	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x54, 0x0a, 0x0a, 0x49, 0x6e, 0x69, 0x74, 0x50,
	0x72, 0x6f, 0x76, 0x65, 0x72, 0x12, 0x1e, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
	0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x50,
	0x72, 0x6f, 0x76, 0x65, 0x72, 0x1a, 0x26, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
	0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x50,
	0x72, 0x6f, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6f, 0x0a,
	0x13, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4d, 0x65, 0x74, 0x61,
	0x64, 0x61, 0x74, 0x61, 0x12, 0x27, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
	0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74,
	0x42, 0x61, 0x74, 0x63, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x2f, 0x2e,
	0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x2e,
	0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4d, 0x65,
	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x57,
	0x0a, 0x0b, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1f, 0x2e,
	0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x2e,
	0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x1a, 0x27,
	0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70,
	0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52,
	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xb6,
	0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
	0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50,
	0x01, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x69,
	0x72, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2d, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2f,
	0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6a, 0x75, 0x6e,
	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x72, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0xa2, 0x02, 0x03, 0x4a,
	0x52, 0x58, 0xaa, 0x02, 0x0f, 0x4a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x6f,
	0x6c, 0x6c, 0x75, 0x70, 0xca, 0x02, 0x0f, 0x4a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5c,
	0x52, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0xe2, 0x02, 0x1b, 0x4a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
	0x6e, 0x5c, 0x52, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x10, 0x4a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3a,
	0x3a, 0x52, 0x6f, 0x6c, 0x6c, 0x75, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_junction_rollup_tx_proto_rawDescOnce sync.Once
	file_junction_rollup_tx_proto_rawDescData = file_junction_rollup_tx_proto_rawDesc
)

func file_junction_rollup_tx_proto_rawDescGZIP() []byte {
	file_junction_rollup_tx_proto_rawDescOnce.Do(func() {
		file_junction_rollup_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_junction_rollup_tx_proto_rawDescData)
	})
	return file_junction_rollup_tx_proto_rawDescData
}

var file_junction_rollup_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
var file_junction_rollup_tx_proto_goTypes = []interface{}{
	(*MsgUpdateParams)(nil),                // 0: junction.rollup.MsgUpdateParams
	(*MsgUpdateParamsResponse)(nil),        // 1: junction.rollup.MsgUpdateParamsResponse
	(*MsgInitRollup)(nil),                  // 2: junction.rollup.MsgInitRollup
	(*MsgInitRollupResponse)(nil),          // 3: junction.rollup.MsgInitRollupResponse
	(*MsgInitProver)(nil),                  // 4: junction.rollup.MsgInitProver
	(*MsgInitProverResponse)(nil),          // 5: junction.rollup.MsgInitProverResponse
	(*MsgSubmitBatchMetadata)(nil),         // 6: junction.rollup.MsgSubmitBatchMetadata
	(*MsgSubmitBatchMetadataResponse)(nil), // 7: junction.rollup.MsgSubmitBatchMetadataResponse
	(*MsgSubmitBatch)(nil),                 // 8: junction.rollup.MsgSubmitBatch
	(*MsgSubmitBatchResponse)(nil),         // 9: junction.rollup.MsgSubmitBatchResponse
	(*Params)(nil),                         // 10: junction.rollup.Params
}
var file_junction_rollup_tx_proto_depIdxs = []int32{
	10, // 0: junction.rollup.MsgUpdateParams.params:type_name -> junction.rollup.Params
	0,  // 1: junction.rollup.Msg.UpdateParams:input_type -> junction.rollup.MsgUpdateParams
	2,  // 2: junction.rollup.Msg.InitRollup:input_type -> junction.rollup.MsgInitRollup
	4,  // 3: junction.rollup.Msg.InitProver:input_type -> junction.rollup.MsgInitProver
	6,  // 4: junction.rollup.Msg.SubmitBatchMetadata:input_type -> junction.rollup.MsgSubmitBatchMetadata
	8,  // 5: junction.rollup.Msg.SubmitBatch:input_type -> junction.rollup.MsgSubmitBatch
	1,  // 6: junction.rollup.Msg.UpdateParams:output_type -> junction.rollup.MsgUpdateParamsResponse
	3,  // 7: junction.rollup.Msg.InitRollup:output_type -> junction.rollup.MsgInitRollupResponse
	5,  // 8: junction.rollup.Msg.InitProver:output_type -> junction.rollup.MsgInitProverResponse
	7,  // 9: junction.rollup.Msg.SubmitBatchMetadata:output_type -> junction.rollup.MsgSubmitBatchMetadataResponse
	9,  // 10: junction.rollup.Msg.SubmitBatch:output_type -> junction.rollup.MsgSubmitBatchResponse
	6,  // [6:11] is the sub-list for method output_type
	1,  // [1:6] is the sub-list for method input_type
	1,  // [1:1] is the sub-list for extension type_name
	1,  // [1:1] is the sub-list for extension extendee
	0,  // [0:1] is the sub-list for field type_name
}

func init() { file_junction_rollup_tx_proto_init() }
func file_junction_rollup_tx_proto_init() {
	if File_junction_rollup_tx_proto != nil {
		return
	}
	file_junction_rollup_params_proto_init()
	if !protoimpl.UnsafeEnabled {
		file_junction_rollup_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgUpdateParams); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgUpdateParamsResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgInitRollup); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgInitRollupResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgInitProver); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgInitProverResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgSubmitBatchMetadata); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgSubmitBatchMetadataResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgSubmitBatch); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_junction_rollup_tx_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*MsgSubmitBatchResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_junction_rollup_tx_proto_rawDesc,
			NumEnums:      0,
			NumMessages:   10,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_junction_rollup_tx_proto_goTypes,
		DependencyIndexes: file_junction_rollup_tx_proto_depIdxs,
		MessageInfos:      file_junction_rollup_tx_proto_msgTypes,
	}.Build()
	File_junction_rollup_tx_proto = out.File
	file_junction_rollup_tx_proto_rawDesc = nil
	file_junction_rollup_tx_proto_goTypes = nil
	file_junction_rollup_tx_proto_depIdxs = nil
}
