diff --git a/Dockerfile.wormchain b/Dockerfile.wormchain index 5fad1524f..5b92a2dd3 100644 --- a/Dockerfile.wormchain +++ b/Dockerfile.wormchain @@ -4,7 +4,6 @@ FROM docker.io/golang:1.19.0@sha256:4c00329e17be6fedd8bd4412df454a205348da00f9e0 RUN apt-get update RUN apt install -y netcat RUN apt install -y jq -RUN curl https://get.ignite.com/cli@v0.23.0 | bash && mv ignite /usr/local/bin/ WORKDIR /app @@ -24,7 +23,6 @@ EXPOSE 4500 RUN unset GOPATH -RUN make proto -B RUN make client RUN chmod +x /app/build/wormchaind RUN make validators diff --git a/wormchain/.gitignore b/wormchain/.gitignore index b5f5dfe57..8507f5aab 100644 --- a/wormchain/.gitignore +++ b/wormchain/.gitignore @@ -12,7 +12,6 @@ validators/first_validator/keyring-test validators/second_validator/keyring-test ts-sdk/node_modules ts-sdk/lib -*.pb.go .idea *.iml diff --git a/wormchain/Makefile b/wormchain/Makefile index 6cadca59f..fbfc9fdcd 100644 --- a/wormchain/Makefile +++ b/wormchain/Makefile @@ -1,14 +1,9 @@ PROTO_FILES=$(shell find proto -name "*.proto") GO_FILES=$(shell find . -name "*.go") IGNITE_EXPECTED_VERSION:=v0.23.0 -IGNITE_ACTUAL_VERSION:=$(shell ignite version | awk '/Ignite CLI version:/ { print $$4 }') # Address of the main tilt validator that the others should connect to TILT_VALADDRESS=wormholevaloper1cyyzpxplxdzkeea7kwsydadg87357qna87hzv8 -ifneq ("$(IGNITE_ACTUAL_VERSION)", "$(IGNITE_EXPECTED_VERSION)") - $(error "Expected ignite version $(IGNITE_EXPECTED_VERSION) but found $(IGNITE_ACTUAL_VERSION)") -endif - .PHONY: all all: client vue validators @@ -35,10 +30,13 @@ validators: mkdir -p validators/second_validator/keyring-test cp build/keyring-test/* validators/second_validator/keyring-test/ -build/wormchaind: cmd/wormchaind/main.go $(GO_FILES) proto +build/wormchaind: cmd/wormchaind/main.go $(GO_FILES) go build -o $@ $< -proto: $(PROTO_FILES) +check-ignite: + @ if [ "$(shell ignite version | awk '/Ignite CLI version:/ { print $$4 }')" != "$(IGNITE_EXPECTED_VERSION)" ] ; then echo "Expected ignite version $(IGNITE_EXPECTED_VERSION)" && exit 1 ; fi + +proto: check-ignite $(PROTO_FILES) ignite generate proto-go touch proto diff --git a/wormchain/readme.md b/wormchain/README.md similarity index 94% rename from wormchain/readme.md rename to wormchain/README.md index 47823c01a..f76495281 100644 --- a/wormchain/readme.md +++ b/wormchain/README.md @@ -11,12 +11,6 @@ curl https://get.ignite.com/cli@v0.23.0 | bash cp ignite ~/.local/bin/ ``` -Build the protobuf. - -``` -ignite generate proto-go -``` - Build and install wormchain. ``` diff --git a/wormchain/x/wormhole/types/config.pb.go b/wormchain/x/wormhole/types/config.pb.go new file mode 100644 index 000000000..1d4b6782b --- /dev/null +++ b/wormchain/x/wormhole/types/config.pb.go @@ -0,0 +1,429 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/config.proto + +package types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Config struct { + GuardianSetExpiration uint64 `protobuf:"varint,1,opt,name=guardian_set_expiration,json=guardianSetExpiration,proto3" json:"guardian_set_expiration,omitempty"` + GovernanceEmitter []byte `protobuf:"bytes,2,opt,name=governance_emitter,json=governanceEmitter,proto3" json:"governance_emitter,omitempty"` + GovernanceChain uint32 `protobuf:"varint,3,opt,name=governance_chain,json=governanceChain,proto3" json:"governance_chain,omitempty"` + ChainId uint32 `protobuf:"varint,4,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` +} + +func (m *Config) Reset() { *m = Config{} } +func (m *Config) String() string { return proto.CompactTextString(m) } +func (*Config) ProtoMessage() {} +func (*Config) Descriptor() ([]byte, []int) { + return fileDescriptor_14d08d38823c924a, []int{0} +} +func (m *Config) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Config.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 *Config) XXX_Merge(src proto.Message) { + xxx_messageInfo_Config.Merge(m, src) +} +func (m *Config) XXX_Size() int { + return m.Size() +} +func (m *Config) XXX_DiscardUnknown() { + xxx_messageInfo_Config.DiscardUnknown(m) +} + +var xxx_messageInfo_Config proto.InternalMessageInfo + +func (m *Config) GetGuardianSetExpiration() uint64 { + if m != nil { + return m.GuardianSetExpiration + } + return 0 +} + +func (m *Config) GetGovernanceEmitter() []byte { + if m != nil { + return m.GovernanceEmitter + } + return nil +} + +func (m *Config) GetGovernanceChain() uint32 { + if m != nil { + return m.GovernanceChain + } + return 0 +} + +func (m *Config) GetChainId() uint32 { + if m != nil { + return m.ChainId + } + return 0 +} + +func init() { + proto.RegisterType((*Config)(nil), "wormhole_foundation.wormchain.wormhole.Config") +} + +func init() { proto.RegisterFile("wormhole/config.proto", fileDescriptor_14d08d38823c924a) } + +var fileDescriptor_14d08d38823c924a = []byte{ + // 272 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2d, 0xcf, 0x2f, 0xca, + 0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b, 0x28, 0xca, 0x2f, + 0xc9, 0x17, 0x52, 0x83, 0x09, 0xc7, 0xa7, 0xe5, 0x97, 0xe6, 0xa5, 0x24, 0x96, 0x64, 0xe6, 0xe7, + 0xe9, 0x81, 0xc4, 0x92, 0x33, 0x12, 0x33, 0x21, 0x2c, 0x90, 0xac, 0x94, 0x48, 0x7a, 0x7e, 0x7a, + 0x3e, 0x58, 0x8b, 0x3e, 0x88, 0x05, 0xd1, 0xad, 0xb4, 0x95, 0x91, 0x8b, 0xcd, 0x19, 0x6c, 0x9c, + 0x90, 0x19, 0x97, 0x78, 0x7a, 0x69, 0x62, 0x51, 0x4a, 0x66, 0x62, 0x5e, 0x7c, 0x71, 0x6a, 0x49, + 0x7c, 0x6a, 0x45, 0x41, 0x66, 0x11, 0xd8, 0x38, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x96, 0x20, 0x51, + 0x98, 0x74, 0x70, 0x6a, 0x89, 0x2b, 0x5c, 0x52, 0x48, 0x97, 0x4b, 0x28, 0x3d, 0xbf, 0x2c, 0xb5, + 0x28, 0x2f, 0x31, 0x2f, 0x39, 0x35, 0x3e, 0x35, 0x37, 0xb3, 0xa4, 0x24, 0xb5, 0x48, 0x82, 0x49, + 0x81, 0x51, 0x83, 0x27, 0x48, 0x10, 0x21, 0xe3, 0x0a, 0x91, 0x10, 0xd2, 0xe4, 0x12, 0x40, 0x52, + 0x0e, 0x76, 0xa4, 0x04, 0xb3, 0x02, 0xa3, 0x06, 0x6f, 0x10, 0x3f, 0x42, 0xdc, 0x19, 0x24, 0x2c, + 0x24, 0xc9, 0xc5, 0x01, 0x96, 0x8f, 0xcf, 0x4c, 0x91, 0x60, 0x01, 0x2b, 0x61, 0x07, 0xf3, 0x3d, + 0x53, 0x9c, 0x82, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, + 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0xca, 0x32, 0x3d, + 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0xe6, 0x79, 0x5d, 0x44, 0xd0, 0xe8, + 0xc3, 0x83, 0x46, 0xbf, 0x02, 0x2e, 0xaf, 0x5f, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x0e, + 0x13, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xda, 0x45, 0x4d, 0x6a, 0x01, 0x00, 0x00, +} + +func (m *Config) 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 *Config) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Config) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ChainId != 0 { + i = encodeVarintConfig(dAtA, i, uint64(m.ChainId)) + i-- + dAtA[i] = 0x20 + } + if m.GovernanceChain != 0 { + i = encodeVarintConfig(dAtA, i, uint64(m.GovernanceChain)) + i-- + dAtA[i] = 0x18 + } + if len(m.GovernanceEmitter) > 0 { + i -= len(m.GovernanceEmitter) + copy(dAtA[i:], m.GovernanceEmitter) + i = encodeVarintConfig(dAtA, i, uint64(len(m.GovernanceEmitter))) + i-- + dAtA[i] = 0x12 + } + if m.GuardianSetExpiration != 0 { + i = encodeVarintConfig(dAtA, i, uint64(m.GuardianSetExpiration)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintConfig(dAtA []byte, offset int, v uint64) int { + offset -= sovConfig(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Config) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GuardianSetExpiration != 0 { + n += 1 + sovConfig(uint64(m.GuardianSetExpiration)) + } + l = len(m.GovernanceEmitter) + if l > 0 { + n += 1 + l + sovConfig(uint64(l)) + } + if m.GovernanceChain != 0 { + n += 1 + sovConfig(uint64(m.GovernanceChain)) + } + if m.ChainId != 0 { + n += 1 + sovConfig(uint64(m.ChainId)) + } + return n +} + +func sovConfig(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozConfig(x uint64) (n int) { + return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Config) 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 ErrIntOverflowConfig + } + 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: Config: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianSetExpiration", wireType) + } + m.GuardianSetExpiration = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GuardianSetExpiration |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GovernanceEmitter", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthConfig + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GovernanceEmitter = append(m.GovernanceEmitter[:0], dAtA[iNdEx:postIndex]...) + if m.GovernanceEmitter == nil { + m.GovernanceEmitter = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GovernanceChain", wireType) + } + m.GovernanceChain = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GovernanceChain |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + m.ChainId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ChainId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipConfig(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthConfig + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipConfig(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfig + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfig + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfig + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthConfig + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupConfig + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthConfig + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthConfig = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowConfig = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupConfig = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/consensus_guardian_set_index.pb.go b/wormchain/x/wormhole/types/consensus_guardian_set_index.pb.go new file mode 100644 index 000000000..45cea547f --- /dev/null +++ b/wormchain/x/wormhole/types/consensus_guardian_set_index.pb.go @@ -0,0 +1,302 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/consensus_guardian_set_index.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type ConsensusGuardianSetIndex struct { + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` +} + +func (m *ConsensusGuardianSetIndex) Reset() { *m = ConsensusGuardianSetIndex{} } +func (m *ConsensusGuardianSetIndex) String() string { return proto.CompactTextString(m) } +func (*ConsensusGuardianSetIndex) ProtoMessage() {} +func (*ConsensusGuardianSetIndex) Descriptor() ([]byte, []int) { + return fileDescriptor_18e45d0c16ad5fce, []int{0} +} +func (m *ConsensusGuardianSetIndex) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConsensusGuardianSetIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConsensusGuardianSetIndex.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 *ConsensusGuardianSetIndex) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConsensusGuardianSetIndex.Merge(m, src) +} +func (m *ConsensusGuardianSetIndex) XXX_Size() int { + return m.Size() +} +func (m *ConsensusGuardianSetIndex) XXX_DiscardUnknown() { + xxx_messageInfo_ConsensusGuardianSetIndex.DiscardUnknown(m) +} + +var xxx_messageInfo_ConsensusGuardianSetIndex proto.InternalMessageInfo + +func (m *ConsensusGuardianSetIndex) GetIndex() uint32 { + if m != nil { + return m.Index + } + return 0 +} + +func init() { + proto.RegisterType((*ConsensusGuardianSetIndex)(nil), "wormhole_foundation.wormchain.wormhole.ConsensusGuardianSetIndex") +} + +func init() { + proto.RegisterFile("wormhole/consensus_guardian_set_index.proto", fileDescriptor_18e45d0c16ad5fce) +} + +var fileDescriptor_18e45d0c16ad5fce = []byte{ + // 190 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2e, 0xcf, 0x2f, 0xca, + 0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x4e, 0xcd, 0x2b, 0x2e, 0x2d, 0x8e, 0x4f, + 0x2f, 0x4d, 0x2c, 0x4a, 0xc9, 0x4c, 0xcc, 0x8b, 0x2f, 0x4e, 0x2d, 0x89, 0xcf, 0xcc, 0x4b, 0x49, + 0xad, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x83, 0x29, 0x8e, 0x4f, 0xcb, 0x2f, 0xcd, + 0x4b, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x89, 0x25, 0x67, 0x24, 0x66, 0x42, 0x58, 0x20, + 0x59, 0x25, 0x43, 0x2e, 0x49, 0x67, 0x98, 0x69, 0xee, 0x50, 0xc3, 0x82, 0x53, 0x4b, 0x3c, 0x41, + 0x46, 0x09, 0x89, 0x70, 0xb1, 0x82, 0xcd, 0x94, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0d, 0x82, 0x70, + 0x9c, 0x82, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, + 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0xca, 0x32, 0x3d, 0xb3, + 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x66, 0x83, 0x2e, 0xc2, 0x7e, 0x7d, 0xb8, + 0xfd, 0xfa, 0x15, 0x70, 0x79, 0xfd, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0xb3, 0x8d, + 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x90, 0x7c, 0x1c, 0x4e, 0xe5, 0x00, 0x00, 0x00, +} + +func (m *ConsensusGuardianSetIndex) 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 *ConsensusGuardianSetIndex) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConsensusGuardianSetIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Index != 0 { + i = encodeVarintConsensusGuardianSetIndex(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintConsensusGuardianSetIndex(dAtA []byte, offset int, v uint64) int { + offset -= sovConsensusGuardianSetIndex(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ConsensusGuardianSetIndex) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != 0 { + n += 1 + sovConsensusGuardianSetIndex(uint64(m.Index)) + } + return n +} + +func sovConsensusGuardianSetIndex(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozConsensusGuardianSetIndex(x uint64) (n int) { + return sovConsensusGuardianSetIndex(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ConsensusGuardianSetIndex) 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 ErrIntOverflowConsensusGuardianSetIndex + } + 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: ConsensusGuardianSetIndex: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConsensusGuardianSetIndex: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConsensusGuardianSetIndex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipConsensusGuardianSetIndex(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthConsensusGuardianSetIndex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipConsensusGuardianSetIndex(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConsensusGuardianSetIndex + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConsensusGuardianSetIndex + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConsensusGuardianSetIndex + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthConsensusGuardianSetIndex + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupConsensusGuardianSetIndex + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthConsensusGuardianSetIndex + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthConsensusGuardianSetIndex = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowConsensusGuardianSetIndex = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupConsensusGuardianSetIndex = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/events.pb.go b/wormchain/x/wormhole/types/events.pb.go new file mode 100644 index 000000000..567a8f531 --- /dev/null +++ b/wormchain/x/wormhole/types/events.pb.go @@ -0,0 +1,1090 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/events.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type EventGuardianSetUpdate struct { + OldIndex uint32 `protobuf:"varint,1,opt,name=old_index,json=oldIndex,proto3" json:"old_index,omitempty"` + NewIndex uint32 `protobuf:"varint,2,opt,name=new_index,json=newIndex,proto3" json:"new_index,omitempty"` +} + +func (m *EventGuardianSetUpdate) Reset() { *m = EventGuardianSetUpdate{} } +func (m *EventGuardianSetUpdate) String() string { return proto.CompactTextString(m) } +func (*EventGuardianSetUpdate) ProtoMessage() {} +func (*EventGuardianSetUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_486bfc4df1202b88, []int{0} +} +func (m *EventGuardianSetUpdate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventGuardianSetUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventGuardianSetUpdate.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 *EventGuardianSetUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventGuardianSetUpdate.Merge(m, src) +} +func (m *EventGuardianSetUpdate) XXX_Size() int { + return m.Size() +} +func (m *EventGuardianSetUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_EventGuardianSetUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_EventGuardianSetUpdate proto.InternalMessageInfo + +func (m *EventGuardianSetUpdate) GetOldIndex() uint32 { + if m != nil { + return m.OldIndex + } + return 0 +} + +func (m *EventGuardianSetUpdate) GetNewIndex() uint32 { + if m != nil { + return m.NewIndex + } + return 0 +} + +type EventPostedMessage struct { + Emitter []byte `protobuf:"bytes,1,opt,name=emitter,proto3" json:"emitter,omitempty"` + Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"` + Nonce uint32 `protobuf:"varint,3,opt,name=nonce,proto3" json:"nonce,omitempty"` + Time uint64 `protobuf:"varint,4,opt,name=time,proto3" json:"time,omitempty"` + Payload []byte `protobuf:"bytes,5,opt,name=payload,proto3" json:"payload,omitempty"` +} + +func (m *EventPostedMessage) Reset() { *m = EventPostedMessage{} } +func (m *EventPostedMessage) String() string { return proto.CompactTextString(m) } +func (*EventPostedMessage) ProtoMessage() {} +func (*EventPostedMessage) Descriptor() ([]byte, []int) { + return fileDescriptor_486bfc4df1202b88, []int{1} +} +func (m *EventPostedMessage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventPostedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventPostedMessage.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 *EventPostedMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventPostedMessage.Merge(m, src) +} +func (m *EventPostedMessage) XXX_Size() int { + return m.Size() +} +func (m *EventPostedMessage) XXX_DiscardUnknown() { + xxx_messageInfo_EventPostedMessage.DiscardUnknown(m) +} + +var xxx_messageInfo_EventPostedMessage proto.InternalMessageInfo + +func (m *EventPostedMessage) GetEmitter() []byte { + if m != nil { + return m.Emitter + } + return nil +} + +func (m *EventPostedMessage) GetSequence() uint64 { + if m != nil { + return m.Sequence + } + return 0 +} + +func (m *EventPostedMessage) GetNonce() uint32 { + if m != nil { + return m.Nonce + } + return 0 +} + +func (m *EventPostedMessage) GetTime() uint64 { + if m != nil { + return m.Time + } + return 0 +} + +func (m *EventPostedMessage) GetPayload() []byte { + if m != nil { + return m.Payload + } + return nil +} + +type EventGuardianRegistered struct { + GuardianKey []byte `protobuf:"bytes,1,opt,name=guardian_key,json=guardianKey,proto3" json:"guardian_key,omitempty"` + ValidatorKey []byte `protobuf:"bytes,2,opt,name=validator_key,json=validatorKey,proto3" json:"validator_key,omitempty"` +} + +func (m *EventGuardianRegistered) Reset() { *m = EventGuardianRegistered{} } +func (m *EventGuardianRegistered) String() string { return proto.CompactTextString(m) } +func (*EventGuardianRegistered) ProtoMessage() {} +func (*EventGuardianRegistered) Descriptor() ([]byte, []int) { + return fileDescriptor_486bfc4df1202b88, []int{2} +} +func (m *EventGuardianRegistered) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventGuardianRegistered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventGuardianRegistered.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 *EventGuardianRegistered) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventGuardianRegistered.Merge(m, src) +} +func (m *EventGuardianRegistered) XXX_Size() int { + return m.Size() +} +func (m *EventGuardianRegistered) XXX_DiscardUnknown() { + xxx_messageInfo_EventGuardianRegistered.DiscardUnknown(m) +} + +var xxx_messageInfo_EventGuardianRegistered proto.InternalMessageInfo + +func (m *EventGuardianRegistered) GetGuardianKey() []byte { + if m != nil { + return m.GuardianKey + } + return nil +} + +func (m *EventGuardianRegistered) GetValidatorKey() []byte { + if m != nil { + return m.ValidatorKey + } + return nil +} + +type EventConsensusSetUpdate struct { + OldIndex uint32 `protobuf:"varint,1,opt,name=old_index,json=oldIndex,proto3" json:"old_index,omitempty"` + NewIndex uint32 `protobuf:"varint,2,opt,name=new_index,json=newIndex,proto3" json:"new_index,omitempty"` +} + +func (m *EventConsensusSetUpdate) Reset() { *m = EventConsensusSetUpdate{} } +func (m *EventConsensusSetUpdate) String() string { return proto.CompactTextString(m) } +func (*EventConsensusSetUpdate) ProtoMessage() {} +func (*EventConsensusSetUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_486bfc4df1202b88, []int{3} +} +func (m *EventConsensusSetUpdate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventConsensusSetUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventConsensusSetUpdate.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 *EventConsensusSetUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventConsensusSetUpdate.Merge(m, src) +} +func (m *EventConsensusSetUpdate) XXX_Size() int { + return m.Size() +} +func (m *EventConsensusSetUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_EventConsensusSetUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_EventConsensusSetUpdate proto.InternalMessageInfo + +func (m *EventConsensusSetUpdate) GetOldIndex() uint32 { + if m != nil { + return m.OldIndex + } + return 0 +} + +func (m *EventConsensusSetUpdate) GetNewIndex() uint32 { + if m != nil { + return m.NewIndex + } + return 0 +} + +func init() { + proto.RegisterType((*EventGuardianSetUpdate)(nil), "wormhole_foundation.wormchain.wormhole.EventGuardianSetUpdate") + proto.RegisterType((*EventPostedMessage)(nil), "wormhole_foundation.wormchain.wormhole.EventPostedMessage") + proto.RegisterType((*EventGuardianRegistered)(nil), "wormhole_foundation.wormchain.wormhole.EventGuardianRegistered") + proto.RegisterType((*EventConsensusSetUpdate)(nil), "wormhole_foundation.wormchain.wormhole.EventConsensusSetUpdate") +} + +func init() { proto.RegisterFile("wormhole/events.proto", fileDescriptor_486bfc4df1202b88) } + +var fileDescriptor_486bfc4df1202b88 = []byte{ + // 353 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0xbf, 0x4e, 0xc3, 0x30, + 0x10, 0xc6, 0x9b, 0xd2, 0x42, 0x31, 0xed, 0x62, 0xf1, 0x27, 0x02, 0x29, 0x82, 0x20, 0x21, 0x16, + 0x9a, 0x81, 0x89, 0x15, 0x84, 0x10, 0xaa, 0x90, 0x50, 0x2a, 0x16, 0x96, 0xca, 0xad, 0x8f, 0xd4, + 0x22, 0xf1, 0x85, 0xd8, 0x69, 0x9b, 0x97, 0x40, 0x3c, 0x16, 0x63, 0x47, 0x46, 0xd4, 0xbe, 0x08, + 0x8a, 0xf3, 0x07, 0xb1, 0xb3, 0xdd, 0xf7, 0xfd, 0x2e, 0xdf, 0xc5, 0x3e, 0x93, 0xbd, 0x39, 0x26, + 0xd1, 0x14, 0x43, 0xf0, 0x60, 0x06, 0x52, 0xab, 0x7e, 0x9c, 0xa0, 0x46, 0x7a, 0x56, 0xd9, 0xa3, + 0x17, 0x4c, 0x25, 0x67, 0x5a, 0xa0, 0xec, 0xe7, 0xde, 0x64, 0xca, 0x44, 0x51, 0xe5, 0xd4, 0xf5, + 0xc9, 0xfe, 0x6d, 0xfe, 0xdd, 0x5d, 0xca, 0x12, 0x2e, 0x98, 0x1c, 0x82, 0x7e, 0x8a, 0x39, 0xd3, + 0x40, 0x8f, 0xc8, 0x36, 0x86, 0x7c, 0x24, 0x24, 0x87, 0x85, 0x6d, 0x1d, 0x5b, 0xe7, 0x3d, 0xbf, + 0x83, 0x21, 0xbf, 0xcf, 0x75, 0x0e, 0x25, 0xcc, 0x4b, 0xd8, 0x2c, 0xa0, 0x84, 0xb9, 0x81, 0xee, + 0xbb, 0x45, 0xa8, 0x09, 0x7d, 0x44, 0xa5, 0x81, 0x3f, 0x80, 0x52, 0x2c, 0x00, 0x6a, 0x93, 0x2d, + 0x88, 0x84, 0xd6, 0x90, 0x98, 0xb8, 0xae, 0x5f, 0x49, 0x7a, 0x48, 0x3a, 0x0a, 0xde, 0x52, 0x90, + 0x13, 0x30, 0x61, 0x2d, 0xbf, 0xd6, 0x74, 0x97, 0xb4, 0x25, 0xe6, 0x60, 0xc3, 0x4c, 0x29, 0x04, + 0xa5, 0xa4, 0xa5, 0x45, 0x04, 0x76, 0xcb, 0x74, 0x9b, 0x3a, 0xcf, 0x8f, 0x59, 0x16, 0x22, 0xe3, + 0x76, 0xbb, 0xc8, 0x2f, 0xa5, 0xcb, 0xc8, 0xc1, 0x9f, 0x43, 0xfa, 0x10, 0x08, 0xa5, 0x21, 0x01, + 0x4e, 0x4f, 0x48, 0x37, 0x28, 0xdd, 0xd1, 0x2b, 0x64, 0xe5, 0x9f, 0xed, 0x54, 0xde, 0x00, 0x32, + 0x7a, 0x4a, 0x7a, 0x33, 0x16, 0x0a, 0xce, 0x34, 0x26, 0xa6, 0xa7, 0x69, 0x7a, 0xba, 0xb5, 0x39, + 0x80, 0xcc, 0x1d, 0x96, 0x23, 0x6e, 0x50, 0x2a, 0x90, 0x2a, 0x55, 0xff, 0x70, 0x91, 0xd7, 0xc3, + 0xcf, 0x95, 0x63, 0x2d, 0x57, 0x8e, 0xf5, 0xbd, 0x72, 0xac, 0x8f, 0xb5, 0xd3, 0x58, 0xae, 0x9d, + 0xc6, 0xd7, 0xda, 0x69, 0x3c, 0x5f, 0x05, 0x42, 0x4f, 0xd3, 0x71, 0x7f, 0x82, 0x91, 0x57, 0xed, + 0xf2, 0xe2, 0x77, 0xd3, 0x5e, 0xbd, 0x69, 0x6f, 0x51, 0x73, 0x4f, 0x67, 0x31, 0xa8, 0xf1, 0xa6, + 0x79, 0x20, 0x97, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc1, 0xe4, 0xc3, 0xee, 0x39, 0x02, 0x00, + 0x00, +} + +func (m *EventGuardianSetUpdate) 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 *EventGuardianSetUpdate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventGuardianSetUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NewIndex != 0 { + i = encodeVarintEvents(dAtA, i, uint64(m.NewIndex)) + i-- + dAtA[i] = 0x10 + } + if m.OldIndex != 0 { + i = encodeVarintEvents(dAtA, i, uint64(m.OldIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EventPostedMessage) 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 *EventPostedMessage) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventPostedMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Payload) > 0 { + i -= len(m.Payload) + copy(dAtA[i:], m.Payload) + i = encodeVarintEvents(dAtA, i, uint64(len(m.Payload))) + i-- + dAtA[i] = 0x2a + } + if m.Time != 0 { + i = encodeVarintEvents(dAtA, i, uint64(m.Time)) + i-- + dAtA[i] = 0x20 + } + if m.Nonce != 0 { + i = encodeVarintEvents(dAtA, i, uint64(m.Nonce)) + i-- + dAtA[i] = 0x18 + } + if m.Sequence != 0 { + i = encodeVarintEvents(dAtA, i, uint64(m.Sequence)) + i-- + dAtA[i] = 0x10 + } + if len(m.Emitter) > 0 { + i -= len(m.Emitter) + copy(dAtA[i:], m.Emitter) + i = encodeVarintEvents(dAtA, i, uint64(len(m.Emitter))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventGuardianRegistered) 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 *EventGuardianRegistered) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventGuardianRegistered) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorKey) > 0 { + i -= len(m.ValidatorKey) + copy(dAtA[i:], m.ValidatorKey) + i = encodeVarintEvents(dAtA, i, uint64(len(m.ValidatorKey))) + i-- + dAtA[i] = 0x12 + } + if len(m.GuardianKey) > 0 { + i -= len(m.GuardianKey) + copy(dAtA[i:], m.GuardianKey) + i = encodeVarintEvents(dAtA, i, uint64(len(m.GuardianKey))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventConsensusSetUpdate) 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 *EventConsensusSetUpdate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventConsensusSetUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NewIndex != 0 { + i = encodeVarintEvents(dAtA, i, uint64(m.NewIndex)) + i-- + dAtA[i] = 0x10 + } + if m.OldIndex != 0 { + i = encodeVarintEvents(dAtA, i, uint64(m.OldIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintEvents(dAtA []byte, offset int, v uint64) int { + offset -= sovEvents(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *EventGuardianSetUpdate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.OldIndex != 0 { + n += 1 + sovEvents(uint64(m.OldIndex)) + } + if m.NewIndex != 0 { + n += 1 + sovEvents(uint64(m.NewIndex)) + } + return n +} + +func (m *EventPostedMessage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Emitter) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + if m.Sequence != 0 { + n += 1 + sovEvents(uint64(m.Sequence)) + } + if m.Nonce != 0 { + n += 1 + sovEvents(uint64(m.Nonce)) + } + if m.Time != 0 { + n += 1 + sovEvents(uint64(m.Time)) + } + l = len(m.Payload) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + return n +} + +func (m *EventGuardianRegistered) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.GuardianKey) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + l = len(m.ValidatorKey) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + return n +} + +func (m *EventConsensusSetUpdate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.OldIndex != 0 { + n += 1 + sovEvents(uint64(m.OldIndex)) + } + if m.NewIndex != 0 { + n += 1 + sovEvents(uint64(m.NewIndex)) + } + return n +} + +func sovEvents(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozEvents(x uint64) (n int) { + return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *EventGuardianSetUpdate) 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 ErrIntOverflowEvents + } + 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: EventGuardianSetUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventGuardianSetUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OldIndex", wireType) + } + m.OldIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.OldIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewIndex", wireType) + } + m.NewIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventPostedMessage) 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 ErrIntOverflowEvents + } + 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: EventPostedMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventPostedMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Emitter", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Emitter = append(m.Emitter[:0], dAtA[iNdEx:postIndex]...) + if m.Emitter == nil { + m.Emitter = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + m.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + m.Nonce = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Nonce |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + } + m.Time = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Time |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...) + if m.Payload == nil { + m.Payload = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventGuardianRegistered) 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 ErrIntOverflowEvents + } + 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: EventGuardianRegistered: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventGuardianRegistered: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GuardianKey = append(m.GuardianKey[:0], dAtA[iNdEx:postIndex]...) + if m.GuardianKey == nil { + m.GuardianKey = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorKey = append(m.ValidatorKey[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorKey == nil { + m.ValidatorKey = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventConsensusSetUpdate) 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 ErrIntOverflowEvents + } + 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: EventConsensusSetUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventConsensusSetUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OldIndex", wireType) + } + m.OldIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.OldIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewIndex", wireType) + } + m.NewIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipEvents(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvents + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvents + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvents + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthEvents + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupEvents + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthEvents + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthEvents = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowEvents = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/genesis.pb.go b/wormchain/x/wormhole/types/genesis.pb.go new file mode 100644 index 000000000..82c8dfc98 --- /dev/null +++ b/wormchain/x/wormhole/types/genesis.pb.go @@ -0,0 +1,650 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/genesis.proto + +package types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// GenesisState defines the wormhole module's genesis state. +type GenesisState struct { + GuardianSetList []GuardianSet `protobuf:"bytes,1,rep,name=guardianSetList,proto3" json:"guardianSetList"` + Config *Config `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"` + ReplayProtectionList []ReplayProtection `protobuf:"bytes,3,rep,name=replayProtectionList,proto3" json:"replayProtectionList"` + SequenceCounterList []SequenceCounter `protobuf:"bytes,4,rep,name=sequenceCounterList,proto3" json:"sequenceCounterList"` + ConsensusGuardianSetIndex *ConsensusGuardianSetIndex `protobuf:"bytes,5,opt,name=consensusGuardianSetIndex,proto3" json:"consensusGuardianSetIndex,omitempty"` + GuardianValidatorList []GuardianValidator `protobuf:"bytes,6,rep,name=guardianValidatorList,proto3" json:"guardianValidatorList"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_9a7ced3fe0304831, []int{0} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +func (m *GenesisState) GetGuardianSetList() []GuardianSet { + if m != nil { + return m.GuardianSetList + } + return nil +} + +func (m *GenesisState) GetConfig() *Config { + if m != nil { + return m.Config + } + return nil +} + +func (m *GenesisState) GetReplayProtectionList() []ReplayProtection { + if m != nil { + return m.ReplayProtectionList + } + return nil +} + +func (m *GenesisState) GetSequenceCounterList() []SequenceCounter { + if m != nil { + return m.SequenceCounterList + } + return nil +} + +func (m *GenesisState) GetConsensusGuardianSetIndex() *ConsensusGuardianSetIndex { + if m != nil { + return m.ConsensusGuardianSetIndex + } + return nil +} + +func (m *GenesisState) GetGuardianValidatorList() []GuardianValidator { + if m != nil { + return m.GuardianValidatorList + } + return nil +} + +func init() { + proto.RegisterType((*GenesisState)(nil), "wormhole_foundation.wormchain.wormhole.GenesisState") +} + +func init() { proto.RegisterFile("wormhole/genesis.proto", fileDescriptor_9a7ced3fe0304831) } + +var fileDescriptor_9a7ced3fe0304831 = []byte{ + // 426 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcf, 0x8b, 0xda, 0x40, + 0x14, 0xc7, 0x93, 0xfa, 0xe3, 0x30, 0x16, 0x0a, 0xa9, 0x16, 0x6b, 0x21, 0xda, 0x1e, 0x8a, 0x50, + 0x9a, 0x80, 0x1e, 0x5a, 0x8f, 0x55, 0xa8, 0x14, 0x7a, 0x28, 0x09, 0xf4, 0xb0, 0x97, 0x30, 0x26, + 0x63, 0x1c, 0xd0, 0x19, 0x37, 0x33, 0xd9, 0xd5, 0xd3, 0xfe, 0x0b, 0x7b, 0xdc, 0x3f, 0xc9, 0xa3, + 0xc7, 0x3d, 0x2d, 0x8b, 0xfe, 0x23, 0x4b, 0x66, 0x92, 0xd1, 0x75, 0xb3, 0x10, 0x6f, 0xc3, 0x9b, + 0xf7, 0x3e, 0xdf, 0xf7, 0xbe, 0xef, 0x81, 0x0f, 0xd7, 0x34, 0x5a, 0xcc, 0xe8, 0x1c, 0xd9, 0x21, + 0x22, 0x88, 0x61, 0x66, 0x2d, 0x23, 0xca, 0xa9, 0xf1, 0x35, 0x8b, 0x7b, 0x53, 0x1a, 0x93, 0x00, + 0x72, 0x4c, 0x89, 0x95, 0xc4, 0xfc, 0x19, 0xc4, 0xf2, 0x95, 0xfc, 0xb6, 0x3e, 0x1d, 0xea, 0x63, + 0x18, 0x05, 0x18, 0x12, 0x8f, 0x21, 0x2e, 0x21, 0xad, 0x86, 0xfa, 0xf4, 0x29, 0x99, 0xe2, 0x30, + 0x0d, 0x77, 0x54, 0x38, 0x42, 0xcb, 0x39, 0x5c, 0x7b, 0x49, 0x18, 0xf9, 0x42, 0x42, 0x66, 0xb4, + 0x55, 0x06, 0x43, 0x97, 0x31, 0x22, 0x3e, 0xf2, 0x7c, 0x1a, 0x13, 0x8e, 0xa2, 0x34, 0xe1, 0xdb, + 0x31, 0x99, 0x21, 0xc2, 0x62, 0xe6, 0x1d, 0x37, 0xe0, 0x61, 0x12, 0xa0, 0x55, 0x9a, 0xfc, 0xf9, + 0x65, 0x8f, 0x57, 0x70, 0x8e, 0x03, 0xc8, 0x69, 0xc6, 0xab, 0x87, 0x34, 0xa4, 0xe2, 0x69, 0x27, + 0x2f, 0x19, 0xfd, 0x72, 0x57, 0x01, 0x6f, 0xc7, 0xd2, 0x16, 0x97, 0x43, 0x8e, 0x0c, 0x1f, 0xbc, + 0xcb, 0x10, 0x2e, 0xe2, 0x7f, 0x31, 0xe3, 0x4d, 0xbd, 0x53, 0xea, 0xd6, 0x7a, 0x7d, 0xab, 0x98, + 0x5f, 0xd6, 0xf8, 0x50, 0x3e, 0x2c, 0x6f, 0x1e, 0xda, 0x9a, 0x73, 0x4a, 0x34, 0x7e, 0x83, 0xaa, + 0xb4, 0xab, 0xf9, 0xa6, 0xa3, 0x77, 0x6b, 0x3d, 0xab, 0x28, 0x7b, 0x24, 0xaa, 0x9c, 0xb4, 0xda, + 0x88, 0x40, 0x5d, 0xfa, 0xfb, 0x4f, 0xd9, 0x2b, 0x3a, 0x2e, 0x89, 0x8e, 0x7f, 0x16, 0xa5, 0x3a, + 0x27, 0x8c, 0xb4, 0xed, 0x5c, 0xb6, 0x41, 0xc1, 0xfb, 0x6c, 0x63, 0x23, 0xb9, 0x30, 0x21, 0x59, + 0x16, 0x92, 0x3f, 0x8a, 0x4a, 0xba, 0xcf, 0x11, 0xa9, 0x62, 0x1e, 0xd9, 0xb8, 0x01, 0x1f, 0xd5, + 0x05, 0x1c, 0x79, 0xfb, 0x27, 0x59, 0x7f, 0xb3, 0x22, 0xfc, 0xfb, 0x75, 0x86, 0x7f, 0xf9, 0x20, + 0xe7, 0x75, 0x0d, 0x23, 0x06, 0x8d, 0x6c, 0x81, 0xff, 0xb3, 0xa3, 0x12, 0x33, 0x57, 0xc5, 0xcc, + 0x83, 0x73, 0x0f, 0x43, 0x41, 0xd2, 0xa9, 0xf3, 0xe9, 0x43, 0x77, 0xb3, 0x33, 0xf5, 0xed, 0xce, + 0xd4, 0x1f, 0x77, 0xa6, 0x7e, 0xbb, 0x37, 0xb5, 0xed, 0xde, 0xd4, 0xee, 0xf7, 0xa6, 0x76, 0x31, + 0x08, 0x31, 0x9f, 0xc5, 0x13, 0xcb, 0xa7, 0x0b, 0x3b, 0xa3, 0x7f, 0x3f, 0x68, 0xdb, 0x4a, 0xdb, + 0x5e, 0xa9, 0x7f, 0x9b, 0xaf, 0x97, 0x88, 0x4d, 0xaa, 0xe2, 0xec, 0xfb, 0x4f, 0x01, 0x00, 0x00, + 0xff, 0xff, 0x40, 0x4b, 0xe8, 0xcd, 0x15, 0x04, 0x00, 0x00, +} + +func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.GuardianValidatorList) > 0 { + for iNdEx := len(m.GuardianValidatorList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.GuardianValidatorList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + } + if m.ConsensusGuardianSetIndex != nil { + { + size, err := m.ConsensusGuardianSetIndex.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if len(m.SequenceCounterList) > 0 { + for iNdEx := len(m.SequenceCounterList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SequenceCounterList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.ReplayProtectionList) > 0 { + for iNdEx := len(m.ReplayProtectionList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ReplayProtectionList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if m.Config != nil { + { + size, err := m.Config.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.GuardianSetList) > 0 { + for iNdEx := len(m.GuardianSetList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.GuardianSetList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.GuardianSetList) > 0 { + for _, e := range m.GuardianSetList { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if m.Config != nil { + l = m.Config.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + if len(m.ReplayProtectionList) > 0 { + for _, e := range m.ReplayProtectionList { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.SequenceCounterList) > 0 { + for _, e := range m.SequenceCounterList { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if m.ConsensusGuardianSetIndex != nil { + l = m.ConsensusGuardianSetIndex.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + if len(m.GuardianValidatorList) > 0 { + for _, e := range m.GuardianValidatorList { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GenesisState) 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 ErrIntOverflowGenesis + } + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianSetList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GuardianSetList = append(m.GuardianSetList, GuardianSet{}) + if err := m.GuardianSetList[len(m.GuardianSetList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Config == nil { + m.Config = &Config{} + } + if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtectionList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReplayProtectionList = append(m.ReplayProtectionList, ReplayProtection{}) + if err := m.ReplayProtectionList[len(m.ReplayProtectionList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SequenceCounterList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SequenceCounterList = append(m.SequenceCounterList, SequenceCounter{}) + if err := m.SequenceCounterList[len(m.SequenceCounterList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusGuardianSetIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ConsensusGuardianSetIndex == nil { + m.ConsensusGuardianSetIndex = &ConsensusGuardianSetIndex{} + } + if err := m.ConsensusGuardianSetIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianValidatorList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GuardianValidatorList = append(m.GuardianValidatorList, GuardianValidator{}) + if err := m.GuardianValidatorList[len(m.GuardianValidatorList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenesis(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/governance.pb.go b/wormchain/x/wormhole/types/governance.pb.go new file mode 100644 index 000000000..c685a520e --- /dev/null +++ b/wormchain/x/wormhole/types/governance.pb.go @@ -0,0 +1,900 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/governance.proto + +package types + +import ( + bytes "bytes" + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// GuardianSetUpdateProposal defines a guardian set update governance proposal +type GuardianSetUpdateProposal struct { + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + NewGuardianSet GuardianSet `protobuf:"bytes,3,opt,name=newGuardianSet,proto3" json:"newGuardianSet"` +} + +func (m *GuardianSetUpdateProposal) Reset() { *m = GuardianSetUpdateProposal{} } +func (*GuardianSetUpdateProposal) ProtoMessage() {} +func (*GuardianSetUpdateProposal) Descriptor() ([]byte, []int) { + return fileDescriptor_ceebda8f8c3f5f74, []int{0} +} +func (m *GuardianSetUpdateProposal) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GuardianSetUpdateProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GuardianSetUpdateProposal.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 *GuardianSetUpdateProposal) XXX_Merge(src proto.Message) { + xxx_messageInfo_GuardianSetUpdateProposal.Merge(m, src) +} +func (m *GuardianSetUpdateProposal) XXX_Size() int { + return m.Size() +} +func (m *GuardianSetUpdateProposal) XXX_DiscardUnknown() { + xxx_messageInfo_GuardianSetUpdateProposal.DiscardUnknown(m) +} + +var xxx_messageInfo_GuardianSetUpdateProposal proto.InternalMessageInfo + +func (m *GuardianSetUpdateProposal) GetTitle() string { + if m != nil { + return m.Title + } + return "" +} + +func (m *GuardianSetUpdateProposal) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *GuardianSetUpdateProposal) GetNewGuardianSet() GuardianSet { + if m != nil { + return m.NewGuardianSet + } + return GuardianSet{} +} + +// GovernanceWormholeMessageProposal defines a governance proposal to emit a generic message in the governance message +// format. +type GovernanceWormholeMessageProposal struct { + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + Action uint32 `protobuf:"varint,3,opt,name=action,proto3" json:"action,omitempty"` + Module []byte `protobuf:"bytes,4,opt,name=module,proto3" json:"module,omitempty"` + TargetChain uint32 `protobuf:"varint,5,opt,name=targetChain,proto3" json:"targetChain,omitempty"` + Payload []byte `protobuf:"bytes,6,opt,name=payload,proto3" json:"payload,omitempty"` +} + +func (m *GovernanceWormholeMessageProposal) Reset() { *m = GovernanceWormholeMessageProposal{} } +func (*GovernanceWormholeMessageProposal) ProtoMessage() {} +func (*GovernanceWormholeMessageProposal) Descriptor() ([]byte, []int) { + return fileDescriptor_ceebda8f8c3f5f74, []int{1} +} +func (m *GovernanceWormholeMessageProposal) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GovernanceWormholeMessageProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GovernanceWormholeMessageProposal.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 *GovernanceWormholeMessageProposal) XXX_Merge(src proto.Message) { + xxx_messageInfo_GovernanceWormholeMessageProposal.Merge(m, src) +} +func (m *GovernanceWormholeMessageProposal) XXX_Size() int { + return m.Size() +} +func (m *GovernanceWormholeMessageProposal) XXX_DiscardUnknown() { + xxx_messageInfo_GovernanceWormholeMessageProposal.DiscardUnknown(m) +} + +var xxx_messageInfo_GovernanceWormholeMessageProposal proto.InternalMessageInfo + +func (m *GovernanceWormholeMessageProposal) GetTitle() string { + if m != nil { + return m.Title + } + return "" +} + +func (m *GovernanceWormholeMessageProposal) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *GovernanceWormholeMessageProposal) GetAction() uint32 { + if m != nil { + return m.Action + } + return 0 +} + +func (m *GovernanceWormholeMessageProposal) GetModule() []byte { + if m != nil { + return m.Module + } + return nil +} + +func (m *GovernanceWormholeMessageProposal) GetTargetChain() uint32 { + if m != nil { + return m.TargetChain + } + return 0 +} + +func (m *GovernanceWormholeMessageProposal) GetPayload() []byte { + if m != nil { + return m.Payload + } + return nil +} + +func init() { + proto.RegisterType((*GuardianSetUpdateProposal)(nil), "wormhole_foundation.wormchain.wormhole.GuardianSetUpdateProposal") + proto.RegisterType((*GovernanceWormholeMessageProposal)(nil), "wormhole_foundation.wormchain.wormhole.GovernanceWormholeMessageProposal") +} + +func init() { proto.RegisterFile("wormhole/governance.proto", fileDescriptor_ceebda8f8c3f5f74) } + +var fileDescriptor_ceebda8f8c3f5f74 = []byte{ + // 358 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x51, 0xb1, 0x4e, 0xf2, 0x50, + 0x18, 0xed, 0xfd, 0x7f, 0x40, 0xbd, 0xa8, 0x43, 0x43, 0x4c, 0xc1, 0xa4, 0x54, 0x06, 0xc3, 0x62, + 0x9b, 0xc8, 0xa4, 0x23, 0x0e, 0x4c, 0x26, 0xa6, 0xc4, 0x98, 0xb8, 0x90, 0x4b, 0xfb, 0x59, 0x9a, + 0x94, 0x7e, 0xcd, 0xed, 0xad, 0xc8, 0x5b, 0x38, 0x3a, 0xf2, 0x28, 0x8e, 0x8c, 0xb8, 0x39, 0x19, + 0x03, 0x8b, 0x8f, 0x61, 0x6e, 0x5b, 0xa0, 0x71, 0x32, 0x71, 0xfb, 0xce, 0x39, 0x3d, 0x27, 0x3d, + 0xe7, 0xd2, 0xfa, 0x04, 0xf9, 0x78, 0x84, 0x01, 0x58, 0x1e, 0x3e, 0x02, 0x0f, 0x59, 0xe8, 0x80, + 0x19, 0x71, 0x14, 0xa8, 0x9e, 0xae, 0xa5, 0xc1, 0x03, 0x26, 0xa1, 0xcb, 0x84, 0x8f, 0xa1, 0x29, + 0x39, 0x67, 0xc4, 0xfc, 0xec, 0x92, 0x6a, 0xe3, 0x78, 0x1b, 0x91, 0x30, 0xee, 0xfa, 0x2c, 0x1c, + 0xc4, 0x20, 0xb2, 0x90, 0x46, 0xcd, 0x43, 0x0f, 0xd3, 0xd3, 0x92, 0x57, 0xc6, 0xb6, 0x5e, 0x09, + 0xad, 0xf7, 0xf2, 0x8f, 0xfb, 0x20, 0x6e, 0x23, 0x97, 0x09, 0xb8, 0xe1, 0x18, 0x61, 0xcc, 0x02, + 0xb5, 0x46, 0xcb, 0xc2, 0x17, 0x01, 0x68, 0xc4, 0x20, 0xed, 0x3d, 0x3b, 0x03, 0xaa, 0x41, 0xab, + 0x2e, 0xc4, 0x0e, 0xf7, 0x23, 0xf9, 0x23, 0xda, 0xbf, 0x54, 0x2b, 0x52, 0x2a, 0xa3, 0x87, 0x21, + 0x4c, 0x0a, 0xb9, 0xda, 0x7f, 0x83, 0xb4, 0xab, 0xe7, 0x1d, 0xf3, 0x77, 0x4d, 0xcc, 0x82, 0xb5, + 0x5b, 0x9a, 0x7f, 0x34, 0x15, 0xfb, 0x47, 0xe0, 0xe5, 0xee, 0xcb, 0xac, 0xa9, 0x7c, 0xcd, 0x9a, + 0xa4, 0xf5, 0x46, 0xe8, 0x49, 0x6f, 0x33, 0xd9, 0x5d, 0x1e, 0x71, 0x0d, 0x71, 0xcc, 0xbc, 0xbf, + 0x57, 0x39, 0xa2, 0x15, 0xe6, 0xa4, 0xa2, 0xac, 0x70, 0x60, 0xe7, 0x48, 0xf2, 0x63, 0x74, 0x93, + 0x00, 0xb4, 0x92, 0x41, 0xda, 0xfb, 0x76, 0x8e, 0x64, 0xa2, 0x60, 0xdc, 0x03, 0x71, 0x25, 0x1b, + 0x69, 0xe5, 0xd4, 0x54, 0xa4, 0x54, 0x8d, 0xee, 0x44, 0x6c, 0x1a, 0x20, 0x73, 0xb5, 0x4a, 0x6a, + 0x5d, 0xc3, 0x6d, 0xa7, 0x6e, 0x7f, 0xbe, 0xd4, 0xc9, 0x62, 0xa9, 0x93, 0xcf, 0xa5, 0x4e, 0x9e, + 0x57, 0xba, 0xb2, 0x58, 0xe9, 0xca, 0xfb, 0x4a, 0x57, 0xee, 0x2f, 0x3c, 0x5f, 0x8c, 0x92, 0xa1, + 0xe9, 0xe0, 0xd8, 0x5a, 0xcf, 0x75, 0xb6, 0x1d, 0xd3, 0xda, 0x8c, 0x69, 0x3d, 0x6d, 0x74, 0x4b, + 0x4c, 0x23, 0x88, 0x87, 0x95, 0xf4, 0xc9, 0x3b, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x06, 0x0f, + 0x17, 0x16, 0x6a, 0x02, 0x00, 0x00, +} + +func (this *GuardianSetUpdateProposal) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*GuardianSetUpdateProposal) + if !ok { + that2, ok := that.(GuardianSetUpdateProposal) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Title != that1.Title { + return false + } + if this.Description != that1.Description { + return false + } + if !this.NewGuardianSet.Equal(&that1.NewGuardianSet) { + return false + } + return true +} +func (this *GovernanceWormholeMessageProposal) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*GovernanceWormholeMessageProposal) + if !ok { + that2, ok := that.(GovernanceWormholeMessageProposal) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Title != that1.Title { + return false + } + if this.Description != that1.Description { + return false + } + if this.Action != that1.Action { + return false + } + if !bytes.Equal(this.Module, that1.Module) { + return false + } + if this.TargetChain != that1.TargetChain { + return false + } + if !bytes.Equal(this.Payload, that1.Payload) { + return false + } + return true +} +func (m *GuardianSetUpdateProposal) 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 *GuardianSetUpdateProposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GuardianSetUpdateProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.NewGuardianSet.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGovernance(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x12 + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GovernanceWormholeMessageProposal) 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 *GovernanceWormholeMessageProposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GovernanceWormholeMessageProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Payload) > 0 { + i -= len(m.Payload) + copy(dAtA[i:], m.Payload) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Payload))) + i-- + dAtA[i] = 0x32 + } + if m.TargetChain != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.TargetChain)) + i-- + dAtA[i] = 0x28 + } + if len(m.Module) > 0 { + i -= len(m.Module) + copy(dAtA[i:], m.Module) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Module))) + i-- + dAtA[i] = 0x22 + } + if m.Action != 0 { + i = encodeVarintGovernance(dAtA, i, uint64(m.Action)) + i-- + dAtA[i] = 0x18 + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x12 + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = encodeVarintGovernance(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintGovernance(dAtA []byte, offset int, v uint64) int { + offset -= sovGovernance(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GuardianSetUpdateProposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + l = m.NewGuardianSet.Size() + n += 1 + l + sovGovernance(uint64(l)) + return n +} + +func (m *GovernanceWormholeMessageProposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.Action != 0 { + n += 1 + sovGovernance(uint64(m.Action)) + } + l = len(m.Module) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + if m.TargetChain != 0 { + n += 1 + sovGovernance(uint64(m.TargetChain)) + } + l = len(m.Payload) + if l > 0 { + n += 1 + l + sovGovernance(uint64(l)) + } + return n +} + +func sovGovernance(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGovernance(x uint64) (n int) { + return sovGovernance(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GuardianSetUpdateProposal) 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 ErrIntOverflowGovernance + } + 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: GuardianSetUpdateProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GuardianSetUpdateProposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewGuardianSet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.NewGuardianSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GovernanceWormholeMessageProposal) 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 ErrIntOverflowGovernance + } + 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: GovernanceWormholeMessageProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GovernanceWormholeMessageProposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + 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 ErrInvalidLengthGovernance + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType) + } + m.Action = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Action |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Module", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Module = append(m.Module[:0], dAtA[iNdEx:postIndex]...) + if m.Module == nil { + m.Module = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TargetChain", wireType) + } + m.TargetChain = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TargetChain |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGovernance + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGovernance + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGovernance + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...) + if m.Payload == nil { + m.Payload = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGovernance(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGovernance + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGovernance(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGovernance + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGovernance + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGovernance + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGovernance + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGovernance + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGovernance + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGovernance = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGovernance = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGovernance = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/guardian_key.pb.go b/wormchain/x/wormhole/types/guardian_key.pb.go new file mode 100644 index 000000000..34bebb61f --- /dev/null +++ b/wormchain/x/wormhole/types/guardian_key.pb.go @@ -0,0 +1,317 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/guardian_key.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type GuardianKey struct { + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *GuardianKey) Reset() { *m = GuardianKey{} } +func (m *GuardianKey) String() string { return proto.CompactTextString(m) } +func (*GuardianKey) ProtoMessage() {} +func (*GuardianKey) Descriptor() ([]byte, []int) { + return fileDescriptor_87576a0b45454f44, []int{0} +} +func (m *GuardianKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GuardianKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GuardianKey.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 *GuardianKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_GuardianKey.Merge(m, src) +} +func (m *GuardianKey) XXX_Size() int { + return m.Size() +} +func (m *GuardianKey) XXX_DiscardUnknown() { + xxx_messageInfo_GuardianKey.DiscardUnknown(m) +} + +var xxx_messageInfo_GuardianKey proto.InternalMessageInfo + +func (m *GuardianKey) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func init() { + proto.RegisterType((*GuardianKey)(nil), "wormhole_foundation.wormchain.wormhole.GuardianKey") +} + +func init() { proto.RegisterFile("wormhole/guardian_key.proto", fileDescriptor_87576a0b45454f44) } + +var fileDescriptor_87576a0b45454f44 = []byte{ + // 168 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2e, 0xcf, 0x2f, 0xca, + 0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0x2f, 0x4d, 0x2c, 0x4a, 0xc9, 0x4c, 0xcc, 0x8b, 0xcf, 0x4e, + 0xad, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x83, 0x49, 0xc6, 0xa7, 0xe5, 0x97, 0xe6, + 0xa5, 0x24, 0x96, 0x64, 0xe6, 0xe7, 0xe9, 0x81, 0xc4, 0x92, 0x33, 0x12, 0x33, 0x21, 0x2c, 0x90, + 0xac, 0x92, 0x3c, 0x17, 0xb7, 0x3b, 0x54, 0xb7, 0x77, 0x6a, 0xa5, 0x90, 0x00, 0x17, 0x73, 0x76, + 0x6a, 0xa5, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x4f, 0x10, 0x88, 0xe9, 0x14, 0x7c, 0xe2, 0x91, 0x1c, + 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, + 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0x96, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, + 0xf9, 0xb9, 0xfa, 0x30, 0xf3, 0x74, 0x11, 0xb6, 0xe9, 0xc3, 0x6d, 0xd3, 0xaf, 0x80, 0xcb, 0xeb, + 0x97, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x1d, 0x69, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, + 0x63, 0x2f, 0xc8, 0x4a, 0xc3, 0x00, 0x00, 0x00, +} + +func (m *GuardianKey) 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 *GuardianKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GuardianKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintGuardianKey(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintGuardianKey(dAtA []byte, offset int, v uint64) int { + offset -= sovGuardianKey(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GuardianKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovGuardianKey(uint64(l)) + } + return n +} + +func sovGuardianKey(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGuardianKey(x uint64) (n int) { + return sovGuardianKey(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GuardianKey) 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 ErrIntOverflowGuardianKey + } + 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: GuardianKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GuardianKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuardianKey + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGuardianKey + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGuardianKey + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGuardianKey(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGuardianKey + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGuardianKey(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianKey + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianKey + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianKey + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGuardianKey + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGuardianKey + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGuardianKey + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGuardianKey = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGuardianKey = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGuardianKey = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/guardian_set.pb.go b/wormchain/x/wormhole/types/guardian_set.pb.go new file mode 100644 index 000000000..6f30a06a1 --- /dev/null +++ b/wormchain/x/wormhole/types/guardian_set.pb.go @@ -0,0 +1,430 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/guardian_set.proto + +package types + +import ( + bytes "bytes" + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type GuardianSet struct { + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + Keys [][]byte `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"` + ExpirationTime uint64 `protobuf:"varint,3,opt,name=expirationTime,proto3" json:"expirationTime,omitempty"` +} + +func (m *GuardianSet) Reset() { *m = GuardianSet{} } +func (m *GuardianSet) String() string { return proto.CompactTextString(m) } +func (*GuardianSet) ProtoMessage() {} +func (*GuardianSet) Descriptor() ([]byte, []int) { + return fileDescriptor_3a6a773f49e89397, []int{0} +} +func (m *GuardianSet) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GuardianSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GuardianSet.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 *GuardianSet) XXX_Merge(src proto.Message) { + xxx_messageInfo_GuardianSet.Merge(m, src) +} +func (m *GuardianSet) XXX_Size() int { + return m.Size() +} +func (m *GuardianSet) XXX_DiscardUnknown() { + xxx_messageInfo_GuardianSet.DiscardUnknown(m) +} + +var xxx_messageInfo_GuardianSet proto.InternalMessageInfo + +func (m *GuardianSet) GetIndex() uint32 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *GuardianSet) GetKeys() [][]byte { + if m != nil { + return m.Keys + } + return nil +} + +func (m *GuardianSet) GetExpirationTime() uint64 { + if m != nil { + return m.ExpirationTime + } + return 0 +} + +func init() { + proto.RegisterType((*GuardianSet)(nil), "wormhole_foundation.wormchain.wormhole.GuardianSet") +} + +func init() { proto.RegisterFile("wormhole/guardian_set.proto", fileDescriptor_3a6a773f49e89397) } + +var fileDescriptor_3a6a773f49e89397 = []byte{ + // 231 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2e, 0xcf, 0x2f, 0xca, + 0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0x2f, 0x4d, 0x2c, 0x4a, 0xc9, 0x4c, 0xcc, 0x8b, 0x2f, 0x4e, + 0x2d, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x83, 0x49, 0xc6, 0xa7, 0xe5, 0x97, 0xe6, + 0xa5, 0x24, 0x96, 0x64, 0xe6, 0xe7, 0xe9, 0x81, 0xc4, 0x92, 0x33, 0x12, 0x33, 0x21, 0x2c, 0x90, + 0xac, 0x94, 0x48, 0x7a, 0x7e, 0x7a, 0x3e, 0x58, 0x8b, 0x3e, 0x88, 0x05, 0xd1, 0xad, 0x94, 0xca, + 0xc5, 0xed, 0x0e, 0x35, 0x33, 0x38, 0xb5, 0x44, 0x48, 0x84, 0x8b, 0x35, 0x33, 0x2f, 0x25, 0xb5, + 0x42, 0x82, 0x51, 0x81, 0x51, 0x83, 0x37, 0x08, 0xc2, 0x11, 0x12, 0xe2, 0x62, 0xc9, 0x4e, 0xad, + 0x2c, 0x96, 0x60, 0x52, 0x60, 0xd6, 0xe0, 0x09, 0x02, 0xb3, 0x85, 0xd4, 0xb8, 0xf8, 0x52, 0x2b, + 0x0a, 0x32, 0x8b, 0xc0, 0xf6, 0x85, 0x64, 0xe6, 0xa6, 0x4a, 0x30, 0x2b, 0x30, 0x6a, 0xb0, 0x04, + 0xa1, 0x89, 0x5a, 0xb1, 0xbc, 0x58, 0x20, 0xcf, 0xe8, 0x14, 0x7c, 0xe2, 0x91, 0x1c, 0xe3, 0x85, + 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, + 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0x96, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, + 0xfa, 0x30, 0xb7, 0xea, 0x22, 0x7c, 0xa2, 0x0f, 0xf7, 0x89, 0x7e, 0x05, 0x5c, 0x5e, 0xbf, 0xa4, + 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0xec, 0x05, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x97, + 0xa8, 0x99, 0x25, 0x1f, 0x01, 0x00, 0x00, +} + +func (this *GuardianSet) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*GuardianSet) + if !ok { + that2, ok := that.(GuardianSet) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Index != that1.Index { + return false + } + if len(this.Keys) != len(that1.Keys) { + return false + } + for i := range this.Keys { + if !bytes.Equal(this.Keys[i], that1.Keys[i]) { + return false + } + } + if this.ExpirationTime != that1.ExpirationTime { + return false + } + return true +} +func (m *GuardianSet) 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 *GuardianSet) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GuardianSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ExpirationTime != 0 { + i = encodeVarintGuardianSet(dAtA, i, uint64(m.ExpirationTime)) + i-- + dAtA[i] = 0x18 + } + if len(m.Keys) > 0 { + for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Keys[iNdEx]) + copy(dAtA[i:], m.Keys[iNdEx]) + i = encodeVarintGuardianSet(dAtA, i, uint64(len(m.Keys[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if m.Index != 0 { + i = encodeVarintGuardianSet(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintGuardianSet(dAtA []byte, offset int, v uint64) int { + offset -= sovGuardianSet(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GuardianSet) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != 0 { + n += 1 + sovGuardianSet(uint64(m.Index)) + } + if len(m.Keys) > 0 { + for _, b := range m.Keys { + l = len(b) + n += 1 + l + sovGuardianSet(uint64(l)) + } + } + if m.ExpirationTime != 0 { + n += 1 + sovGuardianSet(uint64(m.ExpirationTime)) + } + return n +} + +func sovGuardianSet(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGuardianSet(x uint64) (n int) { + return sovGuardianSet(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GuardianSet) 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 ErrIntOverflowGuardianSet + } + 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: GuardianSet: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GuardianSet: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuardianSet + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuardianSet + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGuardianSet + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGuardianSet + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) + copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType) + } + m.ExpirationTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuardianSet + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ExpirationTime |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGuardianSet(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGuardianSet + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGuardianSet(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianSet + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianSet + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianSet + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGuardianSet + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGuardianSet + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGuardianSet + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGuardianSet = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGuardianSet = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGuardianSet = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/guardian_validator.pb.go b/wormchain/x/wormhole/types/guardian_validator.pb.go new file mode 100644 index 000000000..f98c41462 --- /dev/null +++ b/wormchain/x/wormhole/types/guardian_validator.pb.go @@ -0,0 +1,372 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/guardian_validator.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type GuardianValidator struct { + GuardianKey []byte `protobuf:"bytes,1,opt,name=guardianKey,proto3" json:"guardianKey,omitempty"` + ValidatorAddr []byte `protobuf:"bytes,2,opt,name=validatorAddr,proto3" json:"validatorAddr,omitempty"` +} + +func (m *GuardianValidator) Reset() { *m = GuardianValidator{} } +func (m *GuardianValidator) String() string { return proto.CompactTextString(m) } +func (*GuardianValidator) ProtoMessage() {} +func (*GuardianValidator) Descriptor() ([]byte, []int) { + return fileDescriptor_a7e08ab792af660a, []int{0} +} +func (m *GuardianValidator) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GuardianValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GuardianValidator.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 *GuardianValidator) XXX_Merge(src proto.Message) { + xxx_messageInfo_GuardianValidator.Merge(m, src) +} +func (m *GuardianValidator) XXX_Size() int { + return m.Size() +} +func (m *GuardianValidator) XXX_DiscardUnknown() { + xxx_messageInfo_GuardianValidator.DiscardUnknown(m) +} + +var xxx_messageInfo_GuardianValidator proto.InternalMessageInfo + +func (m *GuardianValidator) GetGuardianKey() []byte { + if m != nil { + return m.GuardianKey + } + return nil +} + +func (m *GuardianValidator) GetValidatorAddr() []byte { + if m != nil { + return m.ValidatorAddr + } + return nil +} + +func init() { + proto.RegisterType((*GuardianValidator)(nil), "wormhole_foundation.wormchain.wormhole.GuardianValidator") +} + +func init() { proto.RegisterFile("wormhole/guardian_validator.proto", fileDescriptor_a7e08ab792af660a) } + +var fileDescriptor_a7e08ab792af660a = []byte{ + // 193 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2c, 0xcf, 0x2f, 0xca, + 0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0x2f, 0x4d, 0x2c, 0x4a, 0xc9, 0x4c, 0xcc, 0x8b, 0x2f, 0x4b, + 0xcc, 0xc9, 0x4c, 0x49, 0x2c, 0xc9, 0x2f, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x83, + 0x29, 0x89, 0x4f, 0xcb, 0x2f, 0xcd, 0x4b, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x89, 0x25, + 0x67, 0x24, 0x66, 0x42, 0x58, 0x20, 0x59, 0xa5, 0x68, 0x2e, 0x41, 0x77, 0xa8, 0x19, 0x61, 0x30, + 0x23, 0x84, 0x14, 0xb8, 0xb8, 0x61, 0x06, 0x7b, 0xa7, 0x56, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0xf0, + 0x04, 0x21, 0x0b, 0x09, 0xa9, 0x70, 0xf1, 0xc2, 0x6d, 0x74, 0x4c, 0x49, 0x29, 0x92, 0x60, 0x02, + 0xab, 0x41, 0x15, 0x74, 0x0a, 0x3e, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, + 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, + 0xcb, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x98, 0x5b, 0x74, 0x11, + 0x2e, 0xd5, 0x87, 0xbb, 0x54, 0xbf, 0x02, 0x2e, 0xaf, 0x5f, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, + 0x06, 0xf6, 0xa0, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x50, 0x80, 0xd5, 0x79, 0x05, 0x01, 0x00, + 0x00, +} + +func (m *GuardianValidator) 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 *GuardianValidator) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GuardianValidator) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorAddr) > 0 { + i -= len(m.ValidatorAddr) + copy(dAtA[i:], m.ValidatorAddr) + i = encodeVarintGuardianValidator(dAtA, i, uint64(len(m.ValidatorAddr))) + i-- + dAtA[i] = 0x12 + } + if len(m.GuardianKey) > 0 { + i -= len(m.GuardianKey) + copy(dAtA[i:], m.GuardianKey) + i = encodeVarintGuardianValidator(dAtA, i, uint64(len(m.GuardianKey))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintGuardianValidator(dAtA []byte, offset int, v uint64) int { + offset -= sovGuardianValidator(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GuardianValidator) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.GuardianKey) + if l > 0 { + n += 1 + l + sovGuardianValidator(uint64(l)) + } + l = len(m.ValidatorAddr) + if l > 0 { + n += 1 + l + sovGuardianValidator(uint64(l)) + } + return n +} + +func sovGuardianValidator(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGuardianValidator(x uint64) (n int) { + return sovGuardianValidator(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GuardianValidator) 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 ErrIntOverflowGuardianValidator + } + 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: GuardianValidator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GuardianValidator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuardianValidator + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGuardianValidator + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGuardianValidator + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GuardianKey = append(m.GuardianKey[:0], dAtA[iNdEx:postIndex]...) + if m.GuardianKey == nil { + m.GuardianKey = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuardianValidator + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGuardianValidator + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGuardianValidator + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddr = append(m.ValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddr == nil { + m.ValidatorAddr = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGuardianValidator(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGuardianValidator + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGuardianValidator(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianValidator + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianValidator + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuardianValidator + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGuardianValidator + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGuardianValidator + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGuardianValidator + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGuardianValidator = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGuardianValidator = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGuardianValidator = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/query.pb.go b/wormchain/x/wormhole/types/query.pb.go new file mode 100644 index 000000000..986d22db6 --- /dev/null +++ b/wormchain/x/wormhole/types/query.pb.go @@ -0,0 +1,4569 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/query.proto + +package types + +import ( + context "context" + fmt "fmt" + query "github.com/cosmos/cosmos-sdk/types/query" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type QueryGetGuardianSetRequest struct { + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` +} + +func (m *QueryGetGuardianSetRequest) Reset() { *m = QueryGetGuardianSetRequest{} } +func (m *QueryGetGuardianSetRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetGuardianSetRequest) ProtoMessage() {} +func (*QueryGetGuardianSetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{0} +} +func (m *QueryGetGuardianSetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetGuardianSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetGuardianSetRequest.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 *QueryGetGuardianSetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetGuardianSetRequest.Merge(m, src) +} +func (m *QueryGetGuardianSetRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetGuardianSetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetGuardianSetRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetGuardianSetRequest proto.InternalMessageInfo + +func (m *QueryGetGuardianSetRequest) GetIndex() uint32 { + if m != nil { + return m.Index + } + return 0 +} + +type QueryGetGuardianSetResponse struct { + GuardianSet GuardianSet `protobuf:"bytes,1,opt,name=GuardianSet,proto3" json:"GuardianSet"` +} + +func (m *QueryGetGuardianSetResponse) Reset() { *m = QueryGetGuardianSetResponse{} } +func (m *QueryGetGuardianSetResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetGuardianSetResponse) ProtoMessage() {} +func (*QueryGetGuardianSetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{1} +} +func (m *QueryGetGuardianSetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetGuardianSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetGuardianSetResponse.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 *QueryGetGuardianSetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetGuardianSetResponse.Merge(m, src) +} +func (m *QueryGetGuardianSetResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetGuardianSetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetGuardianSetResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetGuardianSetResponse proto.InternalMessageInfo + +func (m *QueryGetGuardianSetResponse) GetGuardianSet() GuardianSet { + if m != nil { + return m.GuardianSet + } + return GuardianSet{} +} + +type QueryAllGuardianSetRequest struct { + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllGuardianSetRequest) Reset() { *m = QueryAllGuardianSetRequest{} } +func (m *QueryAllGuardianSetRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllGuardianSetRequest) ProtoMessage() {} +func (*QueryAllGuardianSetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{2} +} +func (m *QueryAllGuardianSetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllGuardianSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllGuardianSetRequest.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 *QueryAllGuardianSetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllGuardianSetRequest.Merge(m, src) +} +func (m *QueryAllGuardianSetRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllGuardianSetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllGuardianSetRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllGuardianSetRequest proto.InternalMessageInfo + +func (m *QueryAllGuardianSetRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryAllGuardianSetResponse struct { + GuardianSet []GuardianSet `protobuf:"bytes,1,rep,name=GuardianSet,proto3" json:"GuardianSet"` + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllGuardianSetResponse) Reset() { *m = QueryAllGuardianSetResponse{} } +func (m *QueryAllGuardianSetResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllGuardianSetResponse) ProtoMessage() {} +func (*QueryAllGuardianSetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{3} +} +func (m *QueryAllGuardianSetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllGuardianSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllGuardianSetResponse.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 *QueryAllGuardianSetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllGuardianSetResponse.Merge(m, src) +} +func (m *QueryAllGuardianSetResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllGuardianSetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllGuardianSetResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllGuardianSetResponse proto.InternalMessageInfo + +func (m *QueryAllGuardianSetResponse) GetGuardianSet() []GuardianSet { + if m != nil { + return m.GuardianSet + } + return nil +} + +func (m *QueryAllGuardianSetResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryGetConfigRequest struct { +} + +func (m *QueryGetConfigRequest) Reset() { *m = QueryGetConfigRequest{} } +func (m *QueryGetConfigRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetConfigRequest) ProtoMessage() {} +func (*QueryGetConfigRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{4} +} +func (m *QueryGetConfigRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetConfigRequest.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 *QueryGetConfigRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetConfigRequest.Merge(m, src) +} +func (m *QueryGetConfigRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetConfigRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetConfigRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetConfigRequest proto.InternalMessageInfo + +type QueryGetConfigResponse struct { + Config Config `protobuf:"bytes,1,opt,name=Config,proto3" json:"Config"` +} + +func (m *QueryGetConfigResponse) Reset() { *m = QueryGetConfigResponse{} } +func (m *QueryGetConfigResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetConfigResponse) ProtoMessage() {} +func (*QueryGetConfigResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{5} +} +func (m *QueryGetConfigResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetConfigResponse.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 *QueryGetConfigResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetConfigResponse.Merge(m, src) +} +func (m *QueryGetConfigResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetConfigResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetConfigResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetConfigResponse proto.InternalMessageInfo + +func (m *QueryGetConfigResponse) GetConfig() Config { + if m != nil { + return m.Config + } + return Config{} +} + +type QueryGetReplayProtectionRequest struct { + Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"` +} + +func (m *QueryGetReplayProtectionRequest) Reset() { *m = QueryGetReplayProtectionRequest{} } +func (m *QueryGetReplayProtectionRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetReplayProtectionRequest) ProtoMessage() {} +func (*QueryGetReplayProtectionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{6} +} +func (m *QueryGetReplayProtectionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetReplayProtectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetReplayProtectionRequest.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 *QueryGetReplayProtectionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetReplayProtectionRequest.Merge(m, src) +} +func (m *QueryGetReplayProtectionRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetReplayProtectionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetReplayProtectionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetReplayProtectionRequest proto.InternalMessageInfo + +func (m *QueryGetReplayProtectionRequest) GetIndex() string { + if m != nil { + return m.Index + } + return "" +} + +type QueryGetReplayProtectionResponse struct { + ReplayProtection ReplayProtection `protobuf:"bytes,1,opt,name=replayProtection,proto3" json:"replayProtection"` +} + +func (m *QueryGetReplayProtectionResponse) Reset() { *m = QueryGetReplayProtectionResponse{} } +func (m *QueryGetReplayProtectionResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetReplayProtectionResponse) ProtoMessage() {} +func (*QueryGetReplayProtectionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{7} +} +func (m *QueryGetReplayProtectionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetReplayProtectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetReplayProtectionResponse.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 *QueryGetReplayProtectionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetReplayProtectionResponse.Merge(m, src) +} +func (m *QueryGetReplayProtectionResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetReplayProtectionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetReplayProtectionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetReplayProtectionResponse proto.InternalMessageInfo + +func (m *QueryGetReplayProtectionResponse) GetReplayProtection() ReplayProtection { + if m != nil { + return m.ReplayProtection + } + return ReplayProtection{} +} + +type QueryAllReplayProtectionRequest struct { + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllReplayProtectionRequest) Reset() { *m = QueryAllReplayProtectionRequest{} } +func (m *QueryAllReplayProtectionRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllReplayProtectionRequest) ProtoMessage() {} +func (*QueryAllReplayProtectionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{8} +} +func (m *QueryAllReplayProtectionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllReplayProtectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllReplayProtectionRequest.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 *QueryAllReplayProtectionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllReplayProtectionRequest.Merge(m, src) +} +func (m *QueryAllReplayProtectionRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllReplayProtectionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllReplayProtectionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllReplayProtectionRequest proto.InternalMessageInfo + +func (m *QueryAllReplayProtectionRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryAllReplayProtectionResponse struct { + ReplayProtection []ReplayProtection `protobuf:"bytes,1,rep,name=replayProtection,proto3" json:"replayProtection"` + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllReplayProtectionResponse) Reset() { *m = QueryAllReplayProtectionResponse{} } +func (m *QueryAllReplayProtectionResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllReplayProtectionResponse) ProtoMessage() {} +func (*QueryAllReplayProtectionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{9} +} +func (m *QueryAllReplayProtectionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllReplayProtectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllReplayProtectionResponse.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 *QueryAllReplayProtectionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllReplayProtectionResponse.Merge(m, src) +} +func (m *QueryAllReplayProtectionResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllReplayProtectionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllReplayProtectionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllReplayProtectionResponse proto.InternalMessageInfo + +func (m *QueryAllReplayProtectionResponse) GetReplayProtection() []ReplayProtection { + if m != nil { + return m.ReplayProtection + } + return nil +} + +func (m *QueryAllReplayProtectionResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryGetSequenceCounterRequest struct { + Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"` +} + +func (m *QueryGetSequenceCounterRequest) Reset() { *m = QueryGetSequenceCounterRequest{} } +func (m *QueryGetSequenceCounterRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetSequenceCounterRequest) ProtoMessage() {} +func (*QueryGetSequenceCounterRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{10} +} +func (m *QueryGetSequenceCounterRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetSequenceCounterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetSequenceCounterRequest.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 *QueryGetSequenceCounterRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetSequenceCounterRequest.Merge(m, src) +} +func (m *QueryGetSequenceCounterRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetSequenceCounterRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetSequenceCounterRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetSequenceCounterRequest proto.InternalMessageInfo + +func (m *QueryGetSequenceCounterRequest) GetIndex() string { + if m != nil { + return m.Index + } + return "" +} + +type QueryGetSequenceCounterResponse struct { + SequenceCounter SequenceCounter `protobuf:"bytes,1,opt,name=sequenceCounter,proto3" json:"sequenceCounter"` +} + +func (m *QueryGetSequenceCounterResponse) Reset() { *m = QueryGetSequenceCounterResponse{} } +func (m *QueryGetSequenceCounterResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetSequenceCounterResponse) ProtoMessage() {} +func (*QueryGetSequenceCounterResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{11} +} +func (m *QueryGetSequenceCounterResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetSequenceCounterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetSequenceCounterResponse.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 *QueryGetSequenceCounterResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetSequenceCounterResponse.Merge(m, src) +} +func (m *QueryGetSequenceCounterResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetSequenceCounterResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetSequenceCounterResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetSequenceCounterResponse proto.InternalMessageInfo + +func (m *QueryGetSequenceCounterResponse) GetSequenceCounter() SequenceCounter { + if m != nil { + return m.SequenceCounter + } + return SequenceCounter{} +} + +type QueryAllSequenceCounterRequest struct { + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllSequenceCounterRequest) Reset() { *m = QueryAllSequenceCounterRequest{} } +func (m *QueryAllSequenceCounterRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllSequenceCounterRequest) ProtoMessage() {} +func (*QueryAllSequenceCounterRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{12} +} +func (m *QueryAllSequenceCounterRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllSequenceCounterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllSequenceCounterRequest.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 *QueryAllSequenceCounterRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllSequenceCounterRequest.Merge(m, src) +} +func (m *QueryAllSequenceCounterRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllSequenceCounterRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllSequenceCounterRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllSequenceCounterRequest proto.InternalMessageInfo + +func (m *QueryAllSequenceCounterRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryAllSequenceCounterResponse struct { + SequenceCounter []SequenceCounter `protobuf:"bytes,1,rep,name=sequenceCounter,proto3" json:"sequenceCounter"` + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllSequenceCounterResponse) Reset() { *m = QueryAllSequenceCounterResponse{} } +func (m *QueryAllSequenceCounterResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllSequenceCounterResponse) ProtoMessage() {} +func (*QueryAllSequenceCounterResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{13} +} +func (m *QueryAllSequenceCounterResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllSequenceCounterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllSequenceCounterResponse.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 *QueryAllSequenceCounterResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllSequenceCounterResponse.Merge(m, src) +} +func (m *QueryAllSequenceCounterResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllSequenceCounterResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllSequenceCounterResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllSequenceCounterResponse proto.InternalMessageInfo + +func (m *QueryAllSequenceCounterResponse) GetSequenceCounter() []SequenceCounter { + if m != nil { + return m.SequenceCounter + } + return nil +} + +func (m *QueryAllSequenceCounterResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryGetConsensusGuardianSetIndexRequest struct { +} + +func (m *QueryGetConsensusGuardianSetIndexRequest) Reset() { + *m = QueryGetConsensusGuardianSetIndexRequest{} +} +func (m *QueryGetConsensusGuardianSetIndexRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetConsensusGuardianSetIndexRequest) ProtoMessage() {} +func (*QueryGetConsensusGuardianSetIndexRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{14} +} +func (m *QueryGetConsensusGuardianSetIndexRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetConsensusGuardianSetIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetConsensusGuardianSetIndexRequest.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 *QueryGetConsensusGuardianSetIndexRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetConsensusGuardianSetIndexRequest.Merge(m, src) +} +func (m *QueryGetConsensusGuardianSetIndexRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetConsensusGuardianSetIndexRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetConsensusGuardianSetIndexRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetConsensusGuardianSetIndexRequest proto.InternalMessageInfo + +type QueryGetConsensusGuardianSetIndexResponse struct { + ConsensusGuardianSetIndex ConsensusGuardianSetIndex `protobuf:"bytes,1,opt,name=ConsensusGuardianSetIndex,proto3" json:"ConsensusGuardianSetIndex"` +} + +func (m *QueryGetConsensusGuardianSetIndexResponse) Reset() { + *m = QueryGetConsensusGuardianSetIndexResponse{} +} +func (m *QueryGetConsensusGuardianSetIndexResponse) String() string { + return proto.CompactTextString(m) +} +func (*QueryGetConsensusGuardianSetIndexResponse) ProtoMessage() {} +func (*QueryGetConsensusGuardianSetIndexResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{15} +} +func (m *QueryGetConsensusGuardianSetIndexResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetConsensusGuardianSetIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetConsensusGuardianSetIndexResponse.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 *QueryGetConsensusGuardianSetIndexResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetConsensusGuardianSetIndexResponse.Merge(m, src) +} +func (m *QueryGetConsensusGuardianSetIndexResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetConsensusGuardianSetIndexResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetConsensusGuardianSetIndexResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetConsensusGuardianSetIndexResponse proto.InternalMessageInfo + +func (m *QueryGetConsensusGuardianSetIndexResponse) GetConsensusGuardianSetIndex() ConsensusGuardianSetIndex { + if m != nil { + return m.ConsensusGuardianSetIndex + } + return ConsensusGuardianSetIndex{} +} + +type QueryGetGuardianValidatorRequest struct { + GuardianKey []byte `protobuf:"bytes,1,opt,name=guardianKey,proto3" json:"guardianKey,omitempty"` +} + +func (m *QueryGetGuardianValidatorRequest) Reset() { *m = QueryGetGuardianValidatorRequest{} } +func (m *QueryGetGuardianValidatorRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetGuardianValidatorRequest) ProtoMessage() {} +func (*QueryGetGuardianValidatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{16} +} +func (m *QueryGetGuardianValidatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetGuardianValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetGuardianValidatorRequest.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 *QueryGetGuardianValidatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetGuardianValidatorRequest.Merge(m, src) +} +func (m *QueryGetGuardianValidatorRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetGuardianValidatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetGuardianValidatorRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetGuardianValidatorRequest proto.InternalMessageInfo + +func (m *QueryGetGuardianValidatorRequest) GetGuardianKey() []byte { + if m != nil { + return m.GuardianKey + } + return nil +} + +type QueryGetGuardianValidatorResponse struct { + GuardianValidator GuardianValidator `protobuf:"bytes,1,opt,name=guardianValidator,proto3" json:"guardianValidator"` +} + +func (m *QueryGetGuardianValidatorResponse) Reset() { *m = QueryGetGuardianValidatorResponse{} } +func (m *QueryGetGuardianValidatorResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetGuardianValidatorResponse) ProtoMessage() {} +func (*QueryGetGuardianValidatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{17} +} +func (m *QueryGetGuardianValidatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetGuardianValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetGuardianValidatorResponse.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 *QueryGetGuardianValidatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetGuardianValidatorResponse.Merge(m, src) +} +func (m *QueryGetGuardianValidatorResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetGuardianValidatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetGuardianValidatorResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetGuardianValidatorResponse proto.InternalMessageInfo + +func (m *QueryGetGuardianValidatorResponse) GetGuardianValidator() GuardianValidator { + if m != nil { + return m.GuardianValidator + } + return GuardianValidator{} +} + +type QueryAllGuardianValidatorRequest struct { + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllGuardianValidatorRequest) Reset() { *m = QueryAllGuardianValidatorRequest{} } +func (m *QueryAllGuardianValidatorRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllGuardianValidatorRequest) ProtoMessage() {} +func (*QueryAllGuardianValidatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{18} +} +func (m *QueryAllGuardianValidatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllGuardianValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllGuardianValidatorRequest.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 *QueryAllGuardianValidatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllGuardianValidatorRequest.Merge(m, src) +} +func (m *QueryAllGuardianValidatorRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllGuardianValidatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllGuardianValidatorRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllGuardianValidatorRequest proto.InternalMessageInfo + +func (m *QueryAllGuardianValidatorRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryAllGuardianValidatorResponse struct { + GuardianValidator []GuardianValidator `protobuf:"bytes,1,rep,name=guardianValidator,proto3" json:"guardianValidator"` + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllGuardianValidatorResponse) Reset() { *m = QueryAllGuardianValidatorResponse{} } +func (m *QueryAllGuardianValidatorResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllGuardianValidatorResponse) ProtoMessage() {} +func (*QueryAllGuardianValidatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{19} +} +func (m *QueryAllGuardianValidatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllGuardianValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllGuardianValidatorResponse.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 *QueryAllGuardianValidatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllGuardianValidatorResponse.Merge(m, src) +} +func (m *QueryAllGuardianValidatorResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllGuardianValidatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllGuardianValidatorResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllGuardianValidatorResponse proto.InternalMessageInfo + +func (m *QueryAllGuardianValidatorResponse) GetGuardianValidator() []GuardianValidator { + if m != nil { + return m.GuardianValidator + } + return nil +} + +func (m *QueryAllGuardianValidatorResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryLatestGuardianSetIndexRequest struct { +} + +func (m *QueryLatestGuardianSetIndexRequest) Reset() { *m = QueryLatestGuardianSetIndexRequest{} } +func (m *QueryLatestGuardianSetIndexRequest) String() string { return proto.CompactTextString(m) } +func (*QueryLatestGuardianSetIndexRequest) ProtoMessage() {} +func (*QueryLatestGuardianSetIndexRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{20} +} +func (m *QueryLatestGuardianSetIndexRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLatestGuardianSetIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLatestGuardianSetIndexRequest.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 *QueryLatestGuardianSetIndexRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLatestGuardianSetIndexRequest.Merge(m, src) +} +func (m *QueryLatestGuardianSetIndexRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryLatestGuardianSetIndexRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLatestGuardianSetIndexRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLatestGuardianSetIndexRequest proto.InternalMessageInfo + +type QueryLatestGuardianSetIndexResponse struct { + LatestGuardianSetIndex uint32 `protobuf:"varint,1,opt,name=latestGuardianSetIndex,proto3" json:"latestGuardianSetIndex,omitempty"` +} + +func (m *QueryLatestGuardianSetIndexResponse) Reset() { *m = QueryLatestGuardianSetIndexResponse{} } +func (m *QueryLatestGuardianSetIndexResponse) String() string { return proto.CompactTextString(m) } +func (*QueryLatestGuardianSetIndexResponse) ProtoMessage() {} +func (*QueryLatestGuardianSetIndexResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_273185ecc792fa38, []int{21} +} +func (m *QueryLatestGuardianSetIndexResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLatestGuardianSetIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLatestGuardianSetIndexResponse.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 *QueryLatestGuardianSetIndexResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLatestGuardianSetIndexResponse.Merge(m, src) +} +func (m *QueryLatestGuardianSetIndexResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryLatestGuardianSetIndexResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLatestGuardianSetIndexResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLatestGuardianSetIndexResponse proto.InternalMessageInfo + +func (m *QueryLatestGuardianSetIndexResponse) GetLatestGuardianSetIndex() uint32 { + if m != nil { + return m.LatestGuardianSetIndex + } + return 0 +} + +func init() { + proto.RegisterType((*QueryGetGuardianSetRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetGuardianSetRequest") + proto.RegisterType((*QueryGetGuardianSetResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetGuardianSetResponse") + proto.RegisterType((*QueryAllGuardianSetRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllGuardianSetRequest") + proto.RegisterType((*QueryAllGuardianSetResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllGuardianSetResponse") + proto.RegisterType((*QueryGetConfigRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetConfigRequest") + proto.RegisterType((*QueryGetConfigResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetConfigResponse") + proto.RegisterType((*QueryGetReplayProtectionRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetReplayProtectionRequest") + proto.RegisterType((*QueryGetReplayProtectionResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetReplayProtectionResponse") + proto.RegisterType((*QueryAllReplayProtectionRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllReplayProtectionRequest") + proto.RegisterType((*QueryAllReplayProtectionResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllReplayProtectionResponse") + proto.RegisterType((*QueryGetSequenceCounterRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetSequenceCounterRequest") + proto.RegisterType((*QueryGetSequenceCounterResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetSequenceCounterResponse") + proto.RegisterType((*QueryAllSequenceCounterRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllSequenceCounterRequest") + proto.RegisterType((*QueryAllSequenceCounterResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllSequenceCounterResponse") + proto.RegisterType((*QueryGetConsensusGuardianSetIndexRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetConsensusGuardianSetIndexRequest") + proto.RegisterType((*QueryGetConsensusGuardianSetIndexResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetConsensusGuardianSetIndexResponse") + proto.RegisterType((*QueryGetGuardianValidatorRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetGuardianValidatorRequest") + proto.RegisterType((*QueryGetGuardianValidatorResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryGetGuardianValidatorResponse") + proto.RegisterType((*QueryAllGuardianValidatorRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllGuardianValidatorRequest") + proto.RegisterType((*QueryAllGuardianValidatorResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllGuardianValidatorResponse") + proto.RegisterType((*QueryLatestGuardianSetIndexRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryLatestGuardianSetIndexRequest") + proto.RegisterType((*QueryLatestGuardianSetIndexResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryLatestGuardianSetIndexResponse") +} + +func init() { proto.RegisterFile("wormhole/query.proto", fileDescriptor_273185ecc792fa38) } + +var fileDescriptor_273185ecc792fa38 = []byte{ + // 1117 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x98, 0xcf, 0x6f, 0x1b, 0x45, + 0x14, 0xc7, 0x33, 0x09, 0xad, 0xc4, 0x04, 0x68, 0x3b, 0xb8, 0x01, 0xb6, 0xc8, 0x49, 0x07, 0x54, + 0x4a, 0x11, 0xbb, 0x34, 0x11, 0x49, 0xd3, 0x52, 0x5a, 0xdb, 0x55, 0xec, 0xb4, 0x39, 0xa4, 0x8e, + 0xc4, 0x01, 0x84, 0xac, 0x8d, 0x3d, 0xd9, 0x6c, 0xb5, 0xd9, 0x71, 0xbd, 0xeb, 0xd2, 0x50, 0xf5, + 0x82, 0xc4, 0x85, 0x43, 0x85, 0xe0, 0x4f, 0x41, 0x9c, 0x39, 0x70, 0xe9, 0xb1, 0x52, 0x25, 0x40, + 0xaa, 0x84, 0x50, 0x82, 0x38, 0xc0, 0x81, 0x3b, 0xe2, 0x80, 0x76, 0xe6, 0xed, 0x7a, 0xbd, 0xde, + 0x5d, 0x76, 0xed, 0xcd, 0xcd, 0x99, 0x1f, 0xdf, 0x79, 0x9f, 0xf7, 0x9e, 0x67, 0xbe, 0x31, 0x2e, + 0x7d, 0xc6, 0x7b, 0x7b, 0xbb, 0xdc, 0x62, 0xda, 0xdd, 0x3e, 0xeb, 0xed, 0xab, 0xdd, 0x1e, 0x77, + 0x39, 0x39, 0xe7, 0x8f, 0xb6, 0x76, 0x78, 0xdf, 0xee, 0xe8, 0xae, 0xc9, 0x6d, 0xd5, 0x1b, 0x6b, + 0xef, 0xea, 0xa6, 0xfc, 0xe4, 0xcd, 0x2a, 0xaf, 0x1b, 0x9c, 0x1b, 0x16, 0xd3, 0xf4, 0xae, 0xa9, + 0xe9, 0xb6, 0xcd, 0x5d, 0xb1, 0xd2, 0x91, 0x2a, 0xca, 0x85, 0x36, 0x77, 0xf6, 0xb8, 0xa3, 0x6d, + 0xeb, 0x0e, 0xc8, 0x6b, 0xf7, 0x2e, 0x6e, 0x33, 0x57, 0xbf, 0xa8, 0x75, 0x75, 0xc3, 0xb4, 0xa5, + 0xac, 0x5c, 0x7b, 0x26, 0x88, 0xc3, 0xe8, 0xeb, 0xbd, 0x8e, 0xa9, 0xdb, 0x2d, 0x87, 0xb9, 0x30, + 0x79, 0x3a, 0x98, 0x6c, 0x73, 0x7b, 0xc7, 0x34, 0x60, 0x78, 0x21, 0x18, 0xee, 0xb1, 0xae, 0xa5, + 0xef, 0xb7, 0xbc, 0x61, 0xd6, 0x0e, 0xa9, 0xce, 0x07, 0x2b, 0x1c, 0x76, 0xb7, 0xcf, 0xec, 0x36, + 0x6b, 0xb5, 0x79, 0xdf, 0x76, 0x59, 0x0f, 0x16, 0xbc, 0x13, 0x56, 0x76, 0x98, 0xed, 0xf4, 0x9d, + 0x56, 0x38, 0x80, 0x96, 0x69, 0x77, 0xd8, 0x7d, 0x58, 0x7c, 0x76, 0x34, 0xc6, 0x7b, 0xba, 0x65, + 0x76, 0x74, 0x97, 0xfb, 0x7a, 0x25, 0x83, 0x1b, 0x5c, 0x7c, 0xd4, 0xbc, 0x4f, 0x72, 0x94, 0x2e, + 0x62, 0xe5, 0xb6, 0x87, 0x5f, 0x67, 0x6e, 0x1d, 0x76, 0x6e, 0x31, 0xb7, 0xe9, 0x85, 0xe4, 0xb8, + 0xa4, 0x84, 0x8f, 0x89, 0x53, 0x5e, 0x45, 0x0b, 0xe8, 0xfc, 0x8b, 0x4d, 0xf9, 0x07, 0xfd, 0x1c, + 0x9f, 0x89, 0xdd, 0xe3, 0x74, 0xbd, 0x40, 0xc9, 0x27, 0x78, 0x36, 0x34, 0x2c, 0xb6, 0xce, 0x2e, + 0x2e, 0xa9, 0xd9, 0xea, 0xa6, 0x86, 0xb6, 0x56, 0x9f, 0x7b, 0xfc, 0xeb, 0xfc, 0x54, 0x33, 0xac, + 0x46, 0x3b, 0x10, 0x6f, 0xc5, 0xb2, 0x62, 0xe2, 0x5d, 0xc3, 0x78, 0x50, 0x3e, 0x38, 0xf9, 0x9c, + 0x2a, 0x6b, 0xad, 0x7a, 0xb5, 0x56, 0x65, 0x2b, 0x41, 0xad, 0xd5, 0x4d, 0xdd, 0x60, 0xb0, 0xb7, + 0x19, 0xda, 0x49, 0x7f, 0x44, 0x80, 0x18, 0x3d, 0x26, 0x09, 0x71, 0xa6, 0x38, 0x44, 0x52, 0x1f, + 0x82, 0x98, 0x16, 0x10, 0x6f, 0xfd, 0x2f, 0x84, 0x8c, 0x6c, 0x88, 0xe2, 0x15, 0x7c, 0xda, 0xaf, + 0x53, 0x4d, 0x34, 0x27, 0xa0, 0xd2, 0x1d, 0x3c, 0x17, 0x9d, 0x00, 0xb0, 0x0d, 0x7c, 0x5c, 0x8e, + 0x40, 0xf2, 0xd4, 0xac, 0x4c, 0x72, 0x17, 0xe0, 0x80, 0x06, 0x5d, 0xc1, 0xf3, 0xfe, 0x39, 0x4d, + 0xf1, 0x35, 0xd8, 0x0c, 0xbe, 0x05, 0xb1, 0x1d, 0xf6, 0xbc, 0xdf, 0x61, 0x8f, 0x10, 0x5e, 0x48, + 0xde, 0x09, 0xb1, 0xde, 0xc1, 0x27, 0x7b, 0x91, 0x39, 0x88, 0xfa, 0x52, 0xd6, 0xa8, 0xa3, 0xda, + 0x10, 0xff, 0x88, 0x2e, 0x35, 0x81, 0xa4, 0x62, 0x59, 0x49, 0x24, 0x45, 0xf5, 0xde, 0xcf, 0x3e, + 0x7b, 0xec, 0x59, 0xa9, 0xec, 0x33, 0x47, 0xc1, 0x5e, 0x5c, 0x3f, 0x2e, 0xe3, 0xb2, 0x5f, 0xd4, + 0x2d, 0xb8, 0xf3, 0x6a, 0xf2, 0xca, 0x4b, 0xef, 0x86, 0xaf, 0xd0, 0xa0, 0x8f, 0x46, 0x36, 0x42, + 0x42, 0x0c, 0x7c, 0xc2, 0x19, 0x9e, 0x82, 0x12, 0xac, 0x64, 0xcd, 0x47, 0x44, 0x19, 0xd2, 0x11, + 0x55, 0xa5, 0xbb, 0x00, 0x51, 0xb1, 0xac, 0x04, 0x88, 0xa2, 0x1a, 0xe1, 0x29, 0x1a, 0x34, 0x5d, + 0x2e, 0xec, 0x99, 0xe2, 0xb1, 0x8b, 0x6b, 0x82, 0x0b, 0xf8, 0x7c, 0xe8, 0xee, 0x91, 0xef, 0x5a, + 0xe8, 0xf6, 0x5b, 0xf7, 0x2a, 0xee, 0xdf, 0x53, 0xdf, 0x21, 0xfc, 0x76, 0x86, 0xc5, 0x90, 0x8b, + 0x2f, 0x11, 0x7e, 0x2d, 0x71, 0x15, 0xd4, 0xa1, 0x92, 0xe3, 0x3e, 0x8b, 0x17, 0x82, 0x04, 0x25, + 0x9f, 0x44, 0x6f, 0x0c, 0xee, 0x2e, 0x7f, 0xee, 0x23, 0xff, 0x2d, 0xf6, 0x7b, 0x64, 0x01, 0xcf, + 0xfa, 0x0f, 0xf5, 0x2d, 0xb6, 0x2f, 0x82, 0x7b, 0xa1, 0x19, 0x1e, 0xa2, 0xdf, 0x20, 0x7c, 0x36, + 0x45, 0x06, 0x98, 0xf7, 0xf0, 0x29, 0x23, 0x3a, 0x09, 0xa8, 0xab, 0x79, 0x9f, 0xa3, 0x40, 0x00, + 0x10, 0x47, 0x95, 0xe9, 0x9d, 0xc1, 0xd5, 0x94, 0x88, 0x56, 0x54, 0xfb, 0x3f, 0xf3, 0x13, 0x10, + 0x7f, 0x58, 0x7a, 0x02, 0x66, 0x8e, 0x26, 0x01, 0xc5, 0x7d, 0x0d, 0xde, 0xc4, 0x54, 0xc0, 0x6d, + 0xe8, 0x2e, 0x73, 0xdc, 0xa4, 0x2f, 0xc0, 0xa7, 0xf8, 0x8d, 0xd4, 0x55, 0x90, 0x84, 0x65, 0x3c, + 0x67, 0xc5, 0xae, 0x00, 0xdf, 0x96, 0x30, 0xbb, 0xf8, 0x7d, 0x09, 0x1f, 0x13, 0xfa, 0xe4, 0x19, + 0x1a, 0x72, 0x34, 0xa4, 0x9a, 0x35, 0x77, 0xc9, 0xe6, 0x51, 0xa9, 0x4d, 0xa4, 0x21, 0xd1, 0x68, + 0xed, 0x8b, 0xa7, 0xbf, 0x7f, 0x3b, 0x7d, 0x95, 0x5c, 0xd1, 0x62, 0xc4, 0xb4, 0x40, 0x4c, 0x1b, + 0xf1, 0xbf, 0x5b, 0xcc, 0xd5, 0x1e, 0x88, 0xf7, 0xe3, 0x21, 0xf9, 0x09, 0xe1, 0x97, 0x42, 0xe2, + 0x15, 0xcb, 0xca, 0x09, 0x18, 0xeb, 0x36, 0x73, 0x02, 0xc6, 0x5b, 0x49, 0x7a, 0x45, 0x00, 0xbe, + 0x4f, 0x96, 0xc6, 0x00, 0x24, 0x3f, 0x20, 0xdf, 0xaf, 0x91, 0xab, 0x79, 0xb3, 0x3d, 0x64, 0x09, + 0x95, 0x0f, 0xc7, 0xdd, 0x0e, 0x18, 0xcb, 0x02, 0xe3, 0x3d, 0xa2, 0x66, 0xc5, 0x90, 0xff, 0x2e, + 0x91, 0xbf, 0x11, 0x3e, 0xd9, 0x1c, 0x71, 0x1c, 0x79, 0x83, 0x49, 0xf0, 0x64, 0x4a, 0x63, 0x72, + 0x21, 0xe0, 0x6b, 0x08, 0xbe, 0x2a, 0xb9, 0x9e, 0x95, 0x2f, 0x6a, 0xa3, 0x82, 0x66, 0xfc, 0x13, + 0xe1, 0x97, 0xa3, 0xc7, 0x78, 0x1d, 0x59, 0xcf, 0xdb, 0x4d, 0xc5, 0x40, 0xa7, 0xb8, 0x4c, 0x7a, + 0x5d, 0x40, 0x5f, 0x26, 0x97, 0xc6, 0x85, 0x26, 0x7f, 0x21, 0x7c, 0x22, 0xe2, 0x30, 0xc8, 0x5a, + 0xde, 0xa2, 0xc4, 0xfb, 0x2c, 0xa5, 0x3e, 0xb1, 0x0e, 0x60, 0xd6, 0x05, 0x66, 0x85, 0x5c, 0xcb, + 0x8a, 0x19, 0x31, 0x47, 0x41, 0x69, 0xff, 0x40, 0x98, 0x44, 0x0e, 0xf1, 0x2a, 0xbb, 0x96, 0xb7, + 0x20, 0x85, 0x00, 0x27, 0xbb, 0x46, 0x7a, 0x4d, 0x00, 0xaf, 0x92, 0x95, 0x31, 0x81, 0xc9, 0xa3, + 0xe9, 0x14, 0xab, 0x45, 0x36, 0xc7, 0xb8, 0x4b, 0x52, 0x8d, 0xa0, 0x72, 0xbb, 0x40, 0x45, 0xc8, + 0xc1, 0x86, 0xc8, 0xc1, 0x1a, 0xb9, 0x91, 0xe3, 0xc2, 0x4a, 0xfc, 0x15, 0x86, 0xfc, 0x83, 0xf0, + 0xa9, 0x11, 0x1b, 0x41, 0x1a, 0xe3, 0xbe, 0x80, 0x51, 0x53, 0xa5, 0xac, 0x17, 0xa0, 0x04, 0xe0, + 0x9b, 0x02, 0xfc, 0x26, 0x69, 0xe4, 0x7d, 0x70, 0x06, 0xbf, 0x28, 0x69, 0x0f, 0x42, 0x4e, 0xf5, + 0xa1, 0x77, 0x87, 0x97, 0x46, 0xce, 0xf3, 0x1a, 0xbf, 0x31, 0xee, 0x03, 0x39, 0x21, 0x7f, 0x9a, + 0x63, 0xa4, 0x55, 0xc1, 0xff, 0x01, 0xb9, 0x3c, 0x3e, 0x3f, 0xf9, 0x17, 0xe1, 0xb9, 0x78, 0x4f, + 0x46, 0x6e, 0xe6, 0x8a, 0x34, 0xd5, 0xfe, 0x29, 0xb7, 0x0a, 0xd1, 0x02, 0xee, 0x75, 0xc1, 0x5d, + 0x23, 0x95, 0xac, 0xdc, 0xd2, 0x34, 0xc6, 0x74, 0x7b, 0x75, 0xeb, 0xf1, 0x41, 0x19, 0x3d, 0x39, + 0x28, 0xa3, 0xdf, 0x0e, 0xca, 0xe8, 0xeb, 0xc3, 0xf2, 0xd4, 0x93, 0xc3, 0xf2, 0xd4, 0x2f, 0x87, + 0xe5, 0xa9, 0x8f, 0x57, 0x0d, 0xd3, 0xdd, 0xed, 0x6f, 0xab, 0x6d, 0xbe, 0x17, 0x08, 0xbd, 0x1b, + 0x7b, 0xcc, 0xfd, 0xc1, 0x41, 0xee, 0x7e, 0x97, 0x39, 0xdb, 0xc7, 0xc5, 0x0f, 0x92, 0x4b, 0xff, + 0x05, 0x00, 0x00, 0xff, 0xff, 0x38, 0x4b, 0x01, 0x4c, 0xf7, 0x15, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + // Queries a guardianSet by index. + GuardianSet(ctx context.Context, in *QueryGetGuardianSetRequest, opts ...grpc.CallOption) (*QueryGetGuardianSetResponse, error) + // Queries a list of guardianSet items. + GuardianSetAll(ctx context.Context, in *QueryAllGuardianSetRequest, opts ...grpc.CallOption) (*QueryAllGuardianSetResponse, error) + // Queries a config by index. + Config(ctx context.Context, in *QueryGetConfigRequest, opts ...grpc.CallOption) (*QueryGetConfigResponse, error) + // Queries a replayProtection by index. + ReplayProtection(ctx context.Context, in *QueryGetReplayProtectionRequest, opts ...grpc.CallOption) (*QueryGetReplayProtectionResponse, error) + // Queries a list of replayProtection items. + ReplayProtectionAll(ctx context.Context, in *QueryAllReplayProtectionRequest, opts ...grpc.CallOption) (*QueryAllReplayProtectionResponse, error) + // Queries a sequenceCounter by index. + SequenceCounter(ctx context.Context, in *QueryGetSequenceCounterRequest, opts ...grpc.CallOption) (*QueryGetSequenceCounterResponse, error) + // Queries a list of sequenceCounter items. + SequenceCounterAll(ctx context.Context, in *QueryAllSequenceCounterRequest, opts ...grpc.CallOption) (*QueryAllSequenceCounterResponse, error) + // Queries a ConsensusGuardianSetIndex by index. + ConsensusGuardianSetIndex(ctx context.Context, in *QueryGetConsensusGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryGetConsensusGuardianSetIndexResponse, error) + // Queries a GuardianValidator by index. + GuardianValidator(ctx context.Context, in *QueryGetGuardianValidatorRequest, opts ...grpc.CallOption) (*QueryGetGuardianValidatorResponse, error) + // Queries a list of GuardianValidator items. + GuardianValidatorAll(ctx context.Context, in *QueryAllGuardianValidatorRequest, opts ...grpc.CallOption) (*QueryAllGuardianValidatorResponse, error) + // Queries a list of LatestGuardianSetIndex items. + LatestGuardianSetIndex(ctx context.Context, in *QueryLatestGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryLatestGuardianSetIndexResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) GuardianSet(ctx context.Context, in *QueryGetGuardianSetRequest, opts ...grpc.CallOption) (*QueryGetGuardianSetResponse, error) { + out := new(QueryGetGuardianSetResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/GuardianSet", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) GuardianSetAll(ctx context.Context, in *QueryAllGuardianSetRequest, opts ...grpc.CallOption) (*QueryAllGuardianSetResponse, error) { + out := new(QueryAllGuardianSetResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/GuardianSetAll", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Config(ctx context.Context, in *QueryGetConfigRequest, opts ...grpc.CallOption) (*QueryGetConfigResponse, error) { + out := new(QueryGetConfigResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/Config", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ReplayProtection(ctx context.Context, in *QueryGetReplayProtectionRequest, opts ...grpc.CallOption) (*QueryGetReplayProtectionResponse, error) { + out := new(QueryGetReplayProtectionResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/ReplayProtection", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ReplayProtectionAll(ctx context.Context, in *QueryAllReplayProtectionRequest, opts ...grpc.CallOption) (*QueryAllReplayProtectionResponse, error) { + out := new(QueryAllReplayProtectionResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/ReplayProtectionAll", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) SequenceCounter(ctx context.Context, in *QueryGetSequenceCounterRequest, opts ...grpc.CallOption) (*QueryGetSequenceCounterResponse, error) { + out := new(QueryGetSequenceCounterResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/SequenceCounter", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) SequenceCounterAll(ctx context.Context, in *QueryAllSequenceCounterRequest, opts ...grpc.CallOption) (*QueryAllSequenceCounterResponse, error) { + out := new(QueryAllSequenceCounterResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/SequenceCounterAll", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ConsensusGuardianSetIndex(ctx context.Context, in *QueryGetConsensusGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryGetConsensusGuardianSetIndexResponse, error) { + out := new(QueryGetConsensusGuardianSetIndexResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/ConsensusGuardianSetIndex", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) GuardianValidator(ctx context.Context, in *QueryGetGuardianValidatorRequest, opts ...grpc.CallOption) (*QueryGetGuardianValidatorResponse, error) { + out := new(QueryGetGuardianValidatorResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/GuardianValidator", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) GuardianValidatorAll(ctx context.Context, in *QueryAllGuardianValidatorRequest, opts ...grpc.CallOption) (*QueryAllGuardianValidatorResponse, error) { + out := new(QueryAllGuardianValidatorResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/GuardianValidatorAll", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) LatestGuardianSetIndex(ctx context.Context, in *QueryLatestGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryLatestGuardianSetIndexResponse, error) { + out := new(QueryLatestGuardianSetIndexResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/LatestGuardianSetIndex", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // Queries a guardianSet by index. + GuardianSet(context.Context, *QueryGetGuardianSetRequest) (*QueryGetGuardianSetResponse, error) + // Queries a list of guardianSet items. + GuardianSetAll(context.Context, *QueryAllGuardianSetRequest) (*QueryAllGuardianSetResponse, error) + // Queries a config by index. + Config(context.Context, *QueryGetConfigRequest) (*QueryGetConfigResponse, error) + // Queries a replayProtection by index. + ReplayProtection(context.Context, *QueryGetReplayProtectionRequest) (*QueryGetReplayProtectionResponse, error) + // Queries a list of replayProtection items. + ReplayProtectionAll(context.Context, *QueryAllReplayProtectionRequest) (*QueryAllReplayProtectionResponse, error) + // Queries a sequenceCounter by index. + SequenceCounter(context.Context, *QueryGetSequenceCounterRequest) (*QueryGetSequenceCounterResponse, error) + // Queries a list of sequenceCounter items. + SequenceCounterAll(context.Context, *QueryAllSequenceCounterRequest) (*QueryAllSequenceCounterResponse, error) + // Queries a ConsensusGuardianSetIndex by index. + ConsensusGuardianSetIndex(context.Context, *QueryGetConsensusGuardianSetIndexRequest) (*QueryGetConsensusGuardianSetIndexResponse, error) + // Queries a GuardianValidator by index. + GuardianValidator(context.Context, *QueryGetGuardianValidatorRequest) (*QueryGetGuardianValidatorResponse, error) + // Queries a list of GuardianValidator items. + GuardianValidatorAll(context.Context, *QueryAllGuardianValidatorRequest) (*QueryAllGuardianValidatorResponse, error) + // Queries a list of LatestGuardianSetIndex items. + LatestGuardianSetIndex(context.Context, *QueryLatestGuardianSetIndexRequest) (*QueryLatestGuardianSetIndexResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) GuardianSet(ctx context.Context, req *QueryGetGuardianSetRequest) (*QueryGetGuardianSetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GuardianSet not implemented") +} +func (*UnimplementedQueryServer) GuardianSetAll(ctx context.Context, req *QueryAllGuardianSetRequest) (*QueryAllGuardianSetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GuardianSetAll not implemented") +} +func (*UnimplementedQueryServer) Config(ctx context.Context, req *QueryGetConfigRequest) (*QueryGetConfigResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Config not implemented") +} +func (*UnimplementedQueryServer) ReplayProtection(ctx context.Context, req *QueryGetReplayProtectionRequest) (*QueryGetReplayProtectionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReplayProtection not implemented") +} +func (*UnimplementedQueryServer) ReplayProtectionAll(ctx context.Context, req *QueryAllReplayProtectionRequest) (*QueryAllReplayProtectionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReplayProtectionAll not implemented") +} +func (*UnimplementedQueryServer) SequenceCounter(ctx context.Context, req *QueryGetSequenceCounterRequest) (*QueryGetSequenceCounterResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SequenceCounter not implemented") +} +func (*UnimplementedQueryServer) SequenceCounterAll(ctx context.Context, req *QueryAllSequenceCounterRequest) (*QueryAllSequenceCounterResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SequenceCounterAll not implemented") +} +func (*UnimplementedQueryServer) ConsensusGuardianSetIndex(ctx context.Context, req *QueryGetConsensusGuardianSetIndexRequest) (*QueryGetConsensusGuardianSetIndexResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConsensusGuardianSetIndex not implemented") +} +func (*UnimplementedQueryServer) GuardianValidator(ctx context.Context, req *QueryGetGuardianValidatorRequest) (*QueryGetGuardianValidatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GuardianValidator not implemented") +} +func (*UnimplementedQueryServer) GuardianValidatorAll(ctx context.Context, req *QueryAllGuardianValidatorRequest) (*QueryAllGuardianValidatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GuardianValidatorAll not implemented") +} +func (*UnimplementedQueryServer) LatestGuardianSetIndex(ctx context.Context, req *QueryLatestGuardianSetIndexRequest) (*QueryLatestGuardianSetIndexResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LatestGuardianSetIndex not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_GuardianSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetGuardianSetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).GuardianSet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/GuardianSet", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).GuardianSet(ctx, req.(*QueryGetGuardianSetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_GuardianSetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllGuardianSetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).GuardianSetAll(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/GuardianSetAll", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).GuardianSetAll(ctx, req.(*QueryAllGuardianSetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Config_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetConfigRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Config(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/Config", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Config(ctx, req.(*QueryGetConfigRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ReplayProtection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetReplayProtectionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ReplayProtection(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/ReplayProtection", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ReplayProtection(ctx, req.(*QueryGetReplayProtectionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ReplayProtectionAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllReplayProtectionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ReplayProtectionAll(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/ReplayProtectionAll", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ReplayProtectionAll(ctx, req.(*QueryAllReplayProtectionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_SequenceCounter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetSequenceCounterRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).SequenceCounter(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/SequenceCounter", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).SequenceCounter(ctx, req.(*QueryGetSequenceCounterRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_SequenceCounterAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllSequenceCounterRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).SequenceCounterAll(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/SequenceCounterAll", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).SequenceCounterAll(ctx, req.(*QueryAllSequenceCounterRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ConsensusGuardianSetIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetConsensusGuardianSetIndexRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ConsensusGuardianSetIndex(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/ConsensusGuardianSetIndex", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ConsensusGuardianSetIndex(ctx, req.(*QueryGetConsensusGuardianSetIndexRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_GuardianValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetGuardianValidatorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).GuardianValidator(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/GuardianValidator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).GuardianValidator(ctx, req.(*QueryGetGuardianValidatorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_GuardianValidatorAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllGuardianValidatorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).GuardianValidatorAll(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/GuardianValidatorAll", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).GuardianValidatorAll(ctx, req.(*QueryAllGuardianValidatorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_LatestGuardianSetIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryLatestGuardianSetIndexRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).LatestGuardianSetIndex(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/LatestGuardianSetIndex", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).LatestGuardianSetIndex(ctx, req.(*QueryLatestGuardianSetIndexRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "wormhole_foundation.wormchain.wormhole.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GuardianSet", + Handler: _Query_GuardianSet_Handler, + }, + { + MethodName: "GuardianSetAll", + Handler: _Query_GuardianSetAll_Handler, + }, + { + MethodName: "Config", + Handler: _Query_Config_Handler, + }, + { + MethodName: "ReplayProtection", + Handler: _Query_ReplayProtection_Handler, + }, + { + MethodName: "ReplayProtectionAll", + Handler: _Query_ReplayProtectionAll_Handler, + }, + { + MethodName: "SequenceCounter", + Handler: _Query_SequenceCounter_Handler, + }, + { + MethodName: "SequenceCounterAll", + Handler: _Query_SequenceCounterAll_Handler, + }, + { + MethodName: "ConsensusGuardianSetIndex", + Handler: _Query_ConsensusGuardianSetIndex_Handler, + }, + { + MethodName: "GuardianValidator", + Handler: _Query_GuardianValidator_Handler, + }, + { + MethodName: "GuardianValidatorAll", + Handler: _Query_GuardianValidatorAll_Handler, + }, + { + MethodName: "LatestGuardianSetIndex", + Handler: _Query_LatestGuardianSetIndex_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "wormhole/query.proto", +} + +func (m *QueryGetGuardianSetRequest) 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 *QueryGetGuardianSetRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetGuardianSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Index != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *QueryGetGuardianSetResponse) 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 *QueryGetGuardianSetResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetGuardianSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.GuardianSet.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryAllGuardianSetRequest) 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 *QueryAllGuardianSetRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllGuardianSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAllGuardianSetResponse) 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 *QueryAllGuardianSetResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllGuardianSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.GuardianSet) > 0 { + for iNdEx := len(m.GuardianSet) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.GuardianSet[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryGetConfigRequest) 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 *QueryGetConfigRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryGetConfigResponse) 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 *QueryGetConfigResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Config.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryGetReplayProtectionRequest) 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 *QueryGetReplayProtectionRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetReplayProtectionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Index) > 0 { + i -= len(m.Index) + copy(dAtA[i:], m.Index) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Index))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryGetReplayProtectionResponse) 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 *QueryGetReplayProtectionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetReplayProtectionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.ReplayProtection.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryAllReplayProtectionRequest) 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 *QueryAllReplayProtectionRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllReplayProtectionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAllReplayProtectionResponse) 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 *QueryAllReplayProtectionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllReplayProtectionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ReplayProtection) > 0 { + for iNdEx := len(m.ReplayProtection) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ReplayProtection[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryGetSequenceCounterRequest) 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 *QueryGetSequenceCounterRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetSequenceCounterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Index) > 0 { + i -= len(m.Index) + copy(dAtA[i:], m.Index) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Index))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryGetSequenceCounterResponse) 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 *QueryGetSequenceCounterResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetSequenceCounterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.SequenceCounter.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryAllSequenceCounterRequest) 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 *QueryAllSequenceCounterRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllSequenceCounterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAllSequenceCounterResponse) 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 *QueryAllSequenceCounterResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllSequenceCounterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.SequenceCounter) > 0 { + for iNdEx := len(m.SequenceCounter) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SequenceCounter[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryGetConsensusGuardianSetIndexRequest) 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 *QueryGetConsensusGuardianSetIndexRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetConsensusGuardianSetIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryGetConsensusGuardianSetIndexResponse) 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 *QueryGetConsensusGuardianSetIndexResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetConsensusGuardianSetIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.ConsensusGuardianSetIndex.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryGetGuardianValidatorRequest) 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 *QueryGetGuardianValidatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetGuardianValidatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.GuardianKey) > 0 { + i -= len(m.GuardianKey) + copy(dAtA[i:], m.GuardianKey) + i = encodeVarintQuery(dAtA, i, uint64(len(m.GuardianKey))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryGetGuardianValidatorResponse) 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 *QueryGetGuardianValidatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetGuardianValidatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.GuardianValidator.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryAllGuardianValidatorRequest) 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 *QueryAllGuardianValidatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllGuardianValidatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAllGuardianValidatorResponse) 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 *QueryAllGuardianValidatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllGuardianValidatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.GuardianValidator) > 0 { + for iNdEx := len(m.GuardianValidator) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.GuardianValidator[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryLatestGuardianSetIndexRequest) 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 *QueryLatestGuardianSetIndexRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLatestGuardianSetIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryLatestGuardianSetIndexResponse) 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 *QueryLatestGuardianSetIndexResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLatestGuardianSetIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.LatestGuardianSetIndex != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.LatestGuardianSetIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryGetGuardianSetRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != 0 { + n += 1 + sovQuery(uint64(m.Index)) + } + return n +} + +func (m *QueryGetGuardianSetResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.GuardianSet.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryAllGuardianSetRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllGuardianSetResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.GuardianSet) > 0 { + for _, e := range m.GuardianSet { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryGetConfigRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryGetConfigResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Config.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryGetReplayProtectionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Index) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryGetReplayProtectionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ReplayProtection.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryAllReplayProtectionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllReplayProtectionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ReplayProtection) > 0 { + for _, e := range m.ReplayProtection { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryGetSequenceCounterRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Index) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryGetSequenceCounterResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.SequenceCounter.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryAllSequenceCounterRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllSequenceCounterResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.SequenceCounter) > 0 { + for _, e := range m.SequenceCounter { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryGetConsensusGuardianSetIndexRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryGetConsensusGuardianSetIndexResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ConsensusGuardianSetIndex.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryGetGuardianValidatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.GuardianKey) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryGetGuardianValidatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.GuardianValidator.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryAllGuardianValidatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllGuardianValidatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.GuardianValidator) > 0 { + for _, e := range m.GuardianValidator { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryLatestGuardianSetIndexRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryLatestGuardianSetIndexResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LatestGuardianSetIndex != 0 { + n += 1 + sovQuery(uint64(m.LatestGuardianSetIndex)) + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryGetGuardianSetRequest) 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 ErrIntOverflowQuery + } + 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: QueryGetGuardianSetRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetGuardianSetRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetGuardianSetResponse) 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 ErrIntOverflowQuery + } + 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: QueryGetGuardianSetResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetGuardianSetResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianSet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.GuardianSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllGuardianSetRequest) 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 ErrIntOverflowQuery + } + 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: QueryAllGuardianSetRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllGuardianSetRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllGuardianSetResponse) 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 ErrIntOverflowQuery + } + 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: QueryAllGuardianSetResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllGuardianSetResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianSet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GuardianSet = append(m.GuardianSet, GuardianSet{}) + if err := m.GuardianSet[len(m.GuardianSet)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetConfigRequest) 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 ErrIntOverflowQuery + } + 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: QueryGetConfigRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetConfigResponse) 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 ErrIntOverflowQuery + } + 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: QueryGetConfigResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetReplayProtectionRequest) 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 ErrIntOverflowQuery + } + 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: QueryGetReplayProtectionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetReplayProtectionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Index = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetReplayProtectionResponse) 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 ErrIntOverflowQuery + } + 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: QueryGetReplayProtectionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetReplayProtectionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtection", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ReplayProtection.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllReplayProtectionRequest) 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 ErrIntOverflowQuery + } + 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: QueryAllReplayProtectionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllReplayProtectionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllReplayProtectionResponse) 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 ErrIntOverflowQuery + } + 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: QueryAllReplayProtectionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllReplayProtectionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtection", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReplayProtection = append(m.ReplayProtection, ReplayProtection{}) + if err := m.ReplayProtection[len(m.ReplayProtection)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetSequenceCounterRequest) 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 ErrIntOverflowQuery + } + 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: QueryGetSequenceCounterRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetSequenceCounterRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Index = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetSequenceCounterResponse) 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 ErrIntOverflowQuery + } + 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: QueryGetSequenceCounterResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetSequenceCounterResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SequenceCounter", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.SequenceCounter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllSequenceCounterRequest) 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 ErrIntOverflowQuery + } + 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: QueryAllSequenceCounterRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllSequenceCounterRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllSequenceCounterResponse) 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 ErrIntOverflowQuery + } + 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: QueryAllSequenceCounterResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllSequenceCounterResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SequenceCounter", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SequenceCounter = append(m.SequenceCounter, SequenceCounter{}) + if err := m.SequenceCounter[len(m.SequenceCounter)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetConsensusGuardianSetIndexRequest) 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 ErrIntOverflowQuery + } + 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: QueryGetConsensusGuardianSetIndexRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetConsensusGuardianSetIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetConsensusGuardianSetIndexResponse) 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 ErrIntOverflowQuery + } + 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: QueryGetConsensusGuardianSetIndexResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetConsensusGuardianSetIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusGuardianSetIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ConsensusGuardianSetIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetGuardianValidatorRequest) 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 ErrIntOverflowQuery + } + 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: QueryGetGuardianValidatorRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetGuardianValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GuardianKey = append(m.GuardianKey[:0], dAtA[iNdEx:postIndex]...) + if m.GuardianKey == nil { + m.GuardianKey = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetGuardianValidatorResponse) 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 ErrIntOverflowQuery + } + 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: QueryGetGuardianValidatorResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetGuardianValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianValidator", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.GuardianValidator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllGuardianValidatorRequest) 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 ErrIntOverflowQuery + } + 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: QueryAllGuardianValidatorRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllGuardianValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllGuardianValidatorResponse) 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 ErrIntOverflowQuery + } + 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: QueryAllGuardianValidatorResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllGuardianValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianValidator", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GuardianValidator = append(m.GuardianValidator, GuardianValidator{}) + if err := m.GuardianValidator[len(m.GuardianValidator)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryLatestGuardianSetIndexRequest) 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 ErrIntOverflowQuery + } + 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: QueryLatestGuardianSetIndexRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLatestGuardianSetIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryLatestGuardianSetIndexResponse) 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 ErrIntOverflowQuery + } + 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: QueryLatestGuardianSetIndexResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLatestGuardianSetIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestGuardianSetIndex", wireType) + } + m.LatestGuardianSetIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LatestGuardianSetIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/replay_protection.pb.go b/wormchain/x/wormhole/types/replay_protection.pb.go new file mode 100644 index 000000000..04cbe8185 --- /dev/null +++ b/wormchain/x/wormhole/types/replay_protection.pb.go @@ -0,0 +1,315 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/replay_protection.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type ReplayProtection struct { + Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"` +} + +func (m *ReplayProtection) Reset() { *m = ReplayProtection{} } +func (m *ReplayProtection) String() string { return proto.CompactTextString(m) } +func (*ReplayProtection) ProtoMessage() {} +func (*ReplayProtection) Descriptor() ([]byte, []int) { + return fileDescriptor_da495f697a0fb01c, []int{0} +} +func (m *ReplayProtection) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReplayProtection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReplayProtection.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 *ReplayProtection) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReplayProtection.Merge(m, src) +} +func (m *ReplayProtection) XXX_Size() int { + return m.Size() +} +func (m *ReplayProtection) XXX_DiscardUnknown() { + xxx_messageInfo_ReplayProtection.DiscardUnknown(m) +} + +var xxx_messageInfo_ReplayProtection proto.InternalMessageInfo + +func (m *ReplayProtection) GetIndex() string { + if m != nil { + return m.Index + } + return "" +} + +func init() { + proto.RegisterType((*ReplayProtection)(nil), "wormhole_foundation.wormchain.wormhole.ReplayProtection") +} + +func init() { proto.RegisterFile("wormhole/replay_protection.proto", fileDescriptor_da495f697a0fb01c) } + +var fileDescriptor_da495f697a0fb01c = []byte{ + // 170 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x28, 0xcf, 0x2f, 0xca, + 0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x2f, 0x4a, 0x2d, 0xc8, 0x49, 0xac, 0x8c, 0x2f, 0x28, 0xca, 0x2f, + 0x49, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x31, 0xf3, 0x85, 0xd4, 0x60, 0x2a, 0xe2, 0xd3, + 0xf2, 0x4b, 0xf3, 0x52, 0x12, 0xc1, 0x52, 0x20, 0xb1, 0xe4, 0x8c, 0xc4, 0x4c, 0x08, 0x0b, 0x24, + 0xab, 0xa4, 0xc1, 0x25, 0x10, 0x04, 0x36, 0x22, 0x00, 0x6e, 0x82, 0x90, 0x08, 0x17, 0x6b, 0x66, + 0x5e, 0x4a, 0x6a, 0x85, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x84, 0xe3, 0x14, 0x7c, 0xe2, + 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, + 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0x96, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, + 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x30, 0x83, 0x75, 0x11, 0xd6, 0xea, 0xc3, 0xad, 0xd5, 0xaf, 0x80, + 0xcb, 0xeb, 0x97, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x5d, 0x6b, 0x0c, 0x08, 0x00, 0x00, + 0xff, 0xff, 0xca, 0x3f, 0x36, 0x04, 0xd1, 0x00, 0x00, 0x00, +} + +func (m *ReplayProtection) 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 *ReplayProtection) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReplayProtection) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Index) > 0 { + i -= len(m.Index) + copy(dAtA[i:], m.Index) + i = encodeVarintReplayProtection(dAtA, i, uint64(len(m.Index))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintReplayProtection(dAtA []byte, offset int, v uint64) int { + offset -= sovReplayProtection(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ReplayProtection) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Index) + if l > 0 { + n += 1 + l + sovReplayProtection(uint64(l)) + } + return n +} + +func sovReplayProtection(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozReplayProtection(x uint64) (n int) { + return sovReplayProtection(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ReplayProtection) 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 ErrIntOverflowReplayProtection + } + 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: ReplayProtection: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReplayProtection: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplayProtection + } + 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 ErrInvalidLengthReplayProtection + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthReplayProtection + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Index = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipReplayProtection(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthReplayProtection + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipReplayProtection(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowReplayProtection + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowReplayProtection + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowReplayProtection + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthReplayProtection + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupReplayProtection + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthReplayProtection + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthReplayProtection = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowReplayProtection = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupReplayProtection = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/sequence_counter.pb.go b/wormchain/x/wormhole/types/sequence_counter.pb.go new file mode 100644 index 000000000..7b9b34ff9 --- /dev/null +++ b/wormchain/x/wormhole/types/sequence_counter.pb.go @@ -0,0 +1,351 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/sequence_counter.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type SequenceCounter struct { + Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"` + Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"` +} + +func (m *SequenceCounter) Reset() { *m = SequenceCounter{} } +func (m *SequenceCounter) String() string { return proto.CompactTextString(m) } +func (*SequenceCounter) ProtoMessage() {} +func (*SequenceCounter) Descriptor() ([]byte, []int) { + return fileDescriptor_adec725923edb1a5, []int{0} +} +func (m *SequenceCounter) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SequenceCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SequenceCounter.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 *SequenceCounter) XXX_Merge(src proto.Message) { + xxx_messageInfo_SequenceCounter.Merge(m, src) +} +func (m *SequenceCounter) XXX_Size() int { + return m.Size() +} +func (m *SequenceCounter) XXX_DiscardUnknown() { + xxx_messageInfo_SequenceCounter.DiscardUnknown(m) +} + +var xxx_messageInfo_SequenceCounter proto.InternalMessageInfo + +func (m *SequenceCounter) GetIndex() string { + if m != nil { + return m.Index + } + return "" +} + +func (m *SequenceCounter) GetSequence() uint64 { + if m != nil { + return m.Sequence + } + return 0 +} + +func init() { + proto.RegisterType((*SequenceCounter)(nil), "wormhole_foundation.wormchain.wormhole.SequenceCounter") +} + +func init() { proto.RegisterFile("wormhole/sequence_counter.proto", fileDescriptor_adec725923edb1a5) } + +var fileDescriptor_adec725923edb1a5 = []byte{ + // 190 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2f, 0xcf, 0x2f, 0xca, + 0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x2f, 0x4e, 0x2d, 0x2c, 0x4d, 0xcd, 0x4b, 0x4e, 0x8d, 0x4f, 0xce, + 0x2f, 0xcd, 0x2b, 0x49, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x83, 0x29, 0x88, + 0x4f, 0xcb, 0x2f, 0xcd, 0x4b, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x89, 0x25, 0x67, 0x24, + 0x66, 0x42, 0x58, 0x20, 0x59, 0x25, 0x67, 0x2e, 0xfe, 0x60, 0xa8, 0x09, 0xce, 0x10, 0x03, 0x84, + 0x44, 0xb8, 0x58, 0x33, 0xf3, 0x52, 0x52, 0x2b, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x20, + 0x1c, 0x21, 0x29, 0x2e, 0x0e, 0x98, 0x55, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0x2c, 0x41, 0x70, 0xbe, + 0x53, 0xf0, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, + 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x59, 0xa6, 0x67, 0x96, + 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xc3, 0xec, 0xd4, 0x45, 0xb8, 0x48, 0x1f, 0xee, + 0x22, 0xfd, 0x0a, 0xb8, 0xbc, 0x7e, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x23, 0xc6, + 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0f, 0x9e, 0xfe, 0x1f, 0xeb, 0x00, 0x00, 0x00, +} + +func (m *SequenceCounter) 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 *SequenceCounter) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SequenceCounter) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Sequence != 0 { + i = encodeVarintSequenceCounter(dAtA, i, uint64(m.Sequence)) + i-- + dAtA[i] = 0x10 + } + if len(m.Index) > 0 { + i -= len(m.Index) + copy(dAtA[i:], m.Index) + i = encodeVarintSequenceCounter(dAtA, i, uint64(len(m.Index))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintSequenceCounter(dAtA []byte, offset int, v uint64) int { + offset -= sovSequenceCounter(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *SequenceCounter) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Index) + if l > 0 { + n += 1 + l + sovSequenceCounter(uint64(l)) + } + if m.Sequence != 0 { + n += 1 + sovSequenceCounter(uint64(m.Sequence)) + } + return n +} + +func sovSequenceCounter(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozSequenceCounter(x uint64) (n int) { + return sovSequenceCounter(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *SequenceCounter) 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 ErrIntOverflowSequenceCounter + } + 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: SequenceCounter: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SequenceCounter: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSequenceCounter + } + 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 ErrInvalidLengthSequenceCounter + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSequenceCounter + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Index = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + m.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSequenceCounter + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSequenceCounter(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSequenceCounter + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSequenceCounter(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSequenceCounter + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSequenceCounter + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSequenceCounter + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthSequenceCounter + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupSequenceCounter + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthSequenceCounter + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthSequenceCounter = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSequenceCounter = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupSequenceCounter = fmt.Errorf("proto: unexpected end of group") +) diff --git a/wormchain/x/wormhole/types/tx.pb.go b/wormchain/x/wormhole/types/tx.pb.go new file mode 100644 index 000000000..2e16cf8e3 --- /dev/null +++ b/wormchain/x/wormhole/types/tx.pb.go @@ -0,0 +1,2142 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: wormhole/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type MsgExecuteGovernanceVAA struct { + Vaa []byte `protobuf:"bytes,1,opt,name=vaa,proto3" json:"vaa,omitempty"` + Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"` +} + +func (m *MsgExecuteGovernanceVAA) Reset() { *m = MsgExecuteGovernanceVAA{} } +func (m *MsgExecuteGovernanceVAA) String() string { return proto.CompactTextString(m) } +func (*MsgExecuteGovernanceVAA) ProtoMessage() {} +func (*MsgExecuteGovernanceVAA) Descriptor() ([]byte, []int) { + return fileDescriptor_55f7aa067b0c517b, []int{0} +} +func (m *MsgExecuteGovernanceVAA) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgExecuteGovernanceVAA) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgExecuteGovernanceVAA.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 *MsgExecuteGovernanceVAA) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgExecuteGovernanceVAA.Merge(m, src) +} +func (m *MsgExecuteGovernanceVAA) XXX_Size() int { + return m.Size() +} +func (m *MsgExecuteGovernanceVAA) XXX_DiscardUnknown() { + xxx_messageInfo_MsgExecuteGovernanceVAA.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgExecuteGovernanceVAA proto.InternalMessageInfo + +func (m *MsgExecuteGovernanceVAA) GetVaa() []byte { + if m != nil { + return m.Vaa + } + return nil +} + +func (m *MsgExecuteGovernanceVAA) GetSigner() string { + if m != nil { + return m.Signer + } + return "" +} + +type MsgExecuteGovernanceVAAResponse struct { +} + +func (m *MsgExecuteGovernanceVAAResponse) Reset() { *m = MsgExecuteGovernanceVAAResponse{} } +func (m *MsgExecuteGovernanceVAAResponse) String() string { return proto.CompactTextString(m) } +func (*MsgExecuteGovernanceVAAResponse) ProtoMessage() {} +func (*MsgExecuteGovernanceVAAResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_55f7aa067b0c517b, []int{1} +} +func (m *MsgExecuteGovernanceVAAResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgExecuteGovernanceVAAResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgExecuteGovernanceVAAResponse.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 *MsgExecuteGovernanceVAAResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgExecuteGovernanceVAAResponse.Merge(m, src) +} +func (m *MsgExecuteGovernanceVAAResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgExecuteGovernanceVAAResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgExecuteGovernanceVAAResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgExecuteGovernanceVAAResponse proto.InternalMessageInfo + +type MsgRegisterAccountAsGuardian struct { + Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"` + GuardianPubkey *GuardianKey `protobuf:"bytes,2,opt,name=guardianPubkey,proto3" json:"guardianPubkey,omitempty"` + Signature []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"` +} + +func (m *MsgRegisterAccountAsGuardian) Reset() { *m = MsgRegisterAccountAsGuardian{} } +func (m *MsgRegisterAccountAsGuardian) String() string { return proto.CompactTextString(m) } +func (*MsgRegisterAccountAsGuardian) ProtoMessage() {} +func (*MsgRegisterAccountAsGuardian) Descriptor() ([]byte, []int) { + return fileDescriptor_55f7aa067b0c517b, []int{2} +} +func (m *MsgRegisterAccountAsGuardian) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRegisterAccountAsGuardian) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRegisterAccountAsGuardian.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 *MsgRegisterAccountAsGuardian) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRegisterAccountAsGuardian.Merge(m, src) +} +func (m *MsgRegisterAccountAsGuardian) XXX_Size() int { + return m.Size() +} +func (m *MsgRegisterAccountAsGuardian) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRegisterAccountAsGuardian.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRegisterAccountAsGuardian proto.InternalMessageInfo + +func (m *MsgRegisterAccountAsGuardian) GetSigner() string { + if m != nil { + return m.Signer + } + return "" +} + +func (m *MsgRegisterAccountAsGuardian) GetGuardianPubkey() *GuardianKey { + if m != nil { + return m.GuardianPubkey + } + return nil +} + +func (m *MsgRegisterAccountAsGuardian) GetSignature() []byte { + if m != nil { + return m.Signature + } + return nil +} + +type MsgRegisterAccountAsGuardianResponse struct { +} + +func (m *MsgRegisterAccountAsGuardianResponse) Reset() { *m = MsgRegisterAccountAsGuardianResponse{} } +func (m *MsgRegisterAccountAsGuardianResponse) String() string { return proto.CompactTextString(m) } +func (*MsgRegisterAccountAsGuardianResponse) ProtoMessage() {} +func (*MsgRegisterAccountAsGuardianResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_55f7aa067b0c517b, []int{3} +} +func (m *MsgRegisterAccountAsGuardianResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRegisterAccountAsGuardianResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRegisterAccountAsGuardianResponse.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 *MsgRegisterAccountAsGuardianResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRegisterAccountAsGuardianResponse.Merge(m, src) +} +func (m *MsgRegisterAccountAsGuardianResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgRegisterAccountAsGuardianResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRegisterAccountAsGuardianResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRegisterAccountAsGuardianResponse proto.InternalMessageInfo + +// Same as from x/wasmd but with vaa auth +type MsgStoreCode struct { + // Signer is the that actor that signed the messages + Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"` + // WASMByteCode can be raw or gzip compressed + WASMByteCode []byte `protobuf:"bytes,2,opt,name=wasm_byte_code,json=wasmByteCode,proto3" json:"wasm_byte_code,omitempty"` + // vaa must be governance msg with payload containing sha3 256 hash of `wasm_byte_code` + Vaa []byte `protobuf:"bytes,3,opt,name=vaa,proto3" json:"vaa,omitempty"` +} + +func (m *MsgStoreCode) Reset() { *m = MsgStoreCode{} } +func (m *MsgStoreCode) String() string { return proto.CompactTextString(m) } +func (*MsgStoreCode) ProtoMessage() {} +func (*MsgStoreCode) Descriptor() ([]byte, []int) { + return fileDescriptor_55f7aa067b0c517b, []int{4} +} +func (m *MsgStoreCode) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgStoreCode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgStoreCode.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 *MsgStoreCode) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgStoreCode.Merge(m, src) +} +func (m *MsgStoreCode) XXX_Size() int { + return m.Size() +} +func (m *MsgStoreCode) XXX_DiscardUnknown() { + xxx_messageInfo_MsgStoreCode.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgStoreCode proto.InternalMessageInfo + +func (m *MsgStoreCode) GetSigner() string { + if m != nil { + return m.Signer + } + return "" +} + +func (m *MsgStoreCode) GetWASMByteCode() []byte { + if m != nil { + return m.WASMByteCode + } + return nil +} + +func (m *MsgStoreCode) GetVaa() []byte { + if m != nil { + return m.Vaa + } + return nil +} + +type MsgStoreCodeResponse struct { + // CodeID is the reference to the stored WASM code + CodeID uint64 `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"` +} + +func (m *MsgStoreCodeResponse) Reset() { *m = MsgStoreCodeResponse{} } +func (m *MsgStoreCodeResponse) String() string { return proto.CompactTextString(m) } +func (*MsgStoreCodeResponse) ProtoMessage() {} +func (*MsgStoreCodeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_55f7aa067b0c517b, []int{5} +} +func (m *MsgStoreCodeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgStoreCodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgStoreCodeResponse.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 *MsgStoreCodeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgStoreCodeResponse.Merge(m, src) +} +func (m *MsgStoreCodeResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgStoreCodeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgStoreCodeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgStoreCodeResponse proto.InternalMessageInfo + +func (m *MsgStoreCodeResponse) GetCodeID() uint64 { + if m != nil { + return m.CodeID + } + return 0 +} + +// Same as from x/wasmd but with vaa auth +type MsgInstantiateContract struct { + // Signer is the that actor that signed the messages + Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"` + // CodeID is the reference to the stored WASM code + CodeID uint64 `protobuf:"varint,3,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"` + // Label is optional metadata to be stored with a contract instance. + Label string `protobuf:"bytes,4,opt,name=label,proto3" json:"label,omitempty"` + // Msg json encoded message to be passed to the contract on instantiation + Msg []byte `protobuf:"bytes,5,opt,name=msg,proto3" json:"msg,omitempty"` + // vaa must be governance msg with payload containing sha3 256 hash of `bigEndian(code_id) || label || msg` + Vaa []byte `protobuf:"bytes,6,opt,name=vaa,proto3" json:"vaa,omitempty"` +} + +func (m *MsgInstantiateContract) Reset() { *m = MsgInstantiateContract{} } +func (m *MsgInstantiateContract) String() string { return proto.CompactTextString(m) } +func (*MsgInstantiateContract) ProtoMessage() {} +func (*MsgInstantiateContract) Descriptor() ([]byte, []int) { + return fileDescriptor_55f7aa067b0c517b, []int{6} +} +func (m *MsgInstantiateContract) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgInstantiateContract) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgInstantiateContract.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 *MsgInstantiateContract) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgInstantiateContract.Merge(m, src) +} +func (m *MsgInstantiateContract) XXX_Size() int { + return m.Size() +} +func (m *MsgInstantiateContract) XXX_DiscardUnknown() { + xxx_messageInfo_MsgInstantiateContract.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgInstantiateContract proto.InternalMessageInfo + +func (m *MsgInstantiateContract) GetSigner() string { + if m != nil { + return m.Signer + } + return "" +} + +func (m *MsgInstantiateContract) GetCodeID() uint64 { + if m != nil { + return m.CodeID + } + return 0 +} + +func (m *MsgInstantiateContract) GetLabel() string { + if m != nil { + return m.Label + } + return "" +} + +func (m *MsgInstantiateContract) GetMsg() []byte { + if m != nil { + return m.Msg + } + return nil +} + +func (m *MsgInstantiateContract) GetVaa() []byte { + if m != nil { + return m.Vaa + } + return nil +} + +type MsgInstantiateContractResponse struct { + // Address is the bech32 address of the new contract instance. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // Data contains base64-encoded bytes to returned from the contract + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *MsgInstantiateContractResponse) Reset() { *m = MsgInstantiateContractResponse{} } +func (m *MsgInstantiateContractResponse) String() string { return proto.CompactTextString(m) } +func (*MsgInstantiateContractResponse) ProtoMessage() {} +func (*MsgInstantiateContractResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_55f7aa067b0c517b, []int{7} +} +func (m *MsgInstantiateContractResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgInstantiateContractResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgInstantiateContractResponse.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 *MsgInstantiateContractResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgInstantiateContractResponse.Merge(m, src) +} +func (m *MsgInstantiateContractResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgInstantiateContractResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgInstantiateContractResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgInstantiateContractResponse proto.InternalMessageInfo + +func (m *MsgInstantiateContractResponse) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *MsgInstantiateContractResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func init() { + proto.RegisterType((*MsgExecuteGovernanceVAA)(nil), "wormhole_foundation.wormchain.wormhole.MsgExecuteGovernanceVAA") + proto.RegisterType((*MsgExecuteGovernanceVAAResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgExecuteGovernanceVAAResponse") + proto.RegisterType((*MsgRegisterAccountAsGuardian)(nil), "wormhole_foundation.wormchain.wormhole.MsgRegisterAccountAsGuardian") + proto.RegisterType((*MsgRegisterAccountAsGuardianResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgRegisterAccountAsGuardianResponse") + proto.RegisterType((*MsgStoreCode)(nil), "wormhole_foundation.wormchain.wormhole.MsgStoreCode") + proto.RegisterType((*MsgStoreCodeResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgStoreCodeResponse") + proto.RegisterType((*MsgInstantiateContract)(nil), "wormhole_foundation.wormchain.wormhole.MsgInstantiateContract") + proto.RegisterType((*MsgInstantiateContractResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgInstantiateContractResponse") +} + +func init() { proto.RegisterFile("wormhole/tx.proto", fileDescriptor_55f7aa067b0c517b) } + +var fileDescriptor_55f7aa067b0c517b = []byte{ + // 594 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0x51, 0x6b, 0xd3, 0x5e, + 0x18, 0xc6, 0x77, 0xfe, 0xed, 0x3a, 0xf6, 0xfe, 0xcb, 0x98, 0xb1, 0xcc, 0x18, 0x47, 0x3a, 0xa3, + 0x8c, 0xdd, 0xd8, 0xc0, 0x26, 0x82, 0x28, 0x4a, 0xbb, 0x69, 0x29, 0x1a, 0x91, 0x14, 0x14, 0xf4, + 0xa2, 0x9c, 0x26, 0xc7, 0xd3, 0xb0, 0x36, 0xa7, 0xe4, 0x9c, 0x6c, 0xcd, 0x95, 0x1f, 0x41, 0xbf, + 0x80, 0xe0, 0x37, 0x10, 0xbf, 0x85, 0x97, 0xbb, 0xf4, 0x6a, 0x48, 0xfb, 0x31, 0xbc, 0x91, 0x93, + 0x34, 0x69, 0x91, 0x46, 0x56, 0xe7, 0xdd, 0x79, 0xcf, 0xc9, 0xfb, 0x7b, 0x9e, 0x27, 0xe7, 0x6d, + 0x03, 0x57, 0x4e, 0x59, 0x30, 0xe8, 0xb1, 0x3e, 0x31, 0xc5, 0xa8, 0x36, 0x0c, 0x98, 0x60, 0xca, + 0x6e, 0xba, 0xd5, 0x79, 0xc7, 0x42, 0xdf, 0xc5, 0xc2, 0x63, 0x7e, 0x4d, 0xee, 0x39, 0x3d, 0xec, + 0x25, 0x2b, 0x79, 0xaa, 0x55, 0x28, 0xa3, 0x2c, 0x6e, 0x31, 0xe5, 0x2a, 0xe9, 0xd6, 0x6e, 0x64, + 0x40, 0x1a, 0xe2, 0xc0, 0xf5, 0xb0, 0xdf, 0x39, 0x26, 0x51, 0x72, 0x68, 0x1c, 0xc2, 0x35, 0x8b, + 0xd3, 0x27, 0x23, 0xe2, 0x84, 0x82, 0x34, 0xd9, 0x09, 0x09, 0x7c, 0xec, 0x3b, 0xe4, 0x55, 0xbd, + 0xae, 0x6c, 0x42, 0xe1, 0x04, 0x63, 0x15, 0xed, 0xa0, 0xbd, 0xb2, 0x2d, 0x97, 0xca, 0x16, 0x94, + 0xb8, 0x47, 0x7d, 0x12, 0xa8, 0xff, 0xed, 0xa0, 0xbd, 0x75, 0x7b, 0x5a, 0x19, 0x37, 0xa1, 0x9a, + 0x03, 0xb1, 0x09, 0x1f, 0x32, 0x9f, 0x13, 0xe3, 0x2b, 0x82, 0x6d, 0x8b, 0x53, 0x9b, 0x50, 0x8f, + 0x0b, 0x12, 0xd4, 0x1d, 0x87, 0x85, 0xbe, 0xa8, 0xf3, 0xe6, 0xd4, 0xd2, 0x1c, 0x1b, 0xcd, 0xb3, + 0x95, 0xb7, 0xb0, 0x91, 0xda, 0x7e, 0x19, 0x76, 0x8f, 0x49, 0x14, 0x6b, 0xff, 0xbf, 0x7f, 0x50, + 0xbb, 0xd8, 0x4b, 0xa9, 0xa5, 0x0a, 0xcf, 0x48, 0x64, 0xff, 0x86, 0x52, 0xb6, 0x61, 0x5d, 0xca, + 0x60, 0x11, 0x06, 0x44, 0x2d, 0xc4, 0x41, 0x67, 0x1b, 0xc6, 0x2e, 0xdc, 0xfe, 0x93, 0xe5, 0x2c, + 0xdb, 0x10, 0xca, 0x16, 0xa7, 0x6d, 0xc1, 0x02, 0x72, 0xc8, 0x5c, 0x92, 0x1b, 0xe5, 0x1e, 0x6c, + 0x9c, 0x62, 0x3e, 0xe8, 0x74, 0x23, 0x41, 0x3a, 0x0e, 0x73, 0x49, 0x1c, 0xa5, 0xdc, 0xd8, 0x1c, + 0x9f, 0x57, 0xcb, 0xaf, 0xeb, 0x6d, 0xab, 0x11, 0x89, 0x98, 0x60, 0x97, 0xe5, 0x73, 0x69, 0x95, + 0x5e, 0x44, 0x21, 0xbb, 0x08, 0xe3, 0x01, 0x54, 0xe6, 0x15, 0x53, 0x27, 0xca, 0x2d, 0x58, 0x93, + 0xdc, 0x8e, 0xe7, 0xc6, 0xd2, 0xc5, 0x06, 0x8c, 0xcf, 0xab, 0x25, 0xf9, 0x48, 0xeb, 0xc8, 0x2e, + 0xc9, 0xa3, 0x96, 0x6b, 0x7c, 0x40, 0xb0, 0x65, 0x71, 0xda, 0xf2, 0xb9, 0xc0, 0xbe, 0xf0, 0xb0, + 0x54, 0xf1, 0x45, 0x80, 0x1d, 0x91, 0xeb, 0x7c, 0x8e, 0x5b, 0xc8, 0xe3, 0x2a, 0x15, 0x58, 0xed, + 0xe3, 0x2e, 0xe9, 0xab, 0xc5, 0xb8, 0x37, 0x29, 0xa4, 0xf9, 0x01, 0xa7, 0xea, 0x6a, 0x62, 0x7e, + 0xc0, 0x69, 0x1a, 0xa7, 0x34, 0x8b, 0xf3, 0x02, 0xf4, 0xc5, 0x86, 0xb2, 0x60, 0x2a, 0xac, 0x61, + 0xd7, 0x0d, 0x08, 0xe7, 0x53, 0x67, 0x69, 0xa9, 0x28, 0x50, 0x74, 0xb1, 0xc0, 0xc9, 0xab, 0xb4, + 0xe3, 0xf5, 0xfe, 0xcf, 0x22, 0x14, 0x2c, 0x4e, 0x95, 0xcf, 0x08, 0x2a, 0x0b, 0x47, 0xfb, 0xf1, + 0x45, 0x87, 0x27, 0x67, 0xac, 0xb5, 0xe6, 0x25, 0x01, 0x59, 0xb0, 0x2f, 0x08, 0xae, 0xe7, 0xff, + 0x28, 0x8e, 0x96, 0x90, 0xc9, 0xa5, 0x68, 0xcf, 0xff, 0x05, 0x25, 0x73, 0xfc, 0x1e, 0xd6, 0x67, + 0xa3, 0x7e, 0x77, 0x09, 0x74, 0xd6, 0xa5, 0x3d, 0xfc, 0x9b, 0xae, 0xcc, 0xc0, 0x27, 0x04, 0x57, + 0x17, 0x0d, 0xef, 0xa3, 0x25, 0xa8, 0x0b, 0xfa, 0xb5, 0xa7, 0x97, 0xeb, 0x4f, 0xfd, 0x35, 0xda, + 0xdf, 0xc6, 0x3a, 0x3a, 0x1b, 0xeb, 0xe8, 0xc7, 0x58, 0x47, 0x1f, 0x27, 0xfa, 0xca, 0xd9, 0x44, + 0x5f, 0xf9, 0x3e, 0xd1, 0x57, 0xde, 0xdc, 0xa7, 0x9e, 0xe8, 0x85, 0xdd, 0x9a, 0xc3, 0x06, 0x66, + 0x4a, 0xbb, 0x33, 0xd3, 0x32, 0x33, 0x2d, 0x73, 0x64, 0xce, 0xbe, 0x02, 0xd1, 0x90, 0xf0, 0x6e, + 0x29, 0xfe, 0xbb, 0x3e, 0xf8, 0x15, 0x00, 0x00, 0xff, 0xff, 0x58, 0x04, 0x5c, 0x24, 0x1e, 0x06, + 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + ExecuteGovernanceVAA(ctx context.Context, in *MsgExecuteGovernanceVAA, opts ...grpc.CallOption) (*MsgExecuteGovernanceVAAResponse, error) + RegisterAccountAsGuardian(ctx context.Context, in *MsgRegisterAccountAsGuardian, opts ...grpc.CallOption) (*MsgRegisterAccountAsGuardianResponse, error) + // StoreCode to submit Wasm code to the system + StoreCode(ctx context.Context, in *MsgStoreCode, opts ...grpc.CallOption) (*MsgStoreCodeResponse, error) + // Instantiate creates a new smart contract instance for the given code id. + InstantiateContract(ctx context.Context, in *MsgInstantiateContract, opts ...grpc.CallOption) (*MsgInstantiateContractResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) ExecuteGovernanceVAA(ctx context.Context, in *MsgExecuteGovernanceVAA, opts ...grpc.CallOption) (*MsgExecuteGovernanceVAAResponse, error) { + out := new(MsgExecuteGovernanceVAAResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/ExecuteGovernanceVAA", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) RegisterAccountAsGuardian(ctx context.Context, in *MsgRegisterAccountAsGuardian, opts ...grpc.CallOption) (*MsgRegisterAccountAsGuardianResponse, error) { + out := new(MsgRegisterAccountAsGuardianResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/RegisterAccountAsGuardian", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) StoreCode(ctx context.Context, in *MsgStoreCode, opts ...grpc.CallOption) (*MsgStoreCodeResponse, error) { + out := new(MsgStoreCodeResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/StoreCode", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) InstantiateContract(ctx context.Context, in *MsgInstantiateContract, opts ...grpc.CallOption) (*MsgInstantiateContractResponse, error) { + out := new(MsgInstantiateContractResponse) + err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/InstantiateContract", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + ExecuteGovernanceVAA(context.Context, *MsgExecuteGovernanceVAA) (*MsgExecuteGovernanceVAAResponse, error) + RegisterAccountAsGuardian(context.Context, *MsgRegisterAccountAsGuardian) (*MsgRegisterAccountAsGuardianResponse, error) + // StoreCode to submit Wasm code to the system + StoreCode(context.Context, *MsgStoreCode) (*MsgStoreCodeResponse, error) + // Instantiate creates a new smart contract instance for the given code id. + InstantiateContract(context.Context, *MsgInstantiateContract) (*MsgInstantiateContractResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) ExecuteGovernanceVAA(ctx context.Context, req *MsgExecuteGovernanceVAA) (*MsgExecuteGovernanceVAAResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ExecuteGovernanceVAA not implemented") +} +func (*UnimplementedMsgServer) RegisterAccountAsGuardian(ctx context.Context, req *MsgRegisterAccountAsGuardian) (*MsgRegisterAccountAsGuardianResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RegisterAccountAsGuardian not implemented") +} +func (*UnimplementedMsgServer) StoreCode(ctx context.Context, req *MsgStoreCode) (*MsgStoreCodeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method StoreCode not implemented") +} +func (*UnimplementedMsgServer) InstantiateContract(ctx context.Context, req *MsgInstantiateContract) (*MsgInstantiateContractResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method InstantiateContract not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_ExecuteGovernanceVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgExecuteGovernanceVAA) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).ExecuteGovernanceVAA(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/ExecuteGovernanceVAA", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ExecuteGovernanceVAA(ctx, req.(*MsgExecuteGovernanceVAA)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_RegisterAccountAsGuardian_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRegisterAccountAsGuardian) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RegisterAccountAsGuardian(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/RegisterAccountAsGuardian", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RegisterAccountAsGuardian(ctx, req.(*MsgRegisterAccountAsGuardian)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_StoreCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgStoreCode) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).StoreCode(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/StoreCode", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).StoreCode(ctx, req.(*MsgStoreCode)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_InstantiateContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgInstantiateContract) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).InstantiateContract(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/InstantiateContract", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).InstantiateContract(ctx, req.(*MsgInstantiateContract)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "wormhole_foundation.wormchain.wormhole.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ExecuteGovernanceVAA", + Handler: _Msg_ExecuteGovernanceVAA_Handler, + }, + { + MethodName: "RegisterAccountAsGuardian", + Handler: _Msg_RegisterAccountAsGuardian_Handler, + }, + { + MethodName: "StoreCode", + Handler: _Msg_StoreCode_Handler, + }, + { + MethodName: "InstantiateContract", + Handler: _Msg_InstantiateContract_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "wormhole/tx.proto", +} + +func (m *MsgExecuteGovernanceVAA) 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 *MsgExecuteGovernanceVAA) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgExecuteGovernanceVAA) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Signer) > 0 { + i -= len(m.Signer) + copy(dAtA[i:], m.Signer) + i = encodeVarintTx(dAtA, i, uint64(len(m.Signer))) + i-- + dAtA[i] = 0x12 + } + if len(m.Vaa) > 0 { + i -= len(m.Vaa) + copy(dAtA[i:], m.Vaa) + i = encodeVarintTx(dAtA, i, uint64(len(m.Vaa))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgExecuteGovernanceVAAResponse) 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 *MsgExecuteGovernanceVAAResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgExecuteGovernanceVAAResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgRegisterAccountAsGuardian) 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 *MsgRegisterAccountAsGuardian) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRegisterAccountAsGuardian) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintTx(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x1a + } + if m.GuardianPubkey != nil { + { + size, err := m.GuardianPubkey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Signer) > 0 { + i -= len(m.Signer) + copy(dAtA[i:], m.Signer) + i = encodeVarintTx(dAtA, i, uint64(len(m.Signer))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRegisterAccountAsGuardianResponse) 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 *MsgRegisterAccountAsGuardianResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRegisterAccountAsGuardianResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgStoreCode) 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 *MsgStoreCode) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgStoreCode) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Vaa) > 0 { + i -= len(m.Vaa) + copy(dAtA[i:], m.Vaa) + i = encodeVarintTx(dAtA, i, uint64(len(m.Vaa))) + i-- + dAtA[i] = 0x1a + } + if len(m.WASMByteCode) > 0 { + i -= len(m.WASMByteCode) + copy(dAtA[i:], m.WASMByteCode) + i = encodeVarintTx(dAtA, i, uint64(len(m.WASMByteCode))) + i-- + dAtA[i] = 0x12 + } + if len(m.Signer) > 0 { + i -= len(m.Signer) + copy(dAtA[i:], m.Signer) + i = encodeVarintTx(dAtA, i, uint64(len(m.Signer))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgStoreCodeResponse) 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 *MsgStoreCodeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgStoreCodeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CodeID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CodeID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgInstantiateContract) 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 *MsgInstantiateContract) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgInstantiateContract) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Vaa) > 0 { + i -= len(m.Vaa) + copy(dAtA[i:], m.Vaa) + i = encodeVarintTx(dAtA, i, uint64(len(m.Vaa))) + i-- + dAtA[i] = 0x32 + } + if len(m.Msg) > 0 { + i -= len(m.Msg) + copy(dAtA[i:], m.Msg) + i = encodeVarintTx(dAtA, i, uint64(len(m.Msg))) + i-- + dAtA[i] = 0x2a + } + if len(m.Label) > 0 { + i -= len(m.Label) + copy(dAtA[i:], m.Label) + i = encodeVarintTx(dAtA, i, uint64(len(m.Label))) + i-- + dAtA[i] = 0x22 + } + if m.CodeID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CodeID)) + i-- + dAtA[i] = 0x18 + } + if len(m.Signer) > 0 { + i -= len(m.Signer) + copy(dAtA[i:], m.Signer) + i = encodeVarintTx(dAtA, i, uint64(len(m.Signer))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgInstantiateContractResponse) 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 *MsgInstantiateContractResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgInstantiateContractResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintTx(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgExecuteGovernanceVAA) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Vaa) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Signer) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgExecuteGovernanceVAAResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgRegisterAccountAsGuardian) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Signer) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.GuardianPubkey != nil { + l = m.GuardianPubkey.Size() + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgRegisterAccountAsGuardianResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgStoreCode) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Signer) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.WASMByteCode) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Vaa) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgStoreCodeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CodeID != 0 { + n += 1 + sovTx(uint64(m.CodeID)) + } + return n +} + +func (m *MsgInstantiateContract) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Signer) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.CodeID != 0 { + n += 1 + sovTx(uint64(m.CodeID)) + } + l = len(m.Label) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Msg) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Vaa) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgInstantiateContractResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgExecuteGovernanceVAA) 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: MsgExecuteGovernanceVAA: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgExecuteGovernanceVAA: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vaa", 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.Vaa = append(m.Vaa[:0], dAtA[iNdEx:postIndex]...) + if m.Vaa == nil { + m.Vaa = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgExecuteGovernanceVAAResponse) 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: MsgExecuteGovernanceVAAResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgExecuteGovernanceVAAResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRegisterAccountAsGuardian) 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: MsgRegisterAccountAsGuardian: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRegisterAccountAsGuardian: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GuardianPubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GuardianPubkey == nil { + m.GuardianPubkey = &GuardianKey{} + } + if err := m.GuardianPubkey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", 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.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []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 *MsgRegisterAccountAsGuardianResponse) 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: MsgRegisterAccountAsGuardianResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRegisterAccountAsGuardianResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgStoreCode) 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: MsgStoreCode: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgStoreCode: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WASMByteCode", 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.WASMByteCode = append(m.WASMByteCode[:0], dAtA[iNdEx:postIndex]...) + if m.WASMByteCode == nil { + m.WASMByteCode = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vaa", 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.Vaa = append(m.Vaa[:0], dAtA[iNdEx:postIndex]...) + if m.Vaa == nil { + m.Vaa = []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 *MsgStoreCodeResponse) 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: MsgStoreCodeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgStoreCodeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType) + } + m.CodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CodeID |= 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 *MsgInstantiateContract) 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: MsgInstantiateContract: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgInstantiateContract: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType) + } + m.CodeID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CodeID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Label", 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.Label = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Msg", 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.Msg = append(m.Msg[:0], dAtA[iNdEx:postIndex]...) + if m.Msg == nil { + m.Msg = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vaa", 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.Vaa = append(m.Vaa[:0], dAtA[iNdEx:postIndex]...) + if m.Vaa == nil { + m.Vaa = []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 *MsgInstantiateContractResponse) 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: MsgInstantiateContractResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgInstantiateContractResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", 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.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []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 skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +)