diff --git a/api/opinit/ophost/v1/tx.pulsar.go b/api/opinit/ophost/v1/tx.pulsar.go
index d84a4d86..ef9c3b1d 100644
--- a/api/opinit/ophost/v1/tx.pulsar.go
+++ b/api/opinit/ophost/v1/tx.pulsar.go
@@ -9167,6 +9167,992 @@ func (x *fastReflection_MsgUpdateBatchInfoResponse) ProtoMethods() *protoiface.M
 	}
 }
 
+var (
+	md_MsgUpdateMetadata           protoreflect.MessageDescriptor
+	fd_MsgUpdateMetadata_authority protoreflect.FieldDescriptor
+	fd_MsgUpdateMetadata_bridge_id protoreflect.FieldDescriptor
+	fd_MsgUpdateMetadata_metadata  protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_opinit_ophost_v1_tx_proto_init()
+	md_MsgUpdateMetadata = File_opinit_ophost_v1_tx_proto.Messages().ByName("MsgUpdateMetadata")
+	fd_MsgUpdateMetadata_authority = md_MsgUpdateMetadata.Fields().ByName("authority")
+	fd_MsgUpdateMetadata_bridge_id = md_MsgUpdateMetadata.Fields().ByName("bridge_id")
+	fd_MsgUpdateMetadata_metadata = md_MsgUpdateMetadata.Fields().ByName("metadata")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateMetadata)(nil)
+
+type fastReflection_MsgUpdateMetadata MsgUpdateMetadata
+
+func (x *MsgUpdateMetadata) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgUpdateMetadata)(x)
+}
+
+func (x *MsgUpdateMetadata) slowProtoReflect() protoreflect.Message {
+	mi := &file_opinit_ophost_v1_tx_proto_msgTypes[18]
+	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_MsgUpdateMetadata_messageType fastReflection_MsgUpdateMetadata_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateMetadata_messageType{}
+
+type fastReflection_MsgUpdateMetadata_messageType struct{}
+
+func (x fastReflection_MsgUpdateMetadata_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgUpdateMetadata)(nil)
+}
+func (x fastReflection_MsgUpdateMetadata_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgUpdateMetadata)
+}
+func (x fastReflection_MsgUpdateMetadata_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUpdateMetadata
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateMetadata) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUpdateMetadata
+}
+
+// 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_MsgUpdateMetadata) Type() protoreflect.MessageType {
+	return _fastReflection_MsgUpdateMetadata_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateMetadata) New() protoreflect.Message {
+	return new(fastReflection_MsgUpdateMetadata)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateMetadata) Interface() protoreflect.ProtoMessage {
+	return (*MsgUpdateMetadata)(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_MsgUpdateMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgUpdateMetadata_authority, value) {
+			return
+		}
+	}
+	if x.BridgeId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.BridgeId)
+		if !f(fd_MsgUpdateMetadata_bridge_id, value) {
+			return
+		}
+	}
+	if len(x.Metadata) != 0 {
+		value := protoreflect.ValueOfBytes(x.Metadata)
+		if !f(fd_MsgUpdateMetadata_metadata, 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_MsgUpdateMetadata) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadata.authority":
+		return x.Authority != ""
+	case "opinit.ophost.v1.MsgUpdateMetadata.bridge_id":
+		return x.BridgeId != uint64(0)
+	case "opinit.ophost.v1.MsgUpdateMetadata.metadata":
+		return len(x.Metadata) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadata"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadata 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_MsgUpdateMetadata) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadata.authority":
+		x.Authority = ""
+	case "opinit.ophost.v1.MsgUpdateMetadata.bridge_id":
+		x.BridgeId = uint64(0)
+	case "opinit.ophost.v1.MsgUpdateMetadata.metadata":
+		x.Metadata = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadata"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadata 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_MsgUpdateMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadata.authority":
+		value := x.Authority
+		return protoreflect.ValueOfString(value)
+	case "opinit.ophost.v1.MsgUpdateMetadata.bridge_id":
+		value := x.BridgeId
+		return protoreflect.ValueOfUint64(value)
+	case "opinit.ophost.v1.MsgUpdateMetadata.metadata":
+		value := x.Metadata
+		return protoreflect.ValueOfBytes(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadata"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadata 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_MsgUpdateMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadata.authority":
+		x.Authority = value.Interface().(string)
+	case "opinit.ophost.v1.MsgUpdateMetadata.bridge_id":
+		x.BridgeId = value.Uint()
+	case "opinit.ophost.v1.MsgUpdateMetadata.metadata":
+		x.Metadata = value.Bytes()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadata"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadata 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_MsgUpdateMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadata.authority":
+		panic(fmt.Errorf("field authority of message opinit.ophost.v1.MsgUpdateMetadata is not mutable"))
+	case "opinit.ophost.v1.MsgUpdateMetadata.bridge_id":
+		panic(fmt.Errorf("field bridge_id of message opinit.ophost.v1.MsgUpdateMetadata is not mutable"))
+	case "opinit.ophost.v1.MsgUpdateMetadata.metadata":
+		panic(fmt.Errorf("field metadata of message opinit.ophost.v1.MsgUpdateMetadata is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadata"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadata 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_MsgUpdateMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadata.authority":
+		return protoreflect.ValueOfString("")
+	case "opinit.ophost.v1.MsgUpdateMetadata.bridge_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "opinit.ophost.v1.MsgUpdateMetadata.metadata":
+		return protoreflect.ValueOfBytes(nil)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadata"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadata 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_MsgUpdateMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in opinit.ophost.v1.MsgUpdateMetadata", 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_MsgUpdateMetadata) 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_MsgUpdateMetadata) 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_MsgUpdateMetadata) 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_MsgUpdateMetadata) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgUpdateMetadata)
+		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.BridgeId != 0 {
+			n += 1 + runtime.Sov(uint64(x.BridgeId))
+		}
+		l = len(x.Metadata)
+		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().(*MsgUpdateMetadata)
+		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.Metadata) > 0 {
+			i -= len(x.Metadata)
+			copy(dAtA[i:], x.Metadata)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Metadata)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.BridgeId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BridgeId))
+			i--
+			dAtA[i] = 0x10
+		}
+		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().(*MsgUpdateMetadata)
+		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: MsgUpdateMetadata: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateMetadata: 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 != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BridgeId", wireType)
+				}
+				x.BridgeId = 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.BridgeId |= 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 Metadata", 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.Metadata = append(x.Metadata[:0], dAtA[iNdEx:postIndex]...)
+				if x.Metadata == nil {
+					x.Metadata = []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_MsgUpdateMetadataResponse                 protoreflect.MessageDescriptor
+	fd_MsgUpdateMetadataResponse_output_index    protoreflect.FieldDescriptor
+	fd_MsgUpdateMetadataResponse_l2_block_number protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_opinit_ophost_v1_tx_proto_init()
+	md_MsgUpdateMetadataResponse = File_opinit_ophost_v1_tx_proto.Messages().ByName("MsgUpdateMetadataResponse")
+	fd_MsgUpdateMetadataResponse_output_index = md_MsgUpdateMetadataResponse.Fields().ByName("output_index")
+	fd_MsgUpdateMetadataResponse_l2_block_number = md_MsgUpdateMetadataResponse.Fields().ByName("l2_block_number")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgUpdateMetadataResponse)(nil)
+
+type fastReflection_MsgUpdateMetadataResponse MsgUpdateMetadataResponse
+
+func (x *MsgUpdateMetadataResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgUpdateMetadataResponse)(x)
+}
+
+func (x *MsgUpdateMetadataResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_opinit_ophost_v1_tx_proto_msgTypes[19]
+	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_MsgUpdateMetadataResponse_messageType fastReflection_MsgUpdateMetadataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgUpdateMetadataResponse_messageType{}
+
+type fastReflection_MsgUpdateMetadataResponse_messageType struct{}
+
+func (x fastReflection_MsgUpdateMetadataResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgUpdateMetadataResponse)(nil)
+}
+func (x fastReflection_MsgUpdateMetadataResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgUpdateMetadataResponse)
+}
+func (x fastReflection_MsgUpdateMetadataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUpdateMetadataResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgUpdateMetadataResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgUpdateMetadataResponse
+}
+
+// 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_MsgUpdateMetadataResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgUpdateMetadataResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgUpdateMetadataResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgUpdateMetadataResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgUpdateMetadataResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgUpdateMetadataResponse)(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_MsgUpdateMetadataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.OutputIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.OutputIndex)
+		if !f(fd_MsgUpdateMetadataResponse_output_index, value) {
+			return
+		}
+	}
+	if x.L2BlockNumber != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.L2BlockNumber)
+		if !f(fd_MsgUpdateMetadataResponse_l2_block_number, 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_MsgUpdateMetadataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.output_index":
+		return x.OutputIndex != uint64(0)
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.l2_block_number":
+		return x.L2BlockNumber != uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadataResponse"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadataResponse 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_MsgUpdateMetadataResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.output_index":
+		x.OutputIndex = uint64(0)
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.l2_block_number":
+		x.L2BlockNumber = uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadataResponse"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadataResponse 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_MsgUpdateMetadataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.output_index":
+		value := x.OutputIndex
+		return protoreflect.ValueOfUint64(value)
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.l2_block_number":
+		value := x.L2BlockNumber
+		return protoreflect.ValueOfUint64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadataResponse"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadataResponse 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_MsgUpdateMetadataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.output_index":
+		x.OutputIndex = value.Uint()
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.l2_block_number":
+		x.L2BlockNumber = value.Uint()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadataResponse"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadataResponse 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_MsgUpdateMetadataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.output_index":
+		panic(fmt.Errorf("field output_index of message opinit.ophost.v1.MsgUpdateMetadataResponse is not mutable"))
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.l2_block_number":
+		panic(fmt.Errorf("field l2_block_number of message opinit.ophost.v1.MsgUpdateMetadataResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadataResponse"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadataResponse 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_MsgUpdateMetadataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.output_index":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "opinit.ophost.v1.MsgUpdateMetadataResponse.l2_block_number":
+		return protoreflect.ValueOfUint64(uint64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: opinit.ophost.v1.MsgUpdateMetadataResponse"))
+		}
+		panic(fmt.Errorf("message opinit.ophost.v1.MsgUpdateMetadataResponse 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_MsgUpdateMetadataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in opinit.ophost.v1.MsgUpdateMetadataResponse", 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_MsgUpdateMetadataResponse) 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_MsgUpdateMetadataResponse) 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_MsgUpdateMetadataResponse) 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_MsgUpdateMetadataResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgUpdateMetadataResponse)
+		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.OutputIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.OutputIndex))
+		}
+		if x.L2BlockNumber != 0 {
+			n += 1 + runtime.Sov(uint64(x.L2BlockNumber))
+		}
+		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().(*MsgUpdateMetadataResponse)
+		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.L2BlockNumber != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.L2BlockNumber))
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.OutputIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.OutputIndex))
+			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().(*MsgUpdateMetadataResponse)
+		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: MsgUpdateMetadataResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateMetadataResponse: 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 OutputIndex", wireType)
+				}
+				x.OutputIndex = 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.OutputIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field L2BlockNumber", wireType)
+				}
+				x.L2BlockNumber = 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.L2BlockNumber |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			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_MsgUpdateParams           protoreflect.MessageDescriptor
 	fd_MsgUpdateParams_authority protoreflect.FieldDescriptor
@@ -9189,7 +10175,7 @@ func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_opinit_ophost_v1_tx_proto_msgTypes[18]
+	mi := &file_opinit_ophost_v1_tx_proto_msgTypes[20]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -9684,7 +10670,7 @@ func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message {
 }
 
 func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_opinit_ophost_v1_tx_proto_msgTypes[19]
+	mi := &file_opinit_ophost_v1_tx_proto_msgTypes[21]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -10919,6 +11905,106 @@ func (x *MsgUpdateBatchInfoResponse) GetL2BlockNumber() uint64 {
 	return 0
 }
 
+// MsgUpdateMetadata is a message to change metadata
+type MsgUpdateMetadata struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// authority is the address that controls the module (defaults to x/gov unless overwritten)
+	// or the current challenger address.
+	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+	BridgeId  uint64 `protobuf:"varint,2,opt,name=bridge_id,json=bridgeId,proto3" json:"bridge_id,omitempty"`
+	Metadata  []byte `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
+}
+
+func (x *MsgUpdateMetadata) Reset() {
+	*x = MsgUpdateMetadata{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_opinit_ophost_v1_tx_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgUpdateMetadata) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateMetadata) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateMetadata.ProtoReflect.Descriptor instead.
+func (*MsgUpdateMetadata) Descriptor() ([]byte, []int) {
+	return file_opinit_ophost_v1_tx_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *MsgUpdateMetadata) GetAuthority() string {
+	if x != nil {
+		return x.Authority
+	}
+	return ""
+}
+
+func (x *MsgUpdateMetadata) GetBridgeId() uint64 {
+	if x != nil {
+		return x.BridgeId
+	}
+	return 0
+}
+
+func (x *MsgUpdateMetadata) GetMetadata() []byte {
+	if x != nil {
+		return x.Metadata
+	}
+	return nil
+}
+
+// MsgUpdateMetadataResponse returns a message handle result.
+type MsgUpdateMetadataResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// last finalized output index
+	OutputIndex uint64 `protobuf:"varint,1,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"`
+	// last finalized l2 block number
+	L2BlockNumber uint64 `protobuf:"varint,2,opt,name=l2_block_number,json=l2BlockNumber,proto3" json:"l2_block_number,omitempty"`
+}
+
+func (x *MsgUpdateMetadataResponse) Reset() {
+	*x = MsgUpdateMetadataResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_opinit_ophost_v1_tx_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgUpdateMetadataResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgUpdateMetadataResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgUpdateMetadataResponse.ProtoReflect.Descriptor instead.
+func (*MsgUpdateMetadataResponse) Descriptor() ([]byte, []int) {
+	return file_opinit_ophost_v1_tx_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *MsgUpdateMetadataResponse) GetOutputIndex() uint64 {
+	if x != nil {
+		return x.OutputIndex
+	}
+	return 0
+}
+
+func (x *MsgUpdateMetadataResponse) GetL2BlockNumber() uint64 {
+	if x != nil {
+		return x.L2BlockNumber
+	}
+	return 0
+}
+
 // MsgUpdateParams is a message to update parameters
 type MsgUpdateParams struct {
 	state         protoimpl.MessageState
@@ -10935,7 +12021,7 @@ type MsgUpdateParams struct {
 func (x *MsgUpdateParams) Reset() {
 	*x = MsgUpdateParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_opinit_ophost_v1_tx_proto_msgTypes[18]
+		mi := &file_opinit_ophost_v1_tx_proto_msgTypes[20]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -10949,7 +12035,7 @@ func (*MsgUpdateParams) ProtoMessage() {}
 
 // Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead.
 func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
-	return file_opinit_ophost_v1_tx_proto_rawDescGZIP(), []int{18}
+	return file_opinit_ophost_v1_tx_proto_rawDescGZIP(), []int{20}
 }
 
 func (x *MsgUpdateParams) GetAuthority() string {
@@ -10976,7 +12062,7 @@ type MsgUpdateParamsResponse struct {
 func (x *MsgUpdateParamsResponse) Reset() {
 	*x = MsgUpdateParamsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_opinit_ophost_v1_tx_proto_msgTypes[19]
+		mi := &file_opinit_ophost_v1_tx_proto_msgTypes[21]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -10990,7 +12076,7 @@ func (*MsgUpdateParamsResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead.
 func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
-	return file_opinit_ophost_v1_tx_proto_rawDescGZIP(), []int{19}
+	return file_opinit_ophost_v1_tx_proto_rawDescGZIP(), []int{21}
 }
 
 var File_opinit_ophost_v1_tx_proto protoreflect.FileDescriptor
@@ -11234,99 +12320,127 @@ var file_opinit_ophost_v1_tx_proto_rawDesc = []byte{
 	0x52, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x26, 0x0a,
 	0x0f, 0x6c, 0x32, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
 	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x6c, 0x32, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e,
-	0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0xcd, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64,
-	0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x4a, 0x0a, 0x09, 0x61, 0x75, 0x74,
-	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2c, 0xf2, 0xde,
-	0x1f, 0x10, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74,
-	0x79, 0x22, 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, 0x43, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f,
-	0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42,
-	0x11, 0xf2, 0xde, 0x1f, 0x0d, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d,
-	0x73, 0x22, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x29, 0x82, 0xe7, 0xb0, 0x2a,
-	0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x16, 0x6f,
-	0x70, 0x68, 0x6f, 0x73, 0x74, 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,
-	0x32, 0x8c, 0x08, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x59, 0x0a, 0x0b, 0x52, 0x65, 0x63, 0x6f,
-	0x72, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x20, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74,
-	0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65,
-	0x63, 0x6f, 0x72, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x1a, 0x28, 0x2e, 0x6f, 0x70, 0x69, 0x6e,
-	0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67,
-	0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x42, 0x72, 0x69,
-	0x64, 0x67, 0x65, 0x12, 0x21, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68,
-	0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
-	0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x1a, 0x29, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e,
-	0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65,
-	0x61, 0x74, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x5f, 0x0a, 0x0d, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x4f, 0x75, 0x74, 0x70,
-	0x75, 0x74, 0x12, 0x22, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f,
-	0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65,
-	0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x1a, 0x2a, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e,
-	0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x72, 0x6f,
-	0x70, 0x6f, 0x73, 0x65, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x5c, 0x0a, 0x0c, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4f, 0x75, 0x74, 0x70,
-	0x75, 0x74, 0x12, 0x21, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f,
-	0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4f,
-	0x75, 0x74, 0x70, 0x75, 0x74, 0x1a, 0x29, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f,
-	0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65,
-	0x74, 0x65, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x74, 0x0a, 0x14, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x12, 0x29, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69,
-	0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49,
+	0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0xf0, 0x01, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64,
+	0x61, 0x74, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4a, 0x0a, 0x09, 0x61,
+	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2c,
+	0xf2, 0xde, 0x1f, 0x10, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
+	0x69, 0x74, 0x79, 0x22, 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, 0x31, 0x0a, 0x09, 0x62, 0x72, 0x69, 0x64, 0x67,
+	0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x14, 0xf2, 0xde, 0x1f, 0x10,
+	0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x69, 0x64, 0x22,
+	0x52, 0x08, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x49, 0x64, 0x12, 0x2f, 0x0a, 0x08, 0x6d, 0x65,
+	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x13, 0xf2, 0xde,
+	0x1f, 0x0f, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0x22, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x3a, 0x2b, 0x82, 0xe7, 0xb0,
+	0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x18,
+	0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
+	0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x66, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x55,
+	0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f,
+	0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6f, 0x75, 0x74,
+	0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x26, 0x0a, 0x0f, 0x6c, 0x32, 0x5f, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x0d, 0x6c, 0x32, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
+	0x22, 0xcd, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61,
+	0x72, 0x61, 0x6d, 0x73, 0x12, 0x4a, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x2c, 0xf2, 0xde, 0x1f, 0x10, 0x79, 0x61, 0x6d,
+	0x6c, 0x3a, 0x22, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 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, 0x43, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x18, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74,
+	0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x11, 0xf2, 0xde, 0x1f, 0x0d,
+	0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x52, 0x06, 0x70,
+	0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x29, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68,
+	0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x16, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74,
+	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, 0x32, 0xf0, 0x08, 0x0a, 0x03,
+	0x4d, 0x73, 0x67, 0x12, 0x59, 0x0a, 0x0b, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x42, 0x61, 0x74,
+	0x63, 0x68, 0x12, 0x20, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f,
+	0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x42,
+	0x61, 0x74, 0x63, 0x68, 0x1a, 0x28, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70,
+	0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, 0x6f, 0x72,
+	0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c,
+	0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x12, 0x21,
+	0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76,
+	0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67,
+	0x65, 0x1a, 0x29, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73,
+	0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x42, 0x72,
+	0x69, 0x64, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5f, 0x0a, 0x0d,
+	0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x22, 0x2e,
+	0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31,
+	0x2e, 0x4d, 0x73, 0x67, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x4f, 0x75, 0x74, 0x70, 0x75,
+	0x74, 0x1a, 0x2a, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73,
+	0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x4f,
+	0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a,
+	0x0c, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x21, 0x2e,
+	0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31,
+	0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74,
+	0x1a, 0x29, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74,
+	0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4f, 0x75, 0x74,
+	0x70, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x74, 0x0a, 0x14, 0x49,
 	0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x44, 0x65, 0x70, 0x6f,
-	0x73, 0x69, 0x74, 0x1a, 0x31, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68,
+	0x73, 0x69, 0x74, 0x12, 0x29, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68,
 	0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61,
-	0x74, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7d, 0x0a, 0x17, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69,
-	0x7a, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61,
-	0x6c, 0x12, 0x2c, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73,
-	0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65,
-	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x1a,
-	0x34, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e,
-	0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x6f,
-	0x6b, 0x65, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50,
-	0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x12, 0x23, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74,
+	0x74, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x1a, 0x31,
+	0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76,
+	0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x54, 0x6f, 0x6b,
+	0x65, 0x6e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x7d, 0x0a, 0x17, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x6f, 0x6b,
+	0x65, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6f,
+	0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e,
+	0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
+	0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x1a, 0x34, 0x2e, 0x6f, 0x70, 0x69,
+	0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73,
+	0x67, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x57, 0x69,
+	0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x62, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73,
+	0x65, 0x72, 0x12, 0x23, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f,
+	0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50,
+	0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x1a, 0x2b, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74,
+	0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70,
+	0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x10, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68,
+	0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x12, 0x25, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69,
+	0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55,
+	0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x1a,
+	0x2d, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e,
+	0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6c,
+	0x6c, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65,
+	0x0a, 0x0f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x49, 0x6e, 0x66,
+	0x6f, 0x12, 0x24, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73,
+	0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x61,
+	0x74, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x2c, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74,
 	0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70,
-	0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x1a, 0x2b, 0x2e, 0x6f,
+	0x64, 0x61, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x23, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74,
+	0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70,
+	0x64, 0x61, 0x74, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x2b, 0x2e, 0x6f,
 	0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e,
-	0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65,
-	0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x10, 0x55, 0x70, 0x64,
-	0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x12, 0x25, 0x2e,
-	0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31,
-	0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65,
-	0x6e, 0x67, 0x65, 0x72, 0x1a, 0x2d, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70,
-	0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74,
-	0x65, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x0f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x61, 0x74,
-	0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x24, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e,
-	0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64,
-	0x61, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x2c, 0x2e, 0x6f,
+	0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
+	0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x0c, 0x55, 0x70, 0x64,
+	0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x21, 0x2e, 0x6f, 0x70, 0x69, 0x6e,
+	0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67,
+	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x29, 0x2e, 0x6f,
 	0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e,
-	0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x49, 0x6e,
-	0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x0c, 0x55, 0x70,
-	0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x21, 0x2e, 0x6f, 0x70, 0x69,
-	0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73,
-	0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x29, 0x2e,
-	0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31,
-	0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42,
-	0xc2, 0x01, 0xc8, 0xe1, 0x1e, 0x00, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x6f, 0x70, 0x69, 0x6e,
-	0x69, 0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78,
-	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x2d, 0x6c, 0x61, 0x62, 0x73, 0x2f,
-	0x4f, 0x50, 0x69, 0x6e, 0x69, 0x74, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6f, 0x70, 0x69, 0x6e, 0x69,
-	0x74, 0x2f, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x6f, 0x70, 0x68, 0x6f,
-	0x73, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x4f, 0x4f, 0x58, 0xaa, 0x02, 0x10, 0x4f, 0x70, 0x69,
-	0x6e, 0x69, 0x74, 0x2e, 0x4f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x10,
-	0x4f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x5c, 0x4f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x5c, 0x56, 0x31,
-	0xe2, 0x02, 0x1c, 0x4f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x5c, 0x4f, 0x70, 0x68, 0x6f, 0x73, 0x74,
-	0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea,
-	0x02, 0x12, 0x4f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x3a, 0x3a, 0x4f, 0x70, 0x68, 0x6f, 0x73, 0x74,
-	0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xc2,
+	0x01, 0xc8, 0xe1, 0x1e, 0x00, 0x0a, 0x14, 0x63, 0x6f, 0x6d, 0x2e, 0x6f, 0x70, 0x69, 0x6e, 0x69,
+	0x74, 0x2e, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
+	0x6f, 0x6d, 0x2f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x2d, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x4f,
+	0x50, 0x69, 0x6e, 0x69, 0x74, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x74,
+	0x2f, 0x6f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x6f, 0x70, 0x68, 0x6f, 0x73,
+	0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x4f, 0x4f, 0x58, 0xaa, 0x02, 0x10, 0x4f, 0x70, 0x69, 0x6e,
+	0x69, 0x74, 0x2e, 0x4f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x10, 0x4f,
+	0x70, 0x69, 0x6e, 0x69, 0x74, 0x5c, 0x4f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x5c, 0x56, 0x31, 0xe2,
+	0x02, 0x1c, 0x4f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x5c, 0x4f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x5c,
+	0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02,
+	0x12, 0x4f, 0x70, 0x69, 0x6e, 0x69, 0x74, 0x3a, 0x3a, 0x4f, 0x70, 0x68, 0x6f, 0x73, 0x74, 0x3a,
+	0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -11341,7 +12455,7 @@ func file_opinit_ophost_v1_tx_proto_rawDescGZIP() []byte {
 	return file_opinit_ophost_v1_tx_proto_rawDescData
 }
 
-var file_opinit_ophost_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
+var file_opinit_ophost_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 22)
 var file_opinit_ophost_v1_tx_proto_goTypes = []interface{}{
 	(*MsgRecordBatch)(nil),                     // 0: opinit.ophost.v1.MsgRecordBatch
 	(*MsgRecordBatchResponse)(nil),             // 1: opinit.ophost.v1.MsgRecordBatchResponse
@@ -11361,19 +12475,21 @@ var file_opinit_ophost_v1_tx_proto_goTypes = []interface{}{
 	(*MsgUpdateChallengerResponse)(nil),        // 15: opinit.ophost.v1.MsgUpdateChallengerResponse
 	(*MsgUpdateBatchInfo)(nil),                 // 16: opinit.ophost.v1.MsgUpdateBatchInfo
 	(*MsgUpdateBatchInfoResponse)(nil),         // 17: opinit.ophost.v1.MsgUpdateBatchInfoResponse
-	(*MsgUpdateParams)(nil),                    // 18: opinit.ophost.v1.MsgUpdateParams
-	(*MsgUpdateParamsResponse)(nil),            // 19: opinit.ophost.v1.MsgUpdateParamsResponse
-	(*BridgeConfig)(nil),                       // 20: opinit.ophost.v1.BridgeConfig
-	(*v1beta1.Coin)(nil),                       // 21: cosmos.base.v1beta1.Coin
-	(*BatchInfo)(nil),                          // 22: opinit.ophost.v1.BatchInfo
-	(*Params)(nil),                             // 23: opinit.ophost.v1.Params
+	(*MsgUpdateMetadata)(nil),                  // 18: opinit.ophost.v1.MsgUpdateMetadata
+	(*MsgUpdateMetadataResponse)(nil),          // 19: opinit.ophost.v1.MsgUpdateMetadataResponse
+	(*MsgUpdateParams)(nil),                    // 20: opinit.ophost.v1.MsgUpdateParams
+	(*MsgUpdateParamsResponse)(nil),            // 21: opinit.ophost.v1.MsgUpdateParamsResponse
+	(*BridgeConfig)(nil),                       // 22: opinit.ophost.v1.BridgeConfig
+	(*v1beta1.Coin)(nil),                       // 23: cosmos.base.v1beta1.Coin
+	(*BatchInfo)(nil),                          // 24: opinit.ophost.v1.BatchInfo
+	(*Params)(nil),                             // 25: opinit.ophost.v1.Params
 }
 var file_opinit_ophost_v1_tx_proto_depIdxs = []int32{
-	20, // 0: opinit.ophost.v1.MsgCreateBridge.config:type_name -> opinit.ophost.v1.BridgeConfig
-	21, // 1: opinit.ophost.v1.MsgInitiateTokenDeposit.amount:type_name -> cosmos.base.v1beta1.Coin
-	21, // 2: opinit.ophost.v1.MsgFinalizeTokenWithdrawal.amount:type_name -> cosmos.base.v1beta1.Coin
-	22, // 3: opinit.ophost.v1.MsgUpdateBatchInfo.new_batch_info:type_name -> opinit.ophost.v1.BatchInfo
-	23, // 4: opinit.ophost.v1.MsgUpdateParams.params:type_name -> opinit.ophost.v1.Params
+	22, // 0: opinit.ophost.v1.MsgCreateBridge.config:type_name -> opinit.ophost.v1.BridgeConfig
+	23, // 1: opinit.ophost.v1.MsgInitiateTokenDeposit.amount:type_name -> cosmos.base.v1beta1.Coin
+	23, // 2: opinit.ophost.v1.MsgFinalizeTokenWithdrawal.amount:type_name -> cosmos.base.v1beta1.Coin
+	24, // 3: opinit.ophost.v1.MsgUpdateBatchInfo.new_batch_info:type_name -> opinit.ophost.v1.BatchInfo
+	25, // 4: opinit.ophost.v1.MsgUpdateParams.params:type_name -> opinit.ophost.v1.Params
 	0,  // 5: opinit.ophost.v1.Msg.RecordBatch:input_type -> opinit.ophost.v1.MsgRecordBatch
 	2,  // 6: opinit.ophost.v1.Msg.CreateBridge:input_type -> opinit.ophost.v1.MsgCreateBridge
 	4,  // 7: opinit.ophost.v1.Msg.ProposeOutput:input_type -> opinit.ophost.v1.MsgProposeOutput
@@ -11383,19 +12499,21 @@ var file_opinit_ophost_v1_tx_proto_depIdxs = []int32{
 	12, // 11: opinit.ophost.v1.Msg.UpdateProposer:input_type -> opinit.ophost.v1.MsgUpdateProposer
 	14, // 12: opinit.ophost.v1.Msg.UpdateChallenger:input_type -> opinit.ophost.v1.MsgUpdateChallenger
 	16, // 13: opinit.ophost.v1.Msg.UpdateBatchInfo:input_type -> opinit.ophost.v1.MsgUpdateBatchInfo
-	18, // 14: opinit.ophost.v1.Msg.UpdateParams:input_type -> opinit.ophost.v1.MsgUpdateParams
-	1,  // 15: opinit.ophost.v1.Msg.RecordBatch:output_type -> opinit.ophost.v1.MsgRecordBatchResponse
-	3,  // 16: opinit.ophost.v1.Msg.CreateBridge:output_type -> opinit.ophost.v1.MsgCreateBridgeResponse
-	5,  // 17: opinit.ophost.v1.Msg.ProposeOutput:output_type -> opinit.ophost.v1.MsgProposeOutputResponse
-	7,  // 18: opinit.ophost.v1.Msg.DeleteOutput:output_type -> opinit.ophost.v1.MsgDeleteOutputResponse
-	9,  // 19: opinit.ophost.v1.Msg.InitiateTokenDeposit:output_type -> opinit.ophost.v1.MsgInitiateTokenDepositResponse
-	11, // 20: opinit.ophost.v1.Msg.FinalizeTokenWithdrawal:output_type -> opinit.ophost.v1.MsgFinalizeTokenWithdrawalResponse
-	13, // 21: opinit.ophost.v1.Msg.UpdateProposer:output_type -> opinit.ophost.v1.MsgUpdateProposerResponse
-	15, // 22: opinit.ophost.v1.Msg.UpdateChallenger:output_type -> opinit.ophost.v1.MsgUpdateChallengerResponse
-	17, // 23: opinit.ophost.v1.Msg.UpdateBatchInfo:output_type -> opinit.ophost.v1.MsgUpdateBatchInfoResponse
-	19, // 24: opinit.ophost.v1.Msg.UpdateParams:output_type -> opinit.ophost.v1.MsgUpdateParamsResponse
-	15, // [15:25] is the sub-list for method output_type
-	5,  // [5:15] is the sub-list for method input_type
+	18, // 14: opinit.ophost.v1.Msg.UpdateMetadata:input_type -> opinit.ophost.v1.MsgUpdateMetadata
+	20, // 15: opinit.ophost.v1.Msg.UpdateParams:input_type -> opinit.ophost.v1.MsgUpdateParams
+	1,  // 16: opinit.ophost.v1.Msg.RecordBatch:output_type -> opinit.ophost.v1.MsgRecordBatchResponse
+	3,  // 17: opinit.ophost.v1.Msg.CreateBridge:output_type -> opinit.ophost.v1.MsgCreateBridgeResponse
+	5,  // 18: opinit.ophost.v1.Msg.ProposeOutput:output_type -> opinit.ophost.v1.MsgProposeOutputResponse
+	7,  // 19: opinit.ophost.v1.Msg.DeleteOutput:output_type -> opinit.ophost.v1.MsgDeleteOutputResponse
+	9,  // 20: opinit.ophost.v1.Msg.InitiateTokenDeposit:output_type -> opinit.ophost.v1.MsgInitiateTokenDepositResponse
+	11, // 21: opinit.ophost.v1.Msg.FinalizeTokenWithdrawal:output_type -> opinit.ophost.v1.MsgFinalizeTokenWithdrawalResponse
+	13, // 22: opinit.ophost.v1.Msg.UpdateProposer:output_type -> opinit.ophost.v1.MsgUpdateProposerResponse
+	15, // 23: opinit.ophost.v1.Msg.UpdateChallenger:output_type -> opinit.ophost.v1.MsgUpdateChallengerResponse
+	17, // 24: opinit.ophost.v1.Msg.UpdateBatchInfo:output_type -> opinit.ophost.v1.MsgUpdateBatchInfoResponse
+	19, // 25: opinit.ophost.v1.Msg.UpdateMetadata:output_type -> opinit.ophost.v1.MsgUpdateMetadataResponse
+	21, // 26: opinit.ophost.v1.Msg.UpdateParams:output_type -> opinit.ophost.v1.MsgUpdateParamsResponse
+	16, // [16:27] is the sub-list for method output_type
+	5,  // [5:16] is the sub-list for method input_type
 	5,  // [5:5] is the sub-list for extension type_name
 	5,  // [5:5] is the sub-list for extension extendee
 	0,  // [0:5] is the sub-list for field type_name
@@ -11625,7 +12743,7 @@ func file_opinit_ophost_v1_tx_proto_init() {
 			}
 		}
 		file_opinit_ophost_v1_tx_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgUpdateParams); i {
+			switch v := v.(*MsgUpdateMetadata); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -11637,6 +12755,30 @@ func file_opinit_ophost_v1_tx_proto_init() {
 			}
 		}
 		file_opinit_ophost_v1_tx_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgUpdateMetadataResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_opinit_ophost_v1_tx_proto_msgTypes[20].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_opinit_ophost_v1_tx_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*MsgUpdateParamsResponse); i {
 			case 0:
 				return &v.state
@@ -11655,7 +12797,7 @@ func file_opinit_ophost_v1_tx_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_opinit_ophost_v1_tx_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   20,
+			NumMessages:   22,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
diff --git a/api/opinit/ophost/v1/tx_grpc.pb.go b/api/opinit/ophost/v1/tx_grpc.pb.go
index a9b666db..505fd87f 100644
--- a/api/opinit/ophost/v1/tx_grpc.pb.go
+++ b/api/opinit/ophost/v1/tx_grpc.pb.go
@@ -28,6 +28,7 @@ const (
 	Msg_UpdateProposer_FullMethodName          = "/opinit.ophost.v1.Msg/UpdateProposer"
 	Msg_UpdateChallenger_FullMethodName        = "/opinit.ophost.v1.Msg/UpdateChallenger"
 	Msg_UpdateBatchInfo_FullMethodName         = "/opinit.ophost.v1.Msg/UpdateBatchInfo"
+	Msg_UpdateMetadata_FullMethodName          = "/opinit.ophost.v1.Msg/UpdateMetadata"
 	Msg_UpdateParams_FullMethodName            = "/opinit.ophost.v1.Msg/UpdateParams"
 )
 
@@ -53,6 +54,8 @@ type MsgClient interface {
 	UpdateChallenger(ctx context.Context, in *MsgUpdateChallenger, opts ...grpc.CallOption) (*MsgUpdateChallengerResponse, error)
 	// UpdateBatchInfo defines a rpc handler method for MsgUpdateBatchInfo.
 	UpdateBatchInfo(ctx context.Context, in *MsgUpdateBatchInfo, opts ...grpc.CallOption) (*MsgUpdateBatchInfoResponse, error)
+	// UpdateMetadata defines a rpc handler method for MsgUpdateMetadata.
+	UpdateMetadata(ctx context.Context, in *MsgUpdateMetadata, opts ...grpc.CallOption) (*MsgUpdateMetadataResponse, error)
 	// UpdateParams defines an operation for updating the
 	// x/opchild module parameters.
 	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
@@ -147,6 +150,15 @@ func (c *msgClient) UpdateBatchInfo(ctx context.Context, in *MsgUpdateBatchInfo,
 	return out, nil
 }
 
+func (c *msgClient) UpdateMetadata(ctx context.Context, in *MsgUpdateMetadata, opts ...grpc.CallOption) (*MsgUpdateMetadataResponse, error) {
+	out := new(MsgUpdateMetadataResponse)
+	err := c.cc.Invoke(ctx, Msg_UpdateMetadata_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
 	out := new(MsgUpdateParamsResponse)
 	err := c.cc.Invoke(ctx, Msg_UpdateParams_FullMethodName, in, out, opts...)
@@ -178,6 +190,8 @@ type MsgServer interface {
 	UpdateChallenger(context.Context, *MsgUpdateChallenger) (*MsgUpdateChallengerResponse, error)
 	// UpdateBatchInfo defines a rpc handler method for MsgUpdateBatchInfo.
 	UpdateBatchInfo(context.Context, *MsgUpdateBatchInfo) (*MsgUpdateBatchInfoResponse, error)
+	// UpdateMetadata defines a rpc handler method for MsgUpdateMetadata.
+	UpdateMetadata(context.Context, *MsgUpdateMetadata) (*MsgUpdateMetadataResponse, error)
 	// UpdateParams defines an operation for updating the
 	// x/opchild module parameters.
 	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
@@ -215,6 +229,9 @@ func (UnimplementedMsgServer) UpdateChallenger(context.Context, *MsgUpdateChalle
 func (UnimplementedMsgServer) UpdateBatchInfo(context.Context, *MsgUpdateBatchInfo) (*MsgUpdateBatchInfoResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method UpdateBatchInfo not implemented")
 }
+func (UnimplementedMsgServer) UpdateMetadata(context.Context, *MsgUpdateMetadata) (*MsgUpdateMetadataResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UpdateMetadata not implemented")
+}
 func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
 }
@@ -393,6 +410,24 @@ func _Msg_UpdateBatchInfo_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_UpdateMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgUpdateMetadata)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).UpdateMetadata(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_UpdateMetadata_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).UpdateMetadata(ctx, req.(*MsgUpdateMetadata))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgUpdateParams)
 	if err := dec(in); err != nil {
@@ -454,6 +489,10 @@ var Msg_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "UpdateBatchInfo",
 			Handler:    _Msg_UpdateBatchInfo_Handler,
 		},
+		{
+			MethodName: "UpdateMetadata",
+			Handler:    _Msg_UpdateMetadata_Handler,
+		},
 		{
 			MethodName: "UpdateParams",
 			Handler:    _Msg_UpdateParams_Handler,
diff --git a/proto/opinit/ophost/v1/tx.proto b/proto/opinit/ophost/v1/tx.proto
index 7087e337..a3925c1a 100644
--- a/proto/opinit/ophost/v1/tx.proto
+++ b/proto/opinit/ophost/v1/tx.proto
@@ -60,6 +60,9 @@ service Msg {
   // UpdateBatchInfo defines a rpc handler method for MsgUpdateBatchInfo.
   rpc UpdateBatchInfo(MsgUpdateBatchInfo) returns (MsgUpdateBatchInfoResponse);
 
+  // UpdateMetadata defines a rpc handler method for MsgUpdateMetadata.
+  rpc UpdateMetadata(MsgUpdateMetadata) returns (MsgUpdateMetadataResponse);
+
   // UpdateParams defines an operation for updating the
   // x/opchild module parameters.
   rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse);
@@ -257,6 +260,26 @@ message MsgUpdateBatchInfoResponse {
   uint64 l2_block_number = 2;
 }
 
+// MsgUpdateMetadata is a message to change metadata
+message MsgUpdateMetadata {
+  option (cosmos.msg.v1.signer) = "authority";
+  option (amino.name)           = "ophost/MsgUpdateMetadata";
+
+  // authority is the address that controls the module (defaults to x/gov unless overwritten)
+  // or the current challenger address.
+  string authority = 1 [(gogoproto.moretags) = "yaml:\"authority\"", (cosmos_proto.scalar) = "cosmos.AddressString"];
+  uint64 bridge_id = 2 [(gogoproto.moretags) = "yaml:\"bridge_id\""];
+  bytes  metadata  = 3 [(gogoproto.moretags) = "yaml:\"metadata\""];
+}
+
+// MsgUpdateMetadataResponse returns a message handle result.
+message MsgUpdateMetadataResponse {
+  // last finalized output index
+  uint64 output_index = 1;
+  // last finalized l2 block number
+  uint64 l2_block_number = 2;
+}
+
 // MsgUpdateParams is a message to update parameters
 message MsgUpdateParams {
   option (cosmos.msg.v1.signer) = "authority";
diff --git a/x/ophost/keeper/common_test.go b/x/ophost/keeper/common_test.go
index e6d5082b..bdfa0e92 100644
--- a/x/ophost/keeper/common_test.go
+++ b/x/ophost/keeper/common_test.go
@@ -385,6 +385,20 @@ func (h *bridgeHook) BridgeBatchInfoUpdated(
 	return nil
 }
 
+func (h *bridgeHook) BridgeMetadataUpdated(
+	ctx context.Context,
+	bridgeId uint64,
+	bridgeConfig ophosttypes.BridgeConfig,
+) error {
+	if h.err != nil {
+		return h.err
+	}
+
+	h.metadata = bridgeConfig.Metadata
+
+	return nil
+}
+
 var _ ophosttypes.CommunityPoolKeeper = &MockCommunityPoolKeeper{}
 
 type MockCommunityPoolKeeper struct {
diff --git a/x/ophost/keeper/msg_server.go b/x/ophost/keeper/msg_server.go
index 3940a530..98af864e 100644
--- a/x/ophost/keeper/msg_server.go
+++ b/x/ophost/keeper/msg_server.go
@@ -489,6 +489,49 @@ func (ms MsgServer) UpdateBatchInfo(ctx context.Context, req *types.MsgUpdateBat
 	}, nil
 }
 
+func (ms MsgServer) UpdateMetadata(ctx context.Context, req *types.MsgUpdateMetadata) (*types.MsgUpdateMetadataResponse, error) {
+	if err := req.Validate(ms.authKeeper.AddressCodec()); err != nil {
+		return nil, err
+	}
+
+	bridgeId := req.BridgeId
+	config, err := ms.GetBridgeConfig(ctx, bridgeId)
+	if err != nil {
+		return nil, err
+	}
+
+	// gov or current proposer can update batch info.
+	if ms.authority != req.Authority && config.Proposer != req.Authority {
+		return nil, govtypes.ErrInvalidSigner.Wrapf("invalid authority; expected %s or %s, got %s", ms.authority, config.Proposer, req.Authority)
+	}
+
+	config.Metadata = req.Metadata
+	if err := ms.Keeper.bridgeHook.BridgeMetadataUpdated(ctx, bridgeId, config); err != nil {
+		return nil, err
+	}
+
+	if err := ms.SetBridgeConfig(ctx, bridgeId, config); err != nil {
+		return nil, err
+	}
+
+	finalizedOutputIndex, finalizedOutput, err := ms.GetLastFinalizedOutput(ctx, bridgeId)
+	if err != nil {
+		return nil, err
+	}
+
+	sdk.UnwrapSDKContext(ctx).EventManager().EmitEvent(sdk.NewEvent(
+		types.EventTypeUpdateBatchInfo,
+		sdk.NewAttribute(types.AttributeKeyBridgeId, strconv.FormatUint(bridgeId, 10)),
+		sdk.NewAttribute(types.AttributeKeyFinalizedOutputIndex, strconv.FormatUint(finalizedOutputIndex, 10)),
+		sdk.NewAttribute(types.AttributeKeyFinalizedL2BlockNumber, strconv.FormatUint(finalizedOutput.L2BlockNumber, 10)),
+	))
+
+	return &types.MsgUpdateMetadataResponse{
+		OutputIndex:   finalizedOutputIndex,
+		L2BlockNumber: finalizedOutput.L2BlockNumber,
+	}, nil
+}
+
 // UpdateParams implements updating the parameters
 func (ms MsgServer) UpdateParams(ctx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
 	if err := req.Validate(ms.authKeeper.AddressCodec()); err != nil {
diff --git a/x/ophost/keeper/msg_server_test.go b/x/ophost/keeper/msg_server_test.go
index 48f2e388..01e689cb 100644
--- a/x/ophost/keeper/msg_server_test.go
+++ b/x/ophost/keeper/msg_server_test.go
@@ -380,6 +380,57 @@ func Test_UpdateBatchInfo(t *testing.T) {
 	require.Error(t, err)
 }
 
+func Test_UpdateMetadata(t *testing.T) {
+	ctx, input := createDefaultTestInput(t)
+	ms := keeper.NewMsgServerImpl(input.OPHostKeeper)
+
+	config := types.BridgeConfig{
+		Proposer:            addrsStr[0],
+		Challenger:          addrsStr[1],
+		SubmissionInterval:  time.Second * 10,
+		FinalizationPeriod:  time.Second * 60,
+		SubmissionStartTime: time.Now().UTC(),
+		Metadata:            []byte{1, 2, 3},
+		BatchInfo:           types.BatchInfo{Submitter: addrsStr[0], Chain: "l1"},
+	}
+
+	_, err := ms.CreateBridge(ctx, types.NewMsgCreateBridge(addrsStr[0], config))
+	require.NoError(t, err)
+
+	// gov signer
+	govAddr, err := input.AccountKeeper.AddressCodec().BytesToString(authtypes.NewModuleAddress("gov"))
+	require.NoError(t, err)
+	msg := types.NewMsgUpdateMetadata(govAddr, 1, []byte{4, 5, 6})
+	_, err = ms.UpdateMetadata(ctx, msg)
+	require.NoError(t, err)
+	_config, err := ms.GetBridgeConfig(ctx, 1)
+	require.NoError(t, err)
+	require.Equal(t, []byte{4, 5, 6}, _config.Metadata)
+	require.Equal(t, []byte{4, 5, 6}, input.BridgeHook.metadata)
+
+	// current challenger
+	msg = types.NewMsgUpdateMetadata(addrsStr[0], 1, []byte{7, 8, 9})
+	_, err = ms.UpdateMetadata(ctx, msg)
+	require.NoError(t, err)
+	_config, err = ms.GetBridgeConfig(ctx, 1)
+	require.NoError(t, err)
+	require.Equal(t, []byte{7, 8, 9}, _config.Metadata)
+	require.Equal(t, []byte{7, 8, 9}, input.BridgeHook.metadata)
+
+	// invalid signer
+	invalidAddr, err := input.AccountKeeper.AddressCodec().BytesToString(authtypes.NewModuleAddress(types.ModuleName))
+	require.NoError(t, err)
+	msg = types.NewMsgUpdateMetadata(invalidAddr, 1, []byte{1, 2, 3})
+	require.NoError(t, err)
+
+	_, err = ms.UpdateMetadata(
+		ctx,
+		msg,
+	)
+	require.Error(t, err)
+
+}
+
 func Test_MsgServer_UpdateParams(t *testing.T) {
 	ctx, input := createDefaultTestInput(t)
 	ms := keeper.NewMsgServerImpl(input.OPHostKeeper)
diff --git a/x/ophost/types/error.go b/x/ophost/types/error.go
index 01cfa6cd..83496ecc 100644
--- a/x/ophost/types/error.go
+++ b/x/ophost/types/error.go
@@ -17,4 +17,5 @@ var (
 	ErrFailedToVerifyWithdrawal   = errorsmod.Register(ModuleName, 10, "failed to verify withdrawal tx")
 	ErrWithdrawalAlreadyFinalized = errorsmod.Register(ModuleName, 11, "withdrawal already finalized")
 	ErrEmptyBatchInfo             = errorsmod.Register(ModuleName, 12, "empty batch info")
+	ErrInvalidBridgeMetadata      = errorsmod.Register(ModuleName, 13, "invalid bridge metadata")
 )
diff --git a/x/ophost/types/hooks.go b/x/ophost/types/hooks.go
index 8a3e6786..17e84b03 100644
--- a/x/ophost/types/hooks.go
+++ b/x/ophost/types/hooks.go
@@ -23,6 +23,11 @@ type BridgeHook interface {
 		bridgeId uint64,
 		bridgeConfig BridgeConfig,
 	) error
+	BridgeMetadataUpdated(
+		ctx context.Context,
+		bridgeId uint64,
+		bridgeConfig BridgeConfig,
+	) error
 }
 
 type BridgeHooks []BridgeHook
@@ -88,3 +93,17 @@ func (hooks BridgeHooks) BridgeBatchInfoUpdated(
 
 	return nil
 }
+
+func (hooks BridgeHooks) BridgeMetadataUpdated(
+	ctx context.Context,
+	bridgeId uint64,
+	bridgeConfig BridgeConfig,
+) error {
+	for _, h := range hooks {
+		if err := h.BridgeMetadataUpdated(ctx, bridgeId, bridgeConfig); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
diff --git a/x/ophost/types/tx.go b/x/ophost/types/tx.go
index e21fc660..3cff6a11 100644
--- a/x/ophost/types/tx.go
+++ b/x/ophost/types/tx.go
@@ -15,9 +15,14 @@ var (
 	_ sdk.Msg = &MsgUpdateProposer{}
 	_ sdk.Msg = &MsgUpdateChallenger{}
 	_ sdk.Msg = &MsgUpdateBatchInfo{}
+	_ sdk.Msg = &MsgUpdateMetadata{}
 	_ sdk.Msg = &MsgUpdateParams{}
 )
 
+const (
+	MaxMetadataLength = 1024 * 5
+)
+
 /* MsgRecordBatch */
 
 // NewMsgRecordBatch creates a new MsgRecordBatch instance.
@@ -69,6 +74,10 @@ func (msg MsgCreateBridge) Validate(ac address.Codec) error {
 		return err
 	}
 
+	if len(msg.Config.Metadata) > MaxMetadataLength {
+		return ErrInvalidBridgeMetadata.Wrapf("metadata length exceeds %d", MaxMetadataLength)
+	}
+
 	return nil
 }
 
@@ -358,6 +367,38 @@ func (msg MsgUpdateBatchInfo) Validate(accAddressCodec address.Codec) error {
 	return nil
 }
 
+/* MsgUpdateMetadata */
+
+// NewMsgUpdateMetadata creates a new MsgUpdateMetadata instance.
+func NewMsgUpdateMetadata(
+	authority string,
+	bridgeId uint64,
+	metadata []byte,
+) *MsgUpdateMetadata {
+	return &MsgUpdateMetadata{
+		Authority: authority,
+		BridgeId:  bridgeId,
+		Metadata:  metadata,
+	}
+}
+
+// Validate performs basic MsgUpdateMetadata message validation.
+func (msg MsgUpdateMetadata) Validate(accAddressCodec address.Codec) error {
+	if _, err := accAddressCodec.StringToBytes(msg.Authority); err != nil {
+		return err
+	}
+
+	if msg.BridgeId == 0 {
+		return ErrInvalidBridgeId
+	}
+
+	if len(msg.Metadata) > MaxMetadataLength {
+		return ErrInvalidBridgeMetadata.Wrapf("metadata length exceeds %d", MaxMetadataLength)
+	}
+
+	return nil
+}
+
 /* MsgUpdateParams */
 
 // NewMsgUpdateParams returns a new MsgUpdateParams instance
diff --git a/x/ophost/types/tx.pb.go b/x/ophost/types/tx.pb.go
index 579053fd..092a9d37 100644
--- a/x/ophost/types/tx.pb.go
+++ b/x/ophost/types/tx.pb.go
@@ -759,6 +759,89 @@ func (m *MsgUpdateBatchInfoResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgUpdateBatchInfoResponse proto.InternalMessageInfo
 
+// MsgUpdateMetadata is a message to change metadata
+type MsgUpdateMetadata struct {
+	// authority is the address that controls the module (defaults to x/gov unless overwritten)
+	// or the current challenger address.
+	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty" yaml:"authority"`
+	BridgeId  uint64 `protobuf:"varint,2,opt,name=bridge_id,json=bridgeId,proto3" json:"bridge_id,omitempty" yaml:"bridge_id"`
+	Metadata  []byte `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty" yaml:"metadata"`
+}
+
+func (m *MsgUpdateMetadata) Reset()         { *m = MsgUpdateMetadata{} }
+func (m *MsgUpdateMetadata) String() string { return proto.CompactTextString(m) }
+func (*MsgUpdateMetadata) ProtoMessage()    {}
+func (*MsgUpdateMetadata) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d16af6eaf4088d05, []int{18}
+}
+func (m *MsgUpdateMetadata) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgUpdateMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgUpdateMetadata.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgUpdateMetadata) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgUpdateMetadata.Merge(m, src)
+}
+func (m *MsgUpdateMetadata) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgUpdateMetadata) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgUpdateMetadata.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgUpdateMetadata proto.InternalMessageInfo
+
+// MsgUpdateMetadataResponse returns a message handle result.
+type MsgUpdateMetadataResponse struct {
+	// last finalized output index
+	OutputIndex uint64 `protobuf:"varint,1,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"`
+	// last finalized l2 block number
+	L2BlockNumber uint64 `protobuf:"varint,2,opt,name=l2_block_number,json=l2BlockNumber,proto3" json:"l2_block_number,omitempty"`
+}
+
+func (m *MsgUpdateMetadataResponse) Reset()         { *m = MsgUpdateMetadataResponse{} }
+func (m *MsgUpdateMetadataResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgUpdateMetadataResponse) ProtoMessage()    {}
+func (*MsgUpdateMetadataResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d16af6eaf4088d05, []int{19}
+}
+func (m *MsgUpdateMetadataResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgUpdateMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgUpdateMetadataResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgUpdateMetadataResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgUpdateMetadataResponse.Merge(m, src)
+}
+func (m *MsgUpdateMetadataResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgUpdateMetadataResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgUpdateMetadataResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgUpdateMetadataResponse proto.InternalMessageInfo
+
 // MsgUpdateParams is a message to update parameters
 type MsgUpdateParams struct {
 	// authority is the address that controls the module
@@ -772,7 +855,7 @@ func (m *MsgUpdateParams) Reset()         { *m = MsgUpdateParams{} }
 func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) }
 func (*MsgUpdateParams) ProtoMessage()    {}
 func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d16af6eaf4088d05, []int{18}
+	return fileDescriptor_d16af6eaf4088d05, []int{20}
 }
 func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -809,7 +892,7 @@ func (m *MsgUpdateParamsResponse) Reset()         { *m = MsgUpdateParamsResponse
 func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgUpdateParamsResponse) ProtoMessage()    {}
 func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d16af6eaf4088d05, []int{19}
+	return fileDescriptor_d16af6eaf4088d05, []int{21}
 }
 func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -857,6 +940,8 @@ func init() {
 	proto.RegisterType((*MsgUpdateChallengerResponse)(nil), "opinit.ophost.v1.MsgUpdateChallengerResponse")
 	proto.RegisterType((*MsgUpdateBatchInfo)(nil), "opinit.ophost.v1.MsgUpdateBatchInfo")
 	proto.RegisterType((*MsgUpdateBatchInfoResponse)(nil), "opinit.ophost.v1.MsgUpdateBatchInfoResponse")
+	proto.RegisterType((*MsgUpdateMetadata)(nil), "opinit.ophost.v1.MsgUpdateMetadata")
+	proto.RegisterType((*MsgUpdateMetadataResponse)(nil), "opinit.ophost.v1.MsgUpdateMetadataResponse")
 	proto.RegisterType((*MsgUpdateParams)(nil), "opinit.ophost.v1.MsgUpdateParams")
 	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "opinit.ophost.v1.MsgUpdateParamsResponse")
 }
@@ -864,104 +949,107 @@ func init() {
 func init() { proto.RegisterFile("opinit/ophost/v1/tx.proto", fileDescriptor_d16af6eaf4088d05) }
 
 var fileDescriptor_d16af6eaf4088d05 = []byte{
-	// 1540 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xcf, 0x6b, 0x1b, 0xc7,
-	0x17, 0x97, 0x14, 0xc7, 0xb1, 0x46, 0xfe, 0xb9, 0x71, 0x6c, 0x79, 0x13, 0xb4, 0xf6, 0x7c, 0x93,
-	0x6f, 0x1d, 0xc7, 0x96, 0x90, 0x9b, 0xa6, 0x20, 0xc8, 0x21, 0xeb, 0xd0, 0xc4, 0x01, 0x35, 0x66,
-	0xdb, 0xd2, 0x1f, 0x14, 0xc4, 0x4a, 0x1a, 0xaf, 0x96, 0x48, 0x3b, 0xea, 0xce, 0xc8, 0x8e, 0x0b,
-	0x85, 0xd2, 0x53, 0x29, 0x3d, 0x14, 0x7a, 0x2e, 0xe4, 0x98, 0x63, 0x0e, 0xa5, 0x7f, 0x83, 0x2f,
-	0x85, 0x50, 0x7a, 0xe8, 0x69, 0x69, 0x93, 0x43, 0x7a, 0xe8, 0x49, 0xd7, 0x5c, 0xca, 0xce, 0xcc,
-	0xce, 0xfe, 0x90, 0xe4, 0x38, 0x26, 0x69, 0x2e, 0xc6, 0xf3, 0xde, 0xe7, 0xcd, 0x9b, 0xf7, 0x79,
-	0x6f, 0xdf, 0x9b, 0x11, 0x58, 0xc2, 0x5d, 0xdb, 0xb1, 0x69, 0x09, 0x77, 0x5b, 0x98, 0xd0, 0xd2,
-	0x5e, 0xb9, 0x44, 0xef, 0x17, 0xbb, 0x2e, 0xa6, 0x58, 0x99, 0xe5, 0xaa, 0x22, 0x57, 0x15, 0xf7,
-	0xca, 0xea, 0x9c, 0xd9, 0xb1, 0x1d, 0x5c, 0x62, 0x7f, 0x39, 0x48, 0x2d, 0x34, 0x30, 0xe9, 0x60,
-	0x52, 0xaa, 0x9b, 0x04, 0x95, 0xf6, 0xca, 0x75, 0x44, 0xcd, 0x72, 0xa9, 0x81, 0x6d, 0x47, 0xe8,
-	0x17, 0x85, 0xbe, 0x43, 0x2c, 0x7f, 0xf3, 0x0e, 0xb1, 0x84, 0x62, 0x89, 0x2b, 0x6a, 0x6c, 0x55,
-	0xe2, 0x0b, 0xa1, 0x9a, 0xb7, 0xb0, 0x85, 0xb9, 0xdc, 0xff, 0x4f, 0x48, 0x2f, 0x0c, 0x9e, 0xf4,
-	0xa0, 0x8b, 0x84, 0x0d, 0xec, 0xa7, 0xc1, 0x74, 0x95, 0x58, 0x06, 0x6a, 0x60, 0xb7, 0xa9, 0x9b,
-	0xb4, 0xd1, 0x52, 0xee, 0x80, 0x2c, 0xe9, 0xd5, 0x3b, 0x36, 0xa5, 0xc8, 0xcd, 0xa7, 0x97, 0xd3,
-	0xab, 0x59, 0x7d, 0xbd, 0xef, 0x69, 0xb3, 0x07, 0x66, 0xa7, 0x5d, 0x81, 0x52, 0x05, 0x7f, 0xfb,
-	0x79, 0x63, 0x5e, 0xf8, 0xbf, 0xd1, 0x6c, 0xba, 0x88, 0x90, 0x0f, 0xa8, 0x6b, 0x3b, 0x96, 0x11,
-	0x9a, 0x2b, 0x65, 0x90, 0xad, 0xbb, 0x76, 0xd3, 0x42, 0x35, 0xbb, 0x99, 0xcf, 0x2c, 0xa7, 0x57,
-	0xc7, 0xf4, 0xf9, 0x70, 0x2f, 0xa9, 0x82, 0xc6, 0x04, 0xff, 0x7f, 0xbb, 0xa9, 0xbc, 0x0b, 0x72,
-	0x75, 0xff, 0x1c, 0xb5, 0xfa, 0x01, 0x45, 0x24, 0x7f, 0x6a, 0x39, 0xbd, 0x3a, 0xa9, 0x2f, 0xf4,
-	0x3d, 0x4d, 0x11, 0x46, 0xa1, 0x12, 0x1a, 0x80, 0xad, 0x74, 0x7f, 0x51, 0x59, 0xfd, 0xe6, 0xd9,
-	0xa3, 0xb5, 0xd0, 0xf7, 0x77, 0xcf, 0x1e, 0xad, 0x9d, 0x13, 0x41, 0xc7, 0x23, 0x84, 0x79, 0xb0,
-	0x10, 0x97, 0x18, 0x88, 0x74, 0xb1, 0x43, 0x10, 0xfc, 0x3d, 0x0d, 0x66, 0xaa, 0xc4, 0xda, 0x72,
-	0x91, 0x49, 0x91, 0xce, 0x8e, 0xa4, 0xdc, 0x04, 0x67, 0x1a, 0xfe, 0x1a, 0x07, 0x6c, 0xac, 0xf5,
-	0x3d, 0x6d, 0x9a, 0x1f, 0x46, 0x28, 0x46, 0x73, 0x11, 0x98, 0x2a, 0x06, 0x18, 0x6f, 0x60, 0x67,
-	0xd7, 0xb6, 0x18, 0x0d, 0xb9, 0xcd, 0x42, 0x31, 0x59, 0x26, 0x45, 0xee, 0x6f, 0x8b, 0xa1, 0x74,
-	0xf5, 0xd0, 0xd3, 0x52, 0x7d, 0x4f, 0x9b, 0x12, 0x8e, 0x98, 0x14, 0x3e, 0x7c, 0xf6, 0x68, 0x2d,
-	0x6d, 0x88, 0x9d, 0x2a, 0x6f, 0xf9, 0x11, 0x07, 0x1e, 0xfc, 0x78, 0x17, 0xc2, 0x78, 0xa3, 0x21,
-	0xc0, 0x6b, 0x60, 0x31, 0x21, 0x0a, 0x22, 0x56, 0xce, 0x47, 0x33, 0xe4, 0xc7, 0x37, 0x16, 0xe6,
-	0x02, 0xfe, 0x92, 0x01, 0xb3, 0x55, 0x62, 0xed, 0xb8, 0xb8, 0x8b, 0x09, 0xba, 0xdb, 0xa3, 0xdd,
-	0x1e, 0x55, 0x6e, 0x81, 0x89, 0x2e, 0x17, 0x04, 0x84, 0x5c, 0xe9, 0x7b, 0xda, 0x0c, 0x3f, 0x67,
-	0xa0, 0x19, 0xcd, 0x88, 0x34, 0x3e, 0x49, 0x71, 0xe8, 0x60, 0xa6, 0xbd, 0x59, 0xab, 0xb7, 0x71,
-	0xe3, 0x5e, 0xcd, 0xe9, 0x75, 0xea, 0xc8, 0x65, 0x05, 0x32, 0xa6, 0xab, 0x7d, 0x4f, 0x5b, 0xe0,
-	0x86, 0x09, 0x00, 0x34, 0xa6, 0xda, 0x9b, 0xba, 0x2f, 0x78, 0x9f, 0xad, 0xfd, 0x02, 0xc3, 0x2c,
-	0x92, 0x9a, 0x8b, 0x31, 0xcd, 0x8f, 0x25, 0x0b, 0x2c, 0xa2, 0x84, 0x06, 0xe0, 0x2b, 0x03, 0x63,
-	0x5a, 0xb9, 0xec, 0xd3, 0x2d, 0x8f, 0xef, 0xf3, 0xbd, 0x18, 0xf2, 0x1d, 0xe3, 0x08, 0x5e, 0x07,
-	0xf9, 0xa4, 0x4c, 0x32, 0xbe, 0x02, 0x26, 0x85, 0x0b, 0xdb, 0x69, 0xa2, 0xfb, 0x82, 0x74, 0x71,
-	0xa6, 0x6d, 0x5f, 0x04, 0x9f, 0xf3, 0x32, 0xbc, 0x89, 0xda, 0x88, 0x06, 0xb4, 0x57, 0x01, 0x68,
-	0xb4, 0xcc, 0x76, 0x1b, 0x39, 0x96, 0x24, 0x7e, 0xa3, 0xef, 0x69, 0x73, 0xa2, 0x40, 0xa4, 0x6e,
-	0x34, 0xf5, 0x91, 0x0d, 0x4e, 0x42, 0x7e, 0x25, 0x71, 0x70, 0xce, 0xfc, 0x62, 0xdf, 0xd3, 0xce,
-	0xc6, 0x98, 0x63, 0x5a, 0x18, 0x8b, 0xa8, 0xb2, 0xe6, 0x73, 0x17, 0xf1, 0x9f, 0xa8, 0xd6, 0x68,
-	0xa4, 0x70, 0x89, 0x55, 0x6b, 0x54, 0x24, 0xbf, 0xcf, 0xe7, 0x19, 0xa6, 0xdb, 0x76, 0x6c, 0x6a,
-	0x9b, 0x14, 0x7d, 0x88, 0xef, 0x21, 0xe7, 0x26, 0xea, 0x62, 0x62, 0x53, 0xe5, 0x06, 0x18, 0x27,
-	0xc8, 0x69, 0x4a, 0x72, 0x2e, 0x87, 0x5f, 0x0f, 0x97, 0x8f, 0x26, 0x46, 0x18, 0x9e, 0x84, 0x94,
-	0x77, 0x40, 0x86, 0x62, 0x46, 0x45, 0x56, 0xbf, 0xd4, 0xf7, 0xb4, 0x2c, 0xc7, 0x52, 0x3c, 0xda,
-	0x5b, 0x86, 0x62, 0xa5, 0x0a, 0xc6, 0xcd, 0x0e, 0xee, 0x39, 0xbc, 0xfe, 0x72, 0x9b, 0x4b, 0x45,
-	0x01, 0xf5, 0x07, 0x42, 0x51, 0x0c, 0x84, 0xe2, 0x16, 0xb6, 0x9d, 0x64, 0x27, 0xe0, 0x66, 0x41,
-	0x27, 0xe0, 0x2b, 0x65, 0x1d, 0x8c, 0x35, 0x4d, 0x6a, 0xe6, 0x4f, 0xb3, 0x62, 0xce, 0x1f, 0x7a,
-	0x5a, 0xba, 0xef, 0x69, 0x39, 0x6e, 0xe1, 0x6b, 0x18, 0x3e, 0x65, 0x30, 0x54, 0xe5, 0xda, 0xb7,
-	0x0f, 0xb4, 0xd4, 0xdf, 0x0f, 0xb4, 0x94, 0x9f, 0x14, 0x11, 0xbb, 0x9f, 0x90, 0x42, 0x98, 0x90,
-	0x61, 0x0c, 0xc3, 0xeb, 0x40, 0x1b, 0xa1, 0x92, 0xc5, 0xad, 0x82, 0x09, 0x82, 0xbe, 0xe8, 0x21,
-	0xa7, 0x81, 0x82, 0x6e, 0x12, 0xac, 0xe1, 0x3f, 0xa7, 0x81, 0x5a, 0x25, 0xd6, 0x7b, 0xb6, 0x63,
-	0xb6, 0xed, 0x2f, 0xb9, 0xfd, 0xc7, 0x36, 0x6d, 0x35, 0x5d, 0x73, 0xdf, 0x6c, 0xff, 0xc7, 0x15,
-	0xa9, 0x5c, 0x03, 0x73, 0xfb, 0xd2, 0xb9, 0x3f, 0x4e, 0xf1, 0x2e, 0xc9, 0x8f, 0x2d, 0x9f, 0x5a,
-	0x9d, 0xd4, 0xb3, 0x3e, 0x7f, 0x9c, 0xb0, 0xd9, 0x10, 0xb3, 0xc3, 0x20, 0xaf, 0xa2, 0xcc, 0x6e,
-	0x81, 0x09, 0x17, 0x35, 0x90, 0xbd, 0x87, 0x5c, 0x96, 0xb1, 0x58, 0x07, 0x0d, 0x34, 0x47, 0x74,
-	0xd0, 0x00, 0xa2, 0x94, 0x22, 0x6c, 0x8f, 0xb3, 0xd8, 0xcf, 0x86, 0x1b, 0x49, 0xde, 0xc3, 0x14,
-	0x44, 0xca, 0xee, 0xcc, 0xab, 0x29, 0xbb, 0x33, 0x7b, 0xc8, 0x25, 0x36, 0x76, 0xf2, 0x13, 0xac,
-	0xf2, 0x94, 0x70, 0x34, 0x0a, 0x05, 0x34, 0x02, 0x88, 0x72, 0x15, 0x00, 0x42, 0x4d, 0x8a, 0x78,
-	0xdf, 0xcd, 0x32, 0x83, 0x73, 0x61, 0x07, 0x0b, 0x75, 0xd0, 0xc8, 0xb2, 0x85, 0xdf, 0x75, 0xfd,
-	0x1c, 0x13, 0x8a, 0x5d, 0xd3, 0x12, 0x76, 0x80, 0xd9, 0x45, 0x72, 0x1c, 0xd5, 0x42, 0x23, 0x27,
-	0x96, 0xcc, 0xf6, 0x36, 0x98, 0x6b, 0x9b, 0x14, 0x11, 0x2a, 0x26, 0x42, 0xcb, 0x24, 0xad, 0x7c,
-	0x8e, 0x6d, 0x70, 0xa1, 0xef, 0x69, 0x79, 0x31, 0x30, 0x92, 0x10, 0x68, 0xcc, 0x70, 0x19, 0x1b,
-	0x1b, 0xb7, 0x4d, 0xd2, 0xaa, 0x94, 0x13, 0x9f, 0xca, 0x4a, 0xf8, 0xa9, 0x8c, 0xa8, 0x67, 0x78,
-	0x11, 0xc0, 0xd1, 0x5a, 0xd9, 0xd1, 0x7e, 0xcc, 0x80, 0xb9, 0x2a, 0xb1, 0x3e, 0xea, 0x36, 0x4d,
-	0x8a, 0x76, 0x82, 0xd1, 0x78, 0x07, 0x64, 0xcd, 0x1e, 0x6d, 0x61, 0xd7, 0xa6, 0x07, 0x83, 0x77,
-	0x30, 0xa9, 0x3a, 0xe2, 0x0e, 0x26, 0x31, 0x27, 0xf9, 0xae, 0x0c, 0x30, 0xe9, 0xa0, 0xfd, 0x9a,
-	0x1c, 0xf3, 0xbc, 0xbd, 0x95, 0x42, 0xce, 0xa3, 0xda, 0xd1, 0x87, 0xc8, 0x39, 0x68, 0x3f, 0x08,
-	0xa9, 0x72, 0x85, 0x5d, 0xcf, 0xe4, 0xb1, 0x7c, 0x12, 0xf3, 0x21, 0x89, 0xf1, 0xf8, 0xe1, 0x2e,
-	0x58, 0x1a, 0x10, 0xbe, 0xc4, 0x00, 0x55, 0xfe, 0x3f, 0x78, 0x4f, 0x60, 0x91, 0x27, 0xee, 0x02,
-	0xf0, 0xa7, 0x0c, 0x38, 0x2b, 0x1d, 0x6d, 0x85, 0xd3, 0xf1, 0x0d, 0xf3, 0xff, 0x09, 0x98, 0xf6,
-	0x19, 0x8e, 0xcc, 0x7b, 0x9e, 0x81, 0x72, 0xdf, 0xd3, 0xce, 0x85, 0x19, 0x38, 0xce, 0xcc, 0x9f,
-	0x72, 0xd0, 0x7e, 0x18, 0x58, 0x65, 0x63, 0x30, 0x0b, 0x6a, 0x32, 0x0b, 0x21, 0x1c, 0xb6, 0xc0,
-	0xf9, 0x21, 0xe2, 0xd7, 0x91, 0x89, 0x87, 0x19, 0xa0, 0x48, 0x57, 0xec, 0x52, 0xbe, 0xed, 0xec,
-	0xe2, 0x37, 0x9d, 0x08, 0xc4, 0x13, 0xc1, 0xdf, 0x1c, 0xb6, 0xb3, 0xcb, 0x27, 0x7d, 0x6e, 0xf3,
-	0xfc, 0x90, 0xdb, 0x7b, 0x70, 0x66, 0x1d, 0x8a, 0xce, 0x19, 0xc9, 0x54, 0xb8, 0x81, 0xe8, 0xa0,
-	0xfe, 0xf7, 0x25, 0x2d, 0x2a, 0xeb, 0x83, 0x59, 0x59, 0x4a, 0x66, 0x45, 0xa2, 0xa1, 0xc5, 0xc6,
-	0x68, 0x42, 0xfa, 0x3a, 0x72, 0xf2, 0x2b, 0xbf, 0x86, 0x8a, 0xcf, 0xd0, 0x74, 0xcd, 0x0e, 0x79,
-	0xa5, 0x09, 0xd9, 0x02, 0xe3, 0x5d, 0xb6, 0xab, 0x78, 0x13, 0xe5, 0x07, 0x59, 0xe5, 0x5e, 0xf5,
-	0xb9, 0x70, 0x10, 0x71, 0x0b, 0x68, 0x08, 0x53, 0x7e, 0x2b, 0x8f, 0x73, 0xb7, 0x30, 0xd0, 0x57,
-	0xb8, 0x0d, 0xbf, 0x58, 0x46, 0x45, 0x01, 0x6b, 0x9b, 0xdf, 0x4f, 0x80, 0x53, 0x55, 0x62, 0x29,
-	0x9f, 0x82, 0x5c, 0xf4, 0x2d, 0xbc, 0x3c, 0x78, 0xa2, 0xf8, 0xcb, 0x51, 0x5d, 0x7d, 0x11, 0x42,
-	0x26, 0xe6, 0x73, 0x30, 0x19, 0x7b, 0x57, 0xae, 0x0c, 0xb5, 0x8c, 0x42, 0xd4, 0xcb, 0x2f, 0x84,
-	0xc8, 0xdd, 0x6b, 0x60, 0x2a, 0xfe, 0x4c, 0x83, 0x43, 0x6d, 0x63, 0x18, 0x75, 0xed, 0xc5, 0x98,
-	0xe8, 0xf1, 0x63, 0xef, 0x91, 0xe1, 0xc7, 0x8f, 0x42, 0x46, 0x1c, 0x7f, 0xd8, 0xc5, 0x5e, 0xa1,
-	0x60, 0x7e, 0xe8, 0xa5, 0x7e, 0xf8, 0x16, 0xc3, 0xa0, 0x6a, 0xf9, 0xd8, 0x50, 0xe9, 0xf5, 0x2b,
-	0xb0, 0x38, 0xea, 0x36, 0xba, 0x3e, 0x74, 0xb7, 0x11, 0x68, 0xf5, 0xea, 0xcb, 0xa0, 0xa5, 0xfb,
-	0x3a, 0x98, 0x4e, 0xcc, 0xfd, 0xff, 0x0d, 0xdd, 0x27, 0x0e, 0x52, 0xaf, 0x1c, 0x03, 0x24, 0x7d,
-	0xb4, 0xc0, 0xec, 0xc0, 0x74, 0xbb, 0x74, 0xc4, 0x06, 0x21, 0x4c, 0xdd, 0x38, 0x16, 0x4c, 0x7a,
-	0x42, 0x60, 0x26, 0xd9, 0xbd, 0x2f, 0x1e, 0xb1, 0x83, 0x44, 0xa9, 0xeb, 0xc7, 0x41, 0x45, 0xeb,
-	0x30, 0xd6, 0x90, 0x56, 0x8e, 0x62, 0x83, 0x41, 0x46, 0xd4, 0xe1, 0xb0, 0x3e, 0xa0, 0x9e, 0xfe,
-	0xda, 0x6f, 0xcf, 0xfa, 0x9d, 0xc3, 0xbf, 0x0a, 0xa9, 0xc3, 0x27, 0x85, 0xf4, 0xe3, 0x27, 0x85,
-	0xf4, 0x9f, 0x4f, 0x0a, 0xe9, 0x1f, 0x9e, 0x16, 0x52, 0x8f, 0x9f, 0x16, 0x52, 0x7f, 0x3c, 0x2d,
-	0xa4, 0x3e, 0x5b, 0xb7, 0x6c, 0xda, 0xea, 0xd5, 0x8b, 0x0d, 0xdc, 0x29, 0xd9, 0xac, 0xbe, 0x36,
-	0xda, 0x66, 0x9d, 0x94, 0xee, 0xee, 0xb0, 0x5f, 0xda, 0xee, 0x07, 0xbf, 0xb5, 0xb1, 0x1f, 0xda,
-	0xea, 0xe3, 0xec, 0x97, 0xb6, 0xb7, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x1b, 0x46, 0x30, 0xc2,
-	0x33, 0x14, 0x00, 0x00,
+	// 1597 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xbd, 0x6f, 0x1b, 0xc7,
+	0x12, 0x27, 0x69, 0x59, 0x16, 0x97, 0xfa, 0x3c, 0xcb, 0x12, 0x75, 0x36, 0x78, 0xd2, 0x3e, 0xfb,
+	0x3d, 0x59, 0x96, 0x48, 0x50, 0xcf, 0xcf, 0x0f, 0x20, 0xe0, 0xc2, 0x27, 0x23, 0xb6, 0x0c, 0x30,
+	0x16, 0x2e, 0x09, 0xf2, 0x01, 0x03, 0xc4, 0x91, 0x5c, 0x1d, 0x0f, 0x26, 0x6f, 0x99, 0xdb, 0xa5,
+	0x64, 0x05, 0x08, 0x10, 0xa4, 0x0a, 0x52, 0x05, 0x48, 0x1d, 0xc0, 0xa5, 0x4b, 0x17, 0x41, 0xfe,
+	0x06, 0x35, 0x01, 0x8c, 0x20, 0x45, 0xaa, 0x43, 0x62, 0x17, 0x4e, 0x91, 0xc2, 0x60, 0xeb, 0x26,
+	0xb8, 0xdd, 0xbd, 0xbd, 0x0f, 0x92, 0xb2, 0x2c, 0xd8, 0x71, 0x23, 0x68, 0x67, 0x7e, 0xb3, 0x3b,
+	0xf3, 0x9b, 0xb9, 0x99, 0x5d, 0x82, 0x25, 0xdc, 0xb5, 0x1d, 0x9b, 0x96, 0x70, 0xb7, 0x85, 0x09,
+	0x2d, 0xed, 0x95, 0x4b, 0xf4, 0x41, 0xb1, 0xeb, 0x62, 0x8a, 0x95, 0x59, 0xae, 0x2a, 0x72, 0x55,
+	0x71, 0xaf, 0xac, 0xce, 0x99, 0x1d, 0xdb, 0xc1, 0x25, 0xf6, 0x97, 0x83, 0xd4, 0x42, 0x03, 0x93,
+	0x0e, 0x26, 0xa5, 0xba, 0x49, 0x50, 0x69, 0xaf, 0x5c, 0x47, 0xd4, 0x2c, 0x97, 0x1a, 0xd8, 0x76,
+	0x84, 0x7e, 0x51, 0xe8, 0x3b, 0xc4, 0xf2, 0x37, 0xef, 0x10, 0x4b, 0x28, 0x96, 0xb8, 0xa2, 0xc6,
+	0x56, 0x25, 0xbe, 0x10, 0xaa, 0x79, 0x0b, 0x5b, 0x98, 0xcb, 0xfd, 0xff, 0x84, 0xf4, 0xc2, 0xa0,
+	0xa7, 0x07, 0x5d, 0x24, 0x6c, 0x60, 0x3f, 0x0d, 0xa6, 0xab, 0xc4, 0x32, 0x50, 0x03, 0xbb, 0x4d,
+	0xdd, 0xa4, 0x8d, 0x96, 0x72, 0x07, 0x64, 0x49, 0xaf, 0xde, 0xb1, 0x29, 0x45, 0x6e, 0x3e, 0xbd,
+	0x9c, 0x5e, 0xcd, 0xea, 0xeb, 0x7d, 0x4f, 0x9b, 0x3d, 0x30, 0x3b, 0xed, 0x0a, 0x94, 0x2a, 0xf8,
+	0xcb, 0x8f, 0x1b, 0xf3, 0xe2, 0xfc, 0x1b, 0xcd, 0xa6, 0x8b, 0x08, 0xf9, 0x80, 0xba, 0xb6, 0x63,
+	0x19, 0xa1, 0xb9, 0x52, 0x06, 0xd9, 0xba, 0x6b, 0x37, 0x2d, 0x54, 0xb3, 0x9b, 0xf9, 0xcc, 0x72,
+	0x7a, 0x75, 0x4c, 0x9f, 0x0f, 0xf7, 0x92, 0x2a, 0x68, 0x4c, 0xf0, 0xff, 0xb7, 0x9b, 0xca, 0xff,
+	0x41, 0xae, 0xee, 0xfb, 0x51, 0xab, 0x1f, 0x50, 0x44, 0xf2, 0xa7, 0x96, 0xd3, 0xab, 0x93, 0xfa,
+	0x42, 0xdf, 0xd3, 0x14, 0x61, 0x14, 0x2a, 0xa1, 0x01, 0xd8, 0x4a, 0xf7, 0x17, 0x95, 0xd5, 0xaf,
+	0x9f, 0x3f, 0x5e, 0x0b, 0xcf, 0xfe, 0xf6, 0xf9, 0xe3, 0xb5, 0x73, 0x22, 0xe8, 0x78, 0x84, 0x30,
+	0x0f, 0x16, 0xe2, 0x12, 0x03, 0x91, 0x2e, 0x76, 0x08, 0x82, 0xbf, 0xa6, 0xc1, 0x4c, 0x95, 0x58,
+	0x5b, 0x2e, 0x32, 0x29, 0xd2, 0x99, 0x4b, 0xca, 0x4d, 0x70, 0xa6, 0xe1, 0xaf, 0x71, 0xc0, 0xc6,
+	0x5a, 0xdf, 0xd3, 0xa6, 0xb9, 0x33, 0x42, 0x31, 0x9a, 0x8b, 0xc0, 0x54, 0x31, 0xc0, 0x78, 0x03,
+	0x3b, 0xbb, 0xb6, 0xc5, 0x68, 0xc8, 0x6d, 0x16, 0x8a, 0xc9, 0x32, 0x29, 0xf2, 0xf3, 0xb6, 0x18,
+	0x4a, 0x57, 0x0f, 0x3d, 0x2d, 0xd5, 0xf7, 0xb4, 0x29, 0x71, 0x10, 0x93, 0xc2, 0x47, 0xcf, 0x1f,
+	0xaf, 0xa5, 0x0d, 0xb1, 0x53, 0xe5, 0x3f, 0x7e, 0xc4, 0xc1, 0x09, 0x7e, 0xbc, 0x0b, 0x61, 0xbc,
+	0xd1, 0x10, 0xe0, 0x35, 0xb0, 0x98, 0x10, 0x05, 0x11, 0x2b, 0xe7, 0xa3, 0x19, 0xf2, 0xe3, 0x1b,
+	0x0b, 0x73, 0x01, 0x7f, 0xca, 0x80, 0xd9, 0x2a, 0xb1, 0x76, 0x5c, 0xdc, 0xc5, 0x04, 0xdd, 0xed,
+	0xd1, 0x6e, 0x8f, 0x2a, 0xb7, 0xc0, 0x44, 0x97, 0x0b, 0x02, 0x42, 0xae, 0xf4, 0x3d, 0x6d, 0x86,
+	0xfb, 0x19, 0x68, 0x46, 0x33, 0x22, 0x8d, 0x4f, 0x52, 0x1c, 0x3a, 0x98, 0x69, 0x6f, 0xd6, 0xea,
+	0x6d, 0xdc, 0xb8, 0x5f, 0x73, 0x7a, 0x9d, 0x3a, 0x72, 0x59, 0x81, 0x8c, 0xe9, 0x6a, 0xdf, 0xd3,
+	0x16, 0xb8, 0x61, 0x02, 0x00, 0x8d, 0xa9, 0xf6, 0xa6, 0xee, 0x0b, 0xde, 0x67, 0x6b, 0xbf, 0xc0,
+	0x30, 0x8b, 0xa4, 0xe6, 0x62, 0x4c, 0xf3, 0x63, 0xc9, 0x02, 0x8b, 0x28, 0xa1, 0x01, 0xf8, 0xca,
+	0xc0, 0x98, 0x56, 0x2e, 0xfb, 0x74, 0x4b, 0xf7, 0x7d, 0xbe, 0x17, 0x43, 0xbe, 0x63, 0x1c, 0xc1,
+	0xeb, 0x20, 0x9f, 0x94, 0x49, 0xc6, 0x57, 0xc0, 0xa4, 0x38, 0xc2, 0x76, 0x9a, 0xe8, 0x81, 0x20,
+	0x5d, 0xf8, 0xb4, 0xed, 0x8b, 0xe0, 0x4b, 0x5e, 0x86, 0x37, 0x51, 0x1b, 0xd1, 0x80, 0xf6, 0x2a,
+	0x00, 0x8d, 0x96, 0xd9, 0x6e, 0x23, 0xc7, 0x92, 0xc4, 0x6f, 0xf4, 0x3d, 0x6d, 0x4e, 0x14, 0x88,
+	0xd4, 0x8d, 0xa6, 0x3e, 0xb2, 0xc1, 0x49, 0xc8, 0xaf, 0x24, 0x1c, 0xe7, 0xcc, 0x2f, 0xf6, 0x3d,
+	0xed, 0x6c, 0x8c, 0x39, 0xa6, 0x85, 0xb1, 0x88, 0x2a, 0x6b, 0x3e, 0x77, 0x91, 0xf3, 0x13, 0xd5,
+	0x1a, 0x8d, 0x14, 0x2e, 0xb1, 0x6a, 0x8d, 0x8a, 0xe4, 0xf7, 0xf9, 0x32, 0xc3, 0x74, 0xdb, 0x8e,
+	0x4d, 0x6d, 0x93, 0xa2, 0x0f, 0xf1, 0x7d, 0xe4, 0xdc, 0x44, 0x5d, 0x4c, 0x6c, 0xaa, 0xdc, 0x00,
+	0xe3, 0x04, 0x39, 0x4d, 0x49, 0xce, 0xe5, 0xf0, 0xeb, 0xe1, 0xf2, 0xd1, 0xc4, 0x08, 0xc3, 0x93,
+	0x90, 0xf2, 0x3f, 0x90, 0xa1, 0x98, 0x51, 0x91, 0xd5, 0x2f, 0xf5, 0x3d, 0x2d, 0xcb, 0xb1, 0x14,
+	0x8f, 0x3e, 0x2d, 0x43, 0xb1, 0x52, 0x05, 0xe3, 0x66, 0x07, 0xf7, 0x1c, 0x5e, 0x7f, 0xb9, 0xcd,
+	0xa5, 0xa2, 0x80, 0xfa, 0x03, 0xa1, 0x28, 0x06, 0x42, 0x71, 0x0b, 0xdb, 0x4e, 0xb2, 0x13, 0x70,
+	0xb3, 0xa0, 0x13, 0xf0, 0x95, 0xb2, 0x0e, 0xc6, 0x9a, 0x26, 0x35, 0xf3, 0xa7, 0x59, 0x31, 0xe7,
+	0x0f, 0x3d, 0x2d, 0xdd, 0xf7, 0xb4, 0x1c, 0xb7, 0xf0, 0x35, 0x0c, 0x9f, 0x32, 0x18, 0xaa, 0x72,
+	0xed, 0x9b, 0x87, 0x5a, 0xea, 0xcf, 0x87, 0x5a, 0xca, 0x4f, 0x8a, 0x88, 0xdd, 0x4f, 0x48, 0x21,
+	0x4c, 0xc8, 0x30, 0x86, 0xe1, 0x75, 0xa0, 0x8d, 0x50, 0xc9, 0xe2, 0x56, 0xc1, 0x04, 0x41, 0x9f,
+	0xf7, 0x90, 0xd3, 0x40, 0x41, 0x37, 0x09, 0xd6, 0xf0, 0xaf, 0xd3, 0x40, 0xad, 0x12, 0xeb, 0x3d,
+	0xdb, 0x31, 0xdb, 0xf6, 0x17, 0xdc, 0xfe, 0x63, 0x9b, 0xb6, 0x9a, 0xae, 0xb9, 0x6f, 0xb6, 0xff,
+	0xe1, 0x8a, 0x54, 0xae, 0x81, 0xb9, 0x7d, 0x79, 0xb8, 0x3f, 0x4e, 0xf1, 0x2e, 0xc9, 0x8f, 0x2d,
+	0x9f, 0x5a, 0x9d, 0xd4, 0xb3, 0x3e, 0x7f, 0x9c, 0xb0, 0xd9, 0x10, 0xb3, 0xc3, 0x20, 0x6f, 0xa2,
+	0xcc, 0x6e, 0x81, 0x09, 0x17, 0x35, 0x90, 0xbd, 0x87, 0x5c, 0x96, 0xb1, 0x58, 0x07, 0x0d, 0x34,
+	0x47, 0x74, 0xd0, 0x00, 0xa2, 0x94, 0x22, 0x6c, 0x8f, 0xb3, 0xd8, 0xcf, 0x86, 0x1b, 0x49, 0xde,
+	0xc3, 0x14, 0x44, 0xca, 0xee, 0xcc, 0x9b, 0x29, 0xbb, 0x33, 0x7b, 0xc8, 0x25, 0x36, 0x76, 0xf2,
+	0x13, 0xac, 0xf2, 0x94, 0x70, 0x34, 0x0a, 0x05, 0x34, 0x02, 0x88, 0x72, 0x15, 0x00, 0x42, 0x4d,
+	0x8a, 0x78, 0xdf, 0xcd, 0x32, 0x83, 0x73, 0x61, 0x07, 0x0b, 0x75, 0xd0, 0xc8, 0xb2, 0x85, 0xdf,
+	0x75, 0xfd, 0x1c, 0x13, 0x8a, 0x5d, 0xd3, 0x12, 0x76, 0x80, 0xd9, 0x45, 0x72, 0x1c, 0xd5, 0x42,
+	0x23, 0x27, 0x96, 0xcc, 0xf6, 0x36, 0x98, 0x6b, 0x9b, 0x14, 0x11, 0x2a, 0x26, 0x42, 0xcb, 0x24,
+	0xad, 0x7c, 0x8e, 0x6d, 0x70, 0xa1, 0xef, 0x69, 0x79, 0x31, 0x30, 0x92, 0x10, 0x68, 0xcc, 0x70,
+	0x19, 0x1b, 0x1b, 0xb7, 0x4d, 0xd2, 0xaa, 0x94, 0x13, 0x9f, 0xca, 0x4a, 0xf8, 0xa9, 0x8c, 0xa8,
+	0x67, 0x78, 0x11, 0xc0, 0xd1, 0x5a, 0xd9, 0xd1, 0xbe, 0xcf, 0x80, 0xb9, 0x2a, 0xb1, 0x3e, 0xea,
+	0x36, 0x4d, 0x8a, 0x76, 0x82, 0xd1, 0x78, 0x07, 0x64, 0xcd, 0x1e, 0x6d, 0x61, 0xd7, 0xa6, 0x07,
+	0x83, 0x77, 0x30, 0xa9, 0x3a, 0xe2, 0x0e, 0x26, 0x31, 0x27, 0xf9, 0xae, 0x0c, 0x30, 0xe9, 0xa0,
+	0xfd, 0x9a, 0x1c, 0xf3, 0xbc, 0xbd, 0x95, 0x42, 0xce, 0xa3, 0xda, 0xd1, 0x4e, 0xe4, 0x1c, 0xb4,
+	0x1f, 0x84, 0x54, 0xb9, 0xc2, 0xae, 0x67, 0xd2, 0x2d, 0x9f, 0xc4, 0x7c, 0x48, 0x62, 0x3c, 0x7e,
+	0xb8, 0x0b, 0x96, 0x06, 0x84, 0xaf, 0x31, 0x40, 0x95, 0x7f, 0x0f, 0xde, 0x13, 0x58, 0xe4, 0x89,
+	0xbb, 0x00, 0xfc, 0x21, 0x03, 0xce, 0xca, 0x83, 0xb6, 0xc2, 0xe9, 0xf8, 0x8e, 0xf9, 0xff, 0x04,
+	0x4c, 0xfb, 0x0c, 0x47, 0xe6, 0x3d, 0xcf, 0x40, 0xb9, 0xef, 0x69, 0xe7, 0xc2, 0x0c, 0x1c, 0x67,
+	0xe6, 0x4f, 0x39, 0x68, 0x3f, 0x0c, 0xac, 0xb2, 0x31, 0x98, 0x05, 0x35, 0x99, 0x85, 0x10, 0x0e,
+	0x5b, 0xe0, 0xfc, 0x10, 0xf1, 0xdb, 0xc8, 0xc4, 0xa3, 0x0c, 0x50, 0xe4, 0x51, 0xec, 0x52, 0xbe,
+	0xed, 0xec, 0xe2, 0x77, 0x9d, 0x08, 0xc4, 0x13, 0xc1, 0xdf, 0x1c, 0xb6, 0xb3, 0xcb, 0x27, 0x7d,
+	0x6e, 0xf3, 0xfc, 0x90, 0xdb, 0x7b, 0xe0, 0xb3, 0x0e, 0x45, 0xe7, 0x8c, 0x64, 0x2a, 0xdc, 0x40,
+	0x74, 0x50, 0xff, 0xfb, 0x92, 0x16, 0x95, 0xf5, 0xc1, 0xac, 0x2c, 0x25, 0xb3, 0x22, 0xd1, 0xd0,
+	0x62, 0x63, 0x34, 0x21, 0x7d, 0x1b, 0x39, 0x79, 0x91, 0x8e, 0xf4, 0xa6, 0x2a, 0xa2, 0xa6, 0x7f,
+	0x7b, 0x78, 0xd7, 0x29, 0x29, 0x81, 0x89, 0x8e, 0x70, 0x45, 0x3c, 0x0e, 0x23, 0x33, 0x2f, 0xd0,
+	0x40, 0x43, 0x82, 0x8e, 0xd5, 0x78, 0x82, 0xe0, 0x62, 0x8d, 0x27, 0x10, 0xbe, 0x0d, 0x6a, 0x7f,
+	0xe6, 0x37, 0x7c, 0xd1, 0xe1, 0x4c, 0xd7, 0xec, 0x90, 0x37, 0x4a, 0xec, 0x16, 0x18, 0xef, 0xb2,
+	0x5d, 0xc5, 0x73, 0x33, 0x3f, 0x58, 0xb0, 0xfc, 0x54, 0x7d, 0x2e, 0x9c, 0xf1, 0xdc, 0x02, 0x1a,
+	0xc2, 0x94, 0x3f, 0x78, 0xe2, 0xcc, 0x2d, 0x0c, 0xb4, 0x6c, 0x6e, 0xc3, 0xef, 0xec, 0x51, 0x51,
+	0xc0, 0xda, 0xe6, 0x8b, 0x09, 0x70, 0xaa, 0x4a, 0x2c, 0xe5, 0x53, 0x90, 0x8b, 0xfe, 0xcc, 0xb0,
+	0x3c, 0xe8, 0x51, 0xfc, 0x51, 0xae, 0xae, 0xbe, 0x0a, 0x21, 0x13, 0x73, 0x0f, 0x4c, 0xc6, 0x9e,
+	0xec, 0x2b, 0x43, 0x2d, 0xa3, 0x10, 0xf5, 0xf2, 0x2b, 0x21, 0x72, 0xf7, 0x1a, 0x98, 0x8a, 0xbf,
+	0x80, 0xe1, 0x50, 0xdb, 0x18, 0x46, 0x5d, 0x7b, 0x35, 0x26, 0xea, 0x7e, 0xec, 0xa9, 0x37, 0xdc,
+	0xfd, 0x28, 0x64, 0x84, 0xfb, 0xc3, 0xde, 0x4c, 0x0a, 0x05, 0xf3, 0x43, 0xdf, 0x4b, 0xc3, 0xb7,
+	0x18, 0x06, 0x55, 0xcb, 0xc7, 0x86, 0xca, 0x53, 0xbf, 0x04, 0x8b, 0xa3, 0x2e, 0xfa, 0xeb, 0x43,
+	0x77, 0x1b, 0x81, 0x56, 0xaf, 0xbe, 0x0e, 0x5a, 0x1e, 0x5f, 0x07, 0xd3, 0x89, 0x2b, 0xd5, 0xbf,
+	0x86, 0xee, 0x13, 0x07, 0xa9, 0x57, 0x8e, 0x01, 0x92, 0x67, 0xb4, 0xc0, 0xec, 0xc0, 0xc5, 0xe1,
+	0xd2, 0x11, 0x1b, 0x84, 0x30, 0x75, 0xe3, 0x58, 0x30, 0x79, 0x12, 0x02, 0x33, 0xc9, 0xc1, 0x78,
+	0xf1, 0x88, 0x1d, 0x24, 0x4a, 0x5d, 0x3f, 0x0e, 0x6a, 0x90, 0x34, 0xd9, 0xeb, 0x8f, 0x22, 0x2d,
+	0x00, 0x1d, 0x49, 0xda, 0x40, 0x0f, 0xbd, 0x07, 0x26, 0x63, 0x4d, 0x6f, 0xe5, 0x28, 0xc6, 0x19,
+	0x64, 0x44, 0xad, 0x0f, 0xeb, 0x35, 0xea, 0xe9, 0xaf, 0xfc, 0xe9, 0xaa, 0xdf, 0x39, 0xfc, 0xa3,
+	0x90, 0x3a, 0x7c, 0x5a, 0x48, 0x3f, 0x79, 0x5a, 0x48, 0xff, 0xfe, 0xb4, 0x90, 0xfe, 0xee, 0x59,
+	0x21, 0xf5, 0xe4, 0x59, 0x21, 0xf5, 0xdb, 0xb3, 0x42, 0xea, 0xb3, 0x75, 0xcb, 0xa6, 0xad, 0x5e,
+	0xbd, 0xd8, 0xc0, 0x9d, 0x92, 0xcd, 0x6a, 0x78, 0xa3, 0x6d, 0xd6, 0x49, 0xe9, 0xee, 0x0e, 0xfb,
+	0xa1, 0xf4, 0x41, 0xf0, 0x53, 0x29, 0xfb, 0x9d, 0xb4, 0x3e, 0xce, 0x7e, 0x28, 0xfd, 0xef, 0xdf,
+	0x01, 0x00, 0x00, 0xff, 0xff, 0x19, 0xff, 0xe3, 0x9a, 0xf2, 0x15, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -994,6 +1082,8 @@ type MsgClient interface {
 	UpdateChallenger(ctx context.Context, in *MsgUpdateChallenger, opts ...grpc.CallOption) (*MsgUpdateChallengerResponse, error)
 	// UpdateBatchInfo defines a rpc handler method for MsgUpdateBatchInfo.
 	UpdateBatchInfo(ctx context.Context, in *MsgUpdateBatchInfo, opts ...grpc.CallOption) (*MsgUpdateBatchInfoResponse, error)
+	// UpdateMetadata defines a rpc handler method for MsgUpdateMetadata.
+	UpdateMetadata(ctx context.Context, in *MsgUpdateMetadata, opts ...grpc.CallOption) (*MsgUpdateMetadataResponse, error)
 	// UpdateParams defines an operation for updating the
 	// x/opchild module parameters.
 	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
@@ -1088,6 +1178,15 @@ func (c *msgClient) UpdateBatchInfo(ctx context.Context, in *MsgUpdateBatchInfo,
 	return out, nil
 }
 
+func (c *msgClient) UpdateMetadata(ctx context.Context, in *MsgUpdateMetadata, opts ...grpc.CallOption) (*MsgUpdateMetadataResponse, error) {
+	out := new(MsgUpdateMetadataResponse)
+	err := c.cc.Invoke(ctx, "/opinit.ophost.v1.Msg/UpdateMetadata", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
 	out := new(MsgUpdateParamsResponse)
 	err := c.cc.Invoke(ctx, "/opinit.ophost.v1.Msg/UpdateParams", in, out, opts...)
@@ -1117,6 +1216,8 @@ type MsgServer interface {
 	UpdateChallenger(context.Context, *MsgUpdateChallenger) (*MsgUpdateChallengerResponse, error)
 	// UpdateBatchInfo defines a rpc handler method for MsgUpdateBatchInfo.
 	UpdateBatchInfo(context.Context, *MsgUpdateBatchInfo) (*MsgUpdateBatchInfoResponse, error)
+	// UpdateMetadata defines a rpc handler method for MsgUpdateMetadata.
+	UpdateMetadata(context.Context, *MsgUpdateMetadata) (*MsgUpdateMetadataResponse, error)
 	// UpdateParams defines an operation for updating the
 	// x/opchild module parameters.
 	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
@@ -1153,6 +1254,9 @@ func (*UnimplementedMsgServer) UpdateChallenger(ctx context.Context, req *MsgUpd
 func (*UnimplementedMsgServer) UpdateBatchInfo(ctx context.Context, req *MsgUpdateBatchInfo) (*MsgUpdateBatchInfoResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method UpdateBatchInfo not implemented")
 }
+func (*UnimplementedMsgServer) UpdateMetadata(ctx context.Context, req *MsgUpdateMetadata) (*MsgUpdateMetadataResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UpdateMetadata not implemented")
+}
 func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
 }
@@ -1323,6 +1427,24 @@ func _Msg_UpdateBatchInfo_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_UpdateMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgUpdateMetadata)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).UpdateMetadata(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/opinit.ophost.v1.Msg/UpdateMetadata",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).UpdateMetadata(ctx, req.(*MsgUpdateMetadata))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgUpdateParams)
 	if err := dec(in); err != nil {
@@ -1381,6 +1503,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "UpdateBatchInfo",
 			Handler:    _Msg_UpdateBatchInfo_Handler,
 		},
+		{
+			MethodName: "UpdateMetadata",
+			Handler:    _Msg_UpdateMetadata_Handler,
+		},
 		{
 			MethodName: "UpdateParams",
 			Handler:    _Msg_UpdateParams_Handler,
@@ -2098,6 +2224,81 @@ func (m *MsgUpdateBatchInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, err
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgUpdateMetadata) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgUpdateMetadata) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgUpdateMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Metadata) > 0 {
+		i -= len(m.Metadata)
+		copy(dAtA[i:], m.Metadata)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Metadata)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.BridgeId != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.BridgeId))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Authority) > 0 {
+		i -= len(m.Authority)
+		copy(dAtA[i:], m.Authority)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgUpdateMetadataResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgUpdateMetadataResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgUpdateMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.L2BlockNumber != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.L2BlockNumber))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.OutputIndex != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.OutputIndex))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2493,6 +2694,41 @@ func (m *MsgUpdateBatchInfoResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgUpdateMetadata) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Authority)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if m.BridgeId != 0 {
+		n += 1 + sovTx(uint64(m.BridgeId))
+	}
+	l = len(m.Metadata)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgUpdateMetadataResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.OutputIndex != 0 {
+		n += 1 + sovTx(uint64(m.OutputIndex))
+	}
+	if m.L2BlockNumber != 0 {
+		n += 1 + sovTx(uint64(m.L2BlockNumber))
+	}
+	return n
+}
+
 func (m *MsgUpdateParams) Size() (n int) {
 	if m == nil {
 		return 0
@@ -4642,6 +4878,229 @@ func (m *MsgUpdateBatchInfoResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgUpdateMetadata) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgUpdateMetadata: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgUpdateMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Authority = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BridgeId", wireType)
+			}
+			m.BridgeId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BridgeId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Metadata = append(m.Metadata[:0], dAtA[iNdEx:postIndex]...)
+			if m.Metadata == nil {
+				m.Metadata = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgUpdateMetadataResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgUpdateMetadataResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgUpdateMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OutputIndex", wireType)
+			}
+			m.OutputIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.OutputIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field L2BlockNumber", wireType)
+			}
+			m.L2BlockNumber = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.L2BlockNumber |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0