From 1e6e34e5618919424deb3686dbb208baf95027b7 Mon Sep 17 00:00:00 2001 From: Jayden Lee <41176085+tkxkd0159@users.noreply.github.com> Date: Wed, 24 Apr 2024 13:30:42 +0900 Subject: [PATCH] add missing proto files --- client/docs/config.json | 5 +- client/docs/swagger-ui/swagger.yaml | 135 + docs/core/proto-docs.md | 252 ++ proto/lbm/fbridge/v1/query.proto | 33 + proto/lbm/fbridge/v1/tx.proto | 66 + x/fbridge/types/query.pb.go | 1166 +++++++- x/fbridge/types/query.pb.gw.go | 186 ++ x/fbridge/types/tx.pb.go | 3850 ++++++++++++++++++++------- 8 files changed, 4678 insertions(+), 1015 deletions(-) diff --git a/client/docs/config.json b/client/docs/config.json index db38cbba69..05239a6e53 100644 --- a/client/docs/config.json +++ b/client/docs/config.json @@ -170,7 +170,10 @@ "operationIds": { "rename": { "Params": "FBridgeParams", - "Commitments": "FBridgeCommitments" + "Commitments": "FBridgeCommitments", + "Guardians": "FBridgeGuardians", + "Operators": "FBridgeOperators", + "Judges": "FBridgeJudges" } } } diff --git a/client/docs/swagger-ui/swagger.yaml b/client/docs/swagger-ui/swagger.yaml index 1e88c28f20..c329811dfb 100644 --- a/client/docs/swagger-ui/swagger.yaml +++ b/client/docs/swagger-ui/swagger.yaml @@ -29970,6 +29970,82 @@ paths: type: string tags: - Query + /lbm/fbridge/v1/guardians: + get: + summary: Get a list of Guardians registered on the bridge + operationId: FBridgeGuardians + responses: + '200': + description: A successful response. + schema: + type: object + properties: + guardians: + type: array + items: + type: string + default: + description: An unexpected error response + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + value: + type: string + format: byte + tags: + - Query + /lbm/fbridge/v1/judges: + get: + summary: Get a list of Judges registered on the bridge + operationId: FBridgeJudges + responses: + '200': + description: A successful response. + schema: + type: object + properties: + judges: + type: array + items: + type: string + default: + description: An unexpected error response + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + value: + type: string + format: byte + tags: + - Query /lbm/fbridge/v1/next_seq_to_confirm: get: summary: Get a next sequence number to be confirmed by n-of-m operators @@ -30007,6 +30083,44 @@ paths: format: byte tags: - Query + /lbm/fbridge/v1/operators: + get: + summary: Get a list of Operators registered on the bridge + operationId: FBridgeOperators + responses: + '200': + description: A successful response. + schema: + type: object + properties: + operators: + type: array + items: + type: string + default: + description: An unexpected error response + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + value: + type: string + format: byte + tags: + - Query /lbm/fbridge/v1/params: get: summary: Params queries the parameters of x/fbridge module. @@ -49788,12 +49902,33 @@ definitions: seq: type: string format: uint64 + lbm.fbridge.v1.GuardiansResponse: + type: object + properties: + guardians: + type: array + items: + type: string + lbm.fbridge.v1.JudgesResponse: + type: object + properties: + judges: + type: array + items: + type: string lbm.fbridge.v1.NextSeqToConfirmResponse: type: object properties: seq: type: string format: uint64 + lbm.fbridge.v1.OperatorsResponse: + type: object + properties: + operators: + type: array + items: + type: string lbm.fbridge.v1.Params: type: object properties: diff --git a/docs/core/proto-docs.md b/docs/core/proto-docs.md index 2dae6bf266..1eae22170a 100644 --- a/docs/core/proto-docs.md +++ b/docs/core/proto-docs.md @@ -783,8 +783,14 @@ - [ConfirmedProvisionResponse](#lbm.fbridge.v1.ConfirmedProvisionResponse) - [GreatestSeqByOperatorRequest](#lbm.fbridge.v1.GreatestSeqByOperatorRequest) - [GreatestSeqByOperatorResponse](#lbm.fbridge.v1.GreatestSeqByOperatorResponse) + - [GuardiansRequest](#lbm.fbridge.v1.GuardiansRequest) + - [GuardiansResponse](#lbm.fbridge.v1.GuardiansResponse) + - [JudgesRequest](#lbm.fbridge.v1.JudgesRequest) + - [JudgesResponse](#lbm.fbridge.v1.JudgesResponse) - [NextSeqToConfirmRequest](#lbm.fbridge.v1.NextSeqToConfirmRequest) - [NextSeqToConfirmResponse](#lbm.fbridge.v1.NextSeqToConfirmResponse) + - [OperatorsRequest](#lbm.fbridge.v1.OperatorsRequest) + - [OperatorsResponse](#lbm.fbridge.v1.OperatorsResponse) - [QueryParamsRequest](#lbm.fbridge.v1.QueryParamsRequest) - [QueryParamsResponse](#lbm.fbridge.v1.QueryParamsResponse) - [SubmittedProvisionRequest](#lbm.fbridge.v1.SubmittedProvisionRequest) @@ -793,6 +799,12 @@ - [Query](#lbm.fbridge.v1.Query) - [lbm/fbridge/v1/tx.proto](#lbm/fbridge/v1/tx.proto) + - [AddGuardianRequest](#lbm.fbridge.v1.AddGuardianRequest) + - [AddGuardianResponse](#lbm.fbridge.v1.AddGuardianResponse) + - [AddJudgeRequest](#lbm.fbridge.v1.AddJudgeRequest) + - [AddJudgeResponse](#lbm.fbridge.v1.AddJudgeResponse) + - [AddOperatorRequest](#lbm.fbridge.v1.AddOperatorRequest) + - [AddOperatorResponse](#lbm.fbridge.v1.AddOperatorResponse) - [ClaimBatchRequest](#lbm.fbridge.v1.ClaimBatchRequest) - [ClaimBatchResponse](#lbm.fbridge.v1.ClaimBatchResponse) - [ClaimRequest](#lbm.fbridge.v1.ClaimRequest) @@ -803,6 +815,12 @@ - [ProvisionResponse](#lbm.fbridge.v1.ProvisionResponse) - [ReleaseTransferRequest](#lbm.fbridge.v1.ReleaseTransferRequest) - [ReleaseTransferResponse](#lbm.fbridge.v1.ReleaseTransferResponse) + - [RemoveGuardianRequest](#lbm.fbridge.v1.RemoveGuardianRequest) + - [RemoveGuardianResponse](#lbm.fbridge.v1.RemoveGuardianResponse) + - [RemoveJudgeRequest](#lbm.fbridge.v1.RemoveJudgeRequest) + - [RemoveJudgeResponse](#lbm.fbridge.v1.RemoveJudgeResponse) + - [RemoveOperatorRequest](#lbm.fbridge.v1.RemoveOperatorRequest) + - [RemoveOperatorResponse](#lbm.fbridge.v1.RemoveOperatorResponse) - [RemoveProvisionRequest](#lbm.fbridge.v1.RemoveProvisionRequest) - [RemoveProvisionResponse](#lbm.fbridge.v1.RemoveProvisionResponse) - [TransferRequest](#lbm.fbridge.v1.TransferRequest) @@ -11778,6 +11796,56 @@ GenesisState defines the fbridge module's genesis state. + + +### GuardiansRequest + + + + + + + + + +### GuardiansResponse + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `guardians` | [string](#string) | repeated | | + + + + + + + + +### JudgesRequest + + + + + + + + + +### JudgesResponse + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `judges` | [string](#string) | repeated | | + + + + + + ### NextSeqToConfirmRequest @@ -11803,6 +11871,31 @@ GenesisState defines the fbridge module's genesis state. + + +### OperatorsRequest + + + + + + + + + +### OperatorsResponse + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `operators` | [string](#string) | repeated | | + + + + + + ### QueryParamsRequest @@ -11879,6 +11972,9 @@ GenesisState defines the fbridge module's genesis state. | `SubmittedProvision` | [SubmittedProvisionRequest](#lbm.fbridge.v1.SubmittedProvisionRequest) | [SubmittedProvisionResponse](#lbm.fbridge.v1.SubmittedProvisionResponse) | Get a provision submitted by a particular operator | GET|/lbm/fbridge/v1/submitted_provision/{operator}/{seq}| | `ConfirmedProvision` | [ConfirmedProvisionRequest](#lbm.fbridge.v1.ConfirmedProvisionRequest) | [ConfirmedProvisionResponse](#lbm.fbridge.v1.ConfirmedProvisionResponse) | Get a specific confirmed provision | GET|/lbm/fbridge/v1/confirmed_provision/{seq}| | `Commitments` | [CommitmentsRequest](#lbm.fbridge.v1.CommitmentsRequest) | [CommitmentsResponse](#lbm.fbridge.v1.CommitmentsResponse) | Get commitments of a specific sequence number | GET|/lbm/fbridge/v1/commitments/{seq}| +| `Guardians` | [GuardiansRequest](#lbm.fbridge.v1.GuardiansRequest) | [GuardiansResponse](#lbm.fbridge.v1.GuardiansResponse) | Get a list of Guardians registered on the bridge | GET|/lbm/fbridge/v1/guardians| +| `Operators` | [OperatorsRequest](#lbm.fbridge.v1.OperatorsRequest) | [OperatorsResponse](#lbm.fbridge.v1.OperatorsResponse) | Get a list of Operators registered on the bridge | GET|/lbm/fbridge/v1/operators| +| `Judges` | [JudgesRequest](#lbm.fbridge.v1.JudgesRequest) | [JudgesResponse](#lbm.fbridge.v1.JudgesResponse) | Get a list of Judges registered on the bridge | GET|/lbm/fbridge/v1/judges| @@ -11891,6 +11987,81 @@ GenesisState defines the fbridge module's genesis state. + + +### AddGuardianRequest +AddGuardianRequest is input values required for adding a guardian + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `guardian` | [string](#string) | | the guardian address to be added | + + + + + + + + +### AddGuardianResponse + + + + + + + + + +### AddJudgeRequest +AddJudgeRequest is input values required for adding a judge + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `judge` | [string](#string) | | the judge address to be added | + + + + + + + + +### AddJudgeResponse + + + + + + + + + +### AddOperatorRequest +AddOperatorRequest is input values required for adding an operator + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `operator` | [string](#string) | | the operator address to be added | + + + + + + + + +### AddOperatorResponse + + + + + + + ### ClaimBatchRequest @@ -12019,6 +12190,81 @@ ReleaseTransferRequest is input values required for releasing a held transfer by + + +### RemoveGuardianRequest +RemoveGuardianRequest is input values required for removing a guardian + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `guardian` | [string](#string) | | the guardian address to be removed | + + + + + + + + +### RemoveGuardianResponse + + + + + + + + + +### RemoveJudgeRequest +RemoveJudgeRequest is input values required for removing a judge + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `judge` | [string](#string) | | the judge address to be removed | + + + + + + + + +### RemoveJudgeResponse + + + + + + + + + +### RemoveOperatorRequest +RemoveOperatorRequest is input values required for removing an operator + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `operator` | [string](#string) | | the operator address to be removed | + + + + + + + + +### RemoveOperatorResponse + + + + + + + ### RemoveProvisionRequest @@ -12091,6 +12337,12 @@ TransferRequest is input values required for bridge transfer | `RemoveProvision` | [RemoveProvisionRequest](#lbm.fbridge.v1.RemoveProvisionRequest) | [RemoveProvisionResponse](#lbm.fbridge.v1.RemoveProvisionResponse) | Remove a specific confirmed provision (reset for specific sequence number). | | | `ClaimBatch` | [ClaimBatchRequest](#lbm.fbridge.v1.ClaimBatchRequest) | [ClaimBatchResponse](#lbm.fbridge.v1.ClaimBatchResponse) | ClaimBatch processes the claiming of multiple claimable provisions in a single operation | | | `Claim` | [ClaimRequest](#lbm.fbridge.v1.ClaimRequest) | [ClaimResponse](#lbm.fbridge.v1.ClaimResponse) | Claim processes the claiming of a provision with a specific sequence number | | +| `AddGuardian` | [AddGuardianRequest](#lbm.fbridge.v1.AddGuardianRequest) | [AddGuardianResponse](#lbm.fbridge.v1.AddGuardianResponse) | AddGuardian adds a guardian to the bridge module. | | +| `RemoveGuardian` | [RemoveGuardianRequest](#lbm.fbridge.v1.RemoveGuardianRequest) | [RemoveGuardianResponse](#lbm.fbridge.v1.RemoveGuardianResponse) | RemoveGuardian removes a guardian from the bridge module. | | +| `AddOperator` | [AddOperatorRequest](#lbm.fbridge.v1.AddOperatorRequest) | [AddOperatorResponse](#lbm.fbridge.v1.AddOperatorResponse) | AddOperator adds an operator to the bridge module. | | +| `RemoveOperator` | [RemoveOperatorRequest](#lbm.fbridge.v1.RemoveOperatorRequest) | [RemoveOperatorResponse](#lbm.fbridge.v1.RemoveOperatorResponse) | RemoveOperator removes an operator from the bridge module. | | +| `AddJudge` | [AddJudgeRequest](#lbm.fbridge.v1.AddJudgeRequest) | [AddJudgeResponse](#lbm.fbridge.v1.AddJudgeResponse) | AddJudge adds a judge to the bridge module. | | +| `RemoveJudge` | [RemoveJudgeRequest](#lbm.fbridge.v1.RemoveJudgeRequest) | [RemoveJudgeResponse](#lbm.fbridge.v1.RemoveJudgeResponse) | RemoveJudge removes a judge from the bridge module. | | diff --git a/proto/lbm/fbridge/v1/query.proto b/proto/lbm/fbridge/v1/query.proto index 4893364dd5..a44319fc1d 100644 --- a/proto/lbm/fbridge/v1/query.proto +++ b/proto/lbm/fbridge/v1/query.proto @@ -37,6 +37,21 @@ service Query { rpc Commitments(CommitmentsRequest) returns (CommitmentsResponse) { option (google.api.http).get = "/lbm/fbridge/v1/commitments/{seq}"; } + + // Get a list of Guardians registered on the bridge + rpc Guardians(GuardiansRequest) returns (GuardiansResponse) { + option (google.api.http).get = "/lbm/fbridge/v1/guardians"; + } + + // Get a list of Operators registered on the bridge + rpc Operators(OperatorsRequest) returns (OperatorsResponse) { + option (google.api.http).get = "/lbm/fbridge/v1/operators"; + } + + // Get a list of Judges registered on the bridge + rpc Judges(JudgesRequest) returns (JudgesResponse) { + option (google.api.http).get = "/lbm/fbridge/v1/judges"; + } } message QueryParamsRequest {} @@ -89,4 +104,22 @@ message CommitmentsRequest { message CommitmentsResponse { repeated string commitments = 1; +} + +message GuardiansRequest {} + +message GuardiansResponse { + repeated string guardians = 1; +} + +message OperatorsRequest {} + +message OperatorsResponse { + repeated string operators = 1; +} + +message JudgesRequest {} + +message JudgesResponse { + repeated string judges = 1; } \ No newline at end of file diff --git a/proto/lbm/fbridge/v1/tx.proto b/proto/lbm/fbridge/v1/tx.proto index 49f9f1a6a1..f295e6c028 100644 --- a/proto/lbm/fbridge/v1/tx.proto +++ b/proto/lbm/fbridge/v1/tx.proto @@ -26,6 +26,24 @@ service Msg { // Claim processes the claiming of a provision with a specific sequence number rpc Claim(ClaimRequest) returns (ClaimResponse); + + // AddGuardian adds a guardian to the bridge module. + rpc AddGuardian(AddGuardianRequest) returns (AddGuardianResponse); + + // RemoveGuardian removes a guardian from the bridge module. + rpc RemoveGuardian(RemoveGuardianRequest) returns (RemoveGuardianResponse); + + // AddOperator adds an operator to the bridge module. + rpc AddOperator(AddOperatorRequest) returns (AddOperatorResponse); + + // RemoveOperator removes an operator from the bridge module. + rpc RemoveOperator(RemoveOperatorRequest) returns (RemoveOperatorResponse); + + // AddJudge adds a judge to the bridge module. + rpc AddJudge(AddJudgeRequest) returns (AddJudgeResponse); + + // RemoveJudge removes a judge from the bridge module. + rpc RemoveJudge(RemoveJudgeRequest) returns (RemoveJudgeResponse); } // TransferRequest is input values required for bridge transfer @@ -95,3 +113,51 @@ message ClaimRequest { } message ClaimResponse {} + +// AddGuardianRequest is input values required for adding a guardian +message AddGuardianRequest { + // the guardian address to be added + string guardian = 1; +} + +message AddGuardianResponse {} + +// RemoveGuardianRequest is input values required for removing a guardian +message RemoveGuardianRequest { + // the guardian address to be removed + string guardian = 1; +} + +message RemoveGuardianResponse {} + +// AddOperatorRequest is input values required for adding an operator +message AddOperatorRequest { + // the operator address to be added + string operator = 1; +} + +message AddOperatorResponse {} + +// RemoveOperatorRequest is input values required for removing an operator +message RemoveOperatorRequest { + // the operator address to be removed + string operator = 1; +} + +message RemoveOperatorResponse {} + +// AddJudgeRequest is input values required for adding a judge +message AddJudgeRequest { + // the judge address to be added + string judge = 1; +} + +message AddJudgeResponse {} + +// RemoveJudgeRequest is input values required for removing a judge +message RemoveJudgeRequest { + // the judge address to be removed + string judge = 1; +} + +message RemoveJudgeResponse {} diff --git a/x/fbridge/types/query.pb.go b/x/fbridge/types/query.pb.go index 53fffd6deb..bb1f91bc2d 100644 --- a/x/fbridge/types/query.pb.go +++ b/x/fbridge/types/query.pb.go @@ -570,6 +570,246 @@ func (m *CommitmentsResponse) GetCommitments() []string { return nil } +type GuardiansRequest struct { +} + +func (m *GuardiansRequest) Reset() { *m = GuardiansRequest{} } +func (m *GuardiansRequest) String() string { return proto.CompactTextString(m) } +func (*GuardiansRequest) ProtoMessage() {} +func (*GuardiansRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_5e7780f9db9d346e, []int{12} +} +func (m *GuardiansRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GuardiansRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GuardiansRequest.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 *GuardiansRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GuardiansRequest.Merge(m, src) +} +func (m *GuardiansRequest) XXX_Size() int { + return m.Size() +} +func (m *GuardiansRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GuardiansRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GuardiansRequest proto.InternalMessageInfo + +type GuardiansResponse struct { + Guardians []string `protobuf:"bytes,1,rep,name=guardians,proto3" json:"guardians,omitempty"` +} + +func (m *GuardiansResponse) Reset() { *m = GuardiansResponse{} } +func (m *GuardiansResponse) String() string { return proto.CompactTextString(m) } +func (*GuardiansResponse) ProtoMessage() {} +func (*GuardiansResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5e7780f9db9d346e, []int{13} +} +func (m *GuardiansResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GuardiansResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GuardiansResponse.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 *GuardiansResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GuardiansResponse.Merge(m, src) +} +func (m *GuardiansResponse) XXX_Size() int { + return m.Size() +} +func (m *GuardiansResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GuardiansResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GuardiansResponse proto.InternalMessageInfo + +func (m *GuardiansResponse) GetGuardians() []string { + if m != nil { + return m.Guardians + } + return nil +} + +type OperatorsRequest struct { +} + +func (m *OperatorsRequest) Reset() { *m = OperatorsRequest{} } +func (m *OperatorsRequest) String() string { return proto.CompactTextString(m) } +func (*OperatorsRequest) ProtoMessage() {} +func (*OperatorsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_5e7780f9db9d346e, []int{14} +} +func (m *OperatorsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OperatorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OperatorsRequest.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 *OperatorsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_OperatorsRequest.Merge(m, src) +} +func (m *OperatorsRequest) XXX_Size() int { + return m.Size() +} +func (m *OperatorsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_OperatorsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_OperatorsRequest proto.InternalMessageInfo + +type OperatorsResponse struct { + Operators []string `protobuf:"bytes,1,rep,name=operators,proto3" json:"operators,omitempty"` +} + +func (m *OperatorsResponse) Reset() { *m = OperatorsResponse{} } +func (m *OperatorsResponse) String() string { return proto.CompactTextString(m) } +func (*OperatorsResponse) ProtoMessage() {} +func (*OperatorsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5e7780f9db9d346e, []int{15} +} +func (m *OperatorsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OperatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OperatorsResponse.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 *OperatorsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_OperatorsResponse.Merge(m, src) +} +func (m *OperatorsResponse) XXX_Size() int { + return m.Size() +} +func (m *OperatorsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_OperatorsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_OperatorsResponse proto.InternalMessageInfo + +func (m *OperatorsResponse) GetOperators() []string { + if m != nil { + return m.Operators + } + return nil +} + +type JudgesRequest struct { +} + +func (m *JudgesRequest) Reset() { *m = JudgesRequest{} } +func (m *JudgesRequest) String() string { return proto.CompactTextString(m) } +func (*JudgesRequest) ProtoMessage() {} +func (*JudgesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_5e7780f9db9d346e, []int{16} +} +func (m *JudgesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JudgesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JudgesRequest.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 *JudgesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_JudgesRequest.Merge(m, src) +} +func (m *JudgesRequest) XXX_Size() int { + return m.Size() +} +func (m *JudgesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_JudgesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_JudgesRequest proto.InternalMessageInfo + +type JudgesResponse struct { + Judges []string `protobuf:"bytes,1,rep,name=judges,proto3" json:"judges,omitempty"` +} + +func (m *JudgesResponse) Reset() { *m = JudgesResponse{} } +func (m *JudgesResponse) String() string { return proto.CompactTextString(m) } +func (*JudgesResponse) ProtoMessage() {} +func (*JudgesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_5e7780f9db9d346e, []int{17} +} +func (m *JudgesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JudgesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JudgesResponse.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 *JudgesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_JudgesResponse.Merge(m, src) +} +func (m *JudgesResponse) XXX_Size() int { + return m.Size() +} +func (m *JudgesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_JudgesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_JudgesResponse proto.InternalMessageInfo + +func (m *JudgesResponse) GetJudges() []string { + if m != nil { + return m.Judges + } + return nil +} + func init() { proto.RegisterType((*QueryParamsRequest)(nil), "lbm.fbridge.v1.QueryParamsRequest") proto.RegisterType((*QueryParamsResponse)(nil), "lbm.fbridge.v1.QueryParamsResponse") @@ -583,55 +823,70 @@ func init() { proto.RegisterType((*ConfirmedProvisionResponse)(nil), "lbm.fbridge.v1.ConfirmedProvisionResponse") proto.RegisterType((*CommitmentsRequest)(nil), "lbm.fbridge.v1.CommitmentsRequest") proto.RegisterType((*CommitmentsResponse)(nil), "lbm.fbridge.v1.CommitmentsResponse") + proto.RegisterType((*GuardiansRequest)(nil), "lbm.fbridge.v1.GuardiansRequest") + proto.RegisterType((*GuardiansResponse)(nil), "lbm.fbridge.v1.GuardiansResponse") + proto.RegisterType((*OperatorsRequest)(nil), "lbm.fbridge.v1.OperatorsRequest") + proto.RegisterType((*OperatorsResponse)(nil), "lbm.fbridge.v1.OperatorsResponse") + proto.RegisterType((*JudgesRequest)(nil), "lbm.fbridge.v1.JudgesRequest") + proto.RegisterType((*JudgesResponse)(nil), "lbm.fbridge.v1.JudgesResponse") } func init() { proto.RegisterFile("lbm/fbridge/v1/query.proto", fileDescriptor_5e7780f9db9d346e) } var fileDescriptor_5e7780f9db9d346e = []byte{ - // 680 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x95, 0xcf, 0x4f, 0xd4, 0x40, - 0x14, 0xc7, 0xb7, 0x80, 0xab, 0xbc, 0x4d, 0x0c, 0x19, 0x10, 0x97, 0x06, 0x0a, 0x96, 0xa8, 0x20, - 0xb0, 0x75, 0x01, 0x25, 0xf1, 0xc7, 0x05, 0x8c, 0x46, 0x4d, 0x14, 0x17, 0x4f, 0x5e, 0x36, 0xd3, - 0xdd, 0xa1, 0x34, 0xd2, 0x4e, 0xdb, 0x99, 0x25, 0x6c, 0x08, 0x07, 0xfd, 0x0b, 0x8c, 0x72, 0xf6, - 0xee, 0xd1, 0xff, 0x82, 0x23, 0x89, 0x17, 0x4f, 0xc6, 0x80, 0x7f, 0x88, 0xe9, 0x74, 0x0a, 0xcb, - 0x74, 0x8b, 0x7b, 0xf3, 0xf6, 0xf6, 0xcd, 0xf7, 0xbd, 0xf7, 0x99, 0xb7, 0xf3, 0x4d, 0x41, 0xdf, - 0xb6, 0x3d, 0x6b, 0xd3, 0x8e, 0xdc, 0xa6, 0x43, 0xac, 0x9d, 0xaa, 0x15, 0xb6, 0x48, 0xd4, 0xae, - 0x04, 0x11, 0xe5, 0x14, 0x5d, 0xdd, 0xb6, 0xbd, 0x8a, 0x3c, 0xab, 0xec, 0x54, 0xf5, 0x71, 0x87, - 0x52, 0x67, 0x9b, 0x58, 0x38, 0x70, 0x2d, 0xec, 0xfb, 0x94, 0x63, 0xee, 0x52, 0x9f, 0x25, 0x6a, - 0x7d, 0xc4, 0xa1, 0x0e, 0x15, 0xa1, 0x15, 0x47, 0x32, 0x3b, 0xae, 0xf4, 0x4f, 0xdb, 0x89, 0x53, - 0x73, 0x04, 0xd0, 0x9b, 0x78, 0xe0, 0x3a, 0x8e, 0xb0, 0xc7, 0x6a, 0x24, 0x6c, 0x11, 0xc6, 0xcd, - 0x97, 0x30, 0x7c, 0x2e, 0xcb, 0x02, 0xea, 0x33, 0x82, 0x96, 0xa1, 0x18, 0x88, 0x4c, 0x59, 0x9b, - 0xd2, 0x66, 0x4a, 0x8b, 0xa3, 0x95, 0xf3, 0x7c, 0x95, 0x44, 0xbf, 0x3a, 0x70, 0xf8, 0x6b, 0xb2, - 0x50, 0x93, 0x5a, 0xf3, 0x01, 0x8c, 0x3f, 0x8b, 0x08, 0xe6, 0x84, 0xf1, 0x0d, 0x12, 0xae, 0xb6, - 0x5f, 0x07, 0x24, 0xc2, 0x9c, 0x46, 0x72, 0x18, 0xd2, 0xe1, 0x0a, 0x95, 0x29, 0xd1, 0x77, 0xb0, - 0x76, 0xfa, 0xdb, 0xac, 0xc2, 0x44, 0x4e, 0xad, 0x44, 0x1a, 0x82, 0x7e, 0x46, 0x42, 0x51, 0x37, - 0x50, 0x8b, 0x43, 0x73, 0x0c, 0xae, 0xbf, 0x22, 0xbb, 0xb1, 0xfc, 0x2d, 0x5d, 0xa3, 0xfe, 0xa6, - 0x1b, 0x79, 0xe9, 0xb5, 0xe6, 0xa1, 0x9c, 0x3d, 0xca, 0x6d, 0xf4, 0x1c, 0xc6, 0x36, 0x5a, 0xb6, - 0xe7, 0x72, 0x4e, 0x9a, 0xeb, 0x11, 0xdd, 0x71, 0x99, 0x4b, 0xfd, 0x1e, 0xa0, 0xd3, 0x56, 0x7d, - 0x67, 0xad, 0x0e, 0x34, 0xd0, 0xbb, 0xf5, 0x92, 0xb3, 0x57, 0x60, 0xa0, 0x89, 0x39, 0x96, 0x5b, - 0x9d, 0xc8, 0x6c, 0x35, 0x2d, 0x78, 0x82, 0x39, 0x96, 0xcb, 0x15, 0x05, 0xe8, 0x31, 0x14, 0x19, - 0xc7, 0xbc, 0xc5, 0xc4, 0xb0, 0xd2, 0xe2, 0x64, 0x6e, 0xe9, 0x86, 0x90, 0xa5, 0xff, 0x4c, 0x52, - 0x64, 0x2e, 0xc0, 0x98, 0x5c, 0x43, 0x97, 0x1b, 0x66, 0x17, 0x12, 0xdf, 0xa2, 0x9b, 0xfe, 0x3f, - 0xdf, 0xe2, 0x16, 0xa0, 0x35, 0xea, 0x79, 0x2e, 0xf7, 0x88, 0xcf, 0x59, 0x3e, 0xfe, 0x0a, 0x0c, - 0x9f, 0xd3, 0x49, 0xec, 0x29, 0x28, 0x35, 0xce, 0xd2, 0x65, 0x6d, 0xaa, 0x7f, 0x66, 0xb0, 0xd6, - 0x99, 0x5a, 0x3c, 0xb8, 0x0c, 0x97, 0x84, 0x1d, 0x50, 0x08, 0xc5, 0xe4, 0x89, 0x23, 0x53, 0x65, - 0xcc, 0xba, 0x48, 0x9f, 0xbe, 0x50, 0x93, 0x8c, 0x37, 0x8d, 0x8f, 0x3f, 0xfe, 0x7c, 0xe9, 0x2b, - 0xa3, 0x51, 0x4b, 0xf1, 0x69, 0xe2, 0x1e, 0xf4, 0x5d, 0x83, 0x6b, 0x5d, 0x2d, 0x80, 0xe6, 0xd5, - 0xf6, 0x17, 0xb9, 0x4c, 0x5f, 0xe8, 0x51, 0x2d, 0xb1, 0x1e, 0x0a, 0xac, 0x7b, 0x68, 0x49, 0xc5, - 0x72, 0x64, 0x59, 0x9d, 0x91, 0xb0, 0x6e, 0xb7, 0xeb, 0xe9, 0xab, 0xb7, 0xf6, 0xd2, 0x68, 0x1f, - 0x7d, 0xd6, 0x60, 0x48, 0x35, 0x1a, 0xba, 0xad, 0x02, 0xe4, 0xb8, 0x54, 0x9f, 0xf9, 0xb7, 0x50, - 0x42, 0xce, 0x09, 0xc8, 0x9b, 0x68, 0x5a, 0x85, 0xf4, 0xc9, 0x6e, 0x02, 0xc8, 0x69, 0xbd, 0x21, - 0xe7, 0x7f, 0xd3, 0x00, 0x65, 0x3d, 0x88, 0x66, 0xd5, 0x69, 0xb9, 0x9e, 0xd7, 0xef, 0xf4, 0x22, - 0x95, 0x68, 0x8f, 0x04, 0xda, 0x7d, 0xb4, 0xac, 0xa2, 0xb1, 0xb4, 0xa6, 0x1e, 0xa4, 0x45, 0x1d, - 0xab, 0xb3, 0xf6, 0x18, 0x09, 0xf7, 0xd1, 0x57, 0x2d, 0x7e, 0xd3, 0xaa, 0xd3, 0xb2, 0xac, 0xb9, - 0xee, 0xcd, 0xb2, 0xe6, 0x1b, 0xd7, 0xac, 0x0a, 0xd6, 0x39, 0x34, 0xab, 0xb2, 0x36, 0xd2, 0x9a, - 0x4e, 0x56, 0x01, 0xf8, 0x41, 0x83, 0x52, 0x87, 0x99, 0xb2, 0x76, 0xc8, 0x3a, 0x32, 0x6b, 0x87, - 0x2e, 0x6e, 0x34, 0x67, 0x05, 0xcb, 0x34, 0xba, 0x91, 0x65, 0x39, 0x15, 0x27, 0x0c, 0xab, 0x2f, - 0x0e, 0x8f, 0x0d, 0xed, 0xe8, 0xd8, 0xd0, 0x7e, 0x1f, 0x1b, 0xda, 0xa7, 0x13, 0xa3, 0x70, 0x74, - 0x62, 0x14, 0x7e, 0x9e, 0x18, 0x85, 0x77, 0x77, 0x1d, 0x97, 0x6f, 0xb5, 0xec, 0x4a, 0x83, 0x7a, - 0xd6, 0x53, 0xd7, 0x67, 0x8d, 0x2d, 0x17, 0x5b, 0x9b, 0x32, 0x58, 0x60, 0xcd, 0xf7, 0xd6, 0xee, - 0x69, 0x6b, 0xde, 0x0e, 0x08, 0xb3, 0x8b, 0xe2, 0x6b, 0xb8, 0xf4, 0x37, 0x00, 0x00, 0xff, 0xff, - 0xca, 0xda, 0x4f, 0xed, 0x8d, 0x07, 0x00, 0x00, + // 818 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0xcf, 0x4f, 0x13, 0x4d, + 0x18, 0xee, 0x02, 0x5f, 0xf3, 0xf5, 0x6d, 0x3e, 0x3e, 0xbe, 0x81, 0x0f, 0xdb, 0xb5, 0x2c, 0x65, + 0x89, 0x5a, 0x04, 0xba, 0x16, 0x50, 0x12, 0x7f, 0x5c, 0xc0, 0x48, 0xc4, 0x44, 0xb1, 0x78, 0xf2, + 0xd2, 0x6c, 0xdb, 0x61, 0x59, 0x65, 0x77, 0xda, 0x9d, 0x29, 0xa1, 0x21, 0x1c, 0xf4, 0x2f, 0x30, + 0xea, 0xd9, 0xbb, 0x47, 0xff, 0x0b, 0x8e, 0x24, 0x5e, 0x3c, 0x19, 0x03, 0x26, 0xfe, 0x1b, 0xa6, + 0xb3, 0xb3, 0xdb, 0x76, 0xa7, 0x0b, 0xdc, 0xbc, 0xcd, 0xbe, 0xf3, 0xbc, 0xcf, 0xf3, 0xcc, 0xcb, + 0xcc, 0x43, 0x41, 0xdd, 0xab, 0x3a, 0xc6, 0x4e, 0xd5, 0xb3, 0xeb, 0x16, 0x36, 0xf6, 0x4b, 0x46, + 0xb3, 0x85, 0xbd, 0x76, 0xb1, 0xe1, 0x11, 0x46, 0xd0, 0xe8, 0x5e, 0xd5, 0x29, 0x8a, 0xbd, 0xe2, + 0x7e, 0x49, 0xcd, 0x59, 0x84, 0x58, 0x7b, 0xd8, 0x30, 0x1b, 0xb6, 0x61, 0xba, 0x2e, 0x61, 0x26, + 0xb3, 0x89, 0x4b, 0x7d, 0xb4, 0x3a, 0x61, 0x11, 0x8b, 0xf0, 0xa5, 0xd1, 0x59, 0x89, 0x6a, 0x2e, + 0xc2, 0x1f, 0xd0, 0xf1, 0x5d, 0x7d, 0x02, 0xd0, 0xf3, 0x8e, 0xe0, 0x96, 0xe9, 0x99, 0x0e, 0x2d, + 0xe3, 0x66, 0x0b, 0x53, 0xa6, 0x3f, 0x81, 0xf1, 0xbe, 0x2a, 0x6d, 0x10, 0x97, 0x62, 0xb4, 0x02, + 0xc9, 0x06, 0xaf, 0x64, 0x94, 0xbc, 0x52, 0x48, 0x2f, 0x4d, 0x16, 0xfb, 0xfd, 0x15, 0x7d, 0xfc, + 0xda, 0xc8, 0xf1, 0xf7, 0xe9, 0x44, 0x59, 0x60, 0xf5, 0xbb, 0x90, 0xdb, 0xf0, 0xb0, 0xc9, 0x30, + 0x65, 0xdb, 0xb8, 0xb9, 0xd6, 0x7e, 0xd6, 0xc0, 0x9e, 0xc9, 0x88, 0x27, 0xc4, 0x90, 0x0a, 0x7f, + 0x13, 0x51, 0xe2, 0xbc, 0xa9, 0x72, 0xf8, 0xad, 0x97, 0x60, 0x2a, 0xa6, 0x57, 0x58, 0x1a, 0x83, + 0x61, 0x8a, 0x9b, 0xbc, 0x6f, 0xa4, 0xdc, 0x59, 0xea, 0x59, 0xb8, 0xf2, 0x14, 0x1f, 0x74, 0xe0, + 0x2f, 0xc8, 0x3a, 0x71, 0x77, 0x6c, 0xcf, 0x09, 0x8e, 0xb5, 0x00, 0x19, 0x79, 0x2b, 0x96, 0xe8, + 0x31, 0x64, 0xb7, 0x5b, 0x55, 0xc7, 0x66, 0x0c, 0xd7, 0xb7, 0x3c, 0xb2, 0x6f, 0x53, 0x9b, 0xb8, + 0x97, 0x30, 0x1d, 0x50, 0x0d, 0x75, 0xa9, 0x3e, 0x2a, 0xa0, 0x0e, 0xe2, 0x12, 0xda, 0xab, 0x30, + 0x52, 0x37, 0x99, 0x29, 0xa6, 0x3a, 0x25, 0x4d, 0x35, 0x68, 0x78, 0x68, 0x32, 0x53, 0x0c, 0x97, + 0x37, 0xa0, 0x07, 0x90, 0xa4, 0xcc, 0x64, 0x2d, 0xca, 0xc5, 0xd2, 0x4b, 0xd3, 0xb1, 0xad, 0xdb, + 0x1c, 0x16, 0xfc, 0x65, 0xfc, 0x26, 0x7d, 0x11, 0xb2, 0x62, 0x0c, 0x03, 0x4e, 0x28, 0x0f, 0xa4, + 0x73, 0x8a, 0x41, 0xf8, 0x3f, 0x7c, 0x8a, 0xeb, 0x80, 0xd6, 0x89, 0xe3, 0xd8, 0xcc, 0xc1, 0x2e, + 0xa3, 0xf1, 0xf6, 0x57, 0x61, 0xbc, 0x0f, 0x27, 0x6c, 0xe7, 0x21, 0x5d, 0xeb, 0x96, 0x33, 0x4a, + 0x7e, 0xb8, 0x90, 0x2a, 0xf7, 0x96, 0x74, 0x04, 0x63, 0x1b, 0x2d, 0xd3, 0xab, 0xdb, 0xa6, 0x1b, + 0xbe, 0x90, 0x12, 0xfc, 0xd7, 0x53, 0x13, 0x54, 0x39, 0x48, 0x59, 0x41, 0x51, 0x10, 0x75, 0x0b, + 0x1d, 0x9a, 0xe0, 0xfa, 0xf6, 0xd2, 0xf4, 0xd4, 0xba, 0x34, 0xc1, 0x5d, 0x0a, 0x69, 0xc2, 0x82, + 0xfe, 0x2f, 0xfc, 0xb3, 0xd9, 0xaa, 0x5b, 0x38, 0xe4, 0x28, 0xc0, 0x68, 0x50, 0x10, 0x04, 0x93, + 0x90, 0x7c, 0xc5, 0x2b, 0xa2, 0x5b, 0x7c, 0x2d, 0xfd, 0x4a, 0xc1, 0x5f, 0xfc, 0x5d, 0xa3, 0x26, + 0x24, 0xfd, 0xb7, 0x8a, 0xf4, 0xe8, 0xb0, 0xe5, 0x38, 0x50, 0x67, 0xcf, 0xc5, 0xf8, 0xa2, 0xba, + 0xf6, 0xf6, 0xeb, 0xcf, 0x0f, 0x43, 0x19, 0x34, 0x69, 0x44, 0x02, 0xc7, 0x8f, 0x01, 0xf4, 0x45, + 0x81, 0xff, 0x07, 0xbe, 0x65, 0xb4, 0x10, 0xa5, 0x3f, 0x2f, 0x2e, 0xd4, 0xc5, 0x4b, 0xa2, 0x85, + 0xad, 0x7b, 0xdc, 0xd6, 0x6d, 0xb4, 0x1c, 0xb5, 0x65, 0x89, 0xb6, 0x0a, 0xc5, 0xcd, 0x4a, 0xb5, + 0x5d, 0x09, 0x26, 0x6c, 0x1c, 0x06, 0xab, 0x23, 0xf4, 0x5e, 0x81, 0xb1, 0x68, 0x62, 0xa0, 0x1b, + 0x51, 0x03, 0x31, 0x71, 0xa3, 0x16, 0x2e, 0x06, 0x0a, 0x93, 0xf3, 0xdc, 0xe4, 0x35, 0x34, 0x1b, + 0x35, 0xe9, 0xe2, 0x03, 0xdf, 0x20, 0x23, 0x95, 0x9a, 0xd0, 0xff, 0xac, 0x00, 0x92, 0xc3, 0x04, + 0xcd, 0x45, 0xd5, 0x62, 0xc3, 0x4b, 0xbd, 0x79, 0x19, 0xa8, 0xb0, 0x76, 0x9f, 0x5b, 0xbb, 0x83, + 0x56, 0xa2, 0xd6, 0x68, 0xd0, 0x53, 0x69, 0x04, 0x4d, 0x3d, 0xa3, 0x33, 0x0e, 0x29, 0x6e, 0x1e, + 0xa1, 0x4f, 0x4a, 0xe7, 0x71, 0x46, 0x23, 0x43, 0xf6, 0x1a, 0x1b, 0x43, 0xb2, 0xd7, 0xf8, 0x04, + 0xd2, 0x4b, 0xdc, 0xeb, 0x3c, 0x9a, 0x8b, 0x7a, 0xad, 0x05, 0x3d, 0xbd, 0x5e, 0xb9, 0xc1, 0x37, + 0x0a, 0xa4, 0x7b, 0x52, 0x41, 0x7e, 0x0e, 0x72, 0xb4, 0xc8, 0xcf, 0x61, 0x40, 0xac, 0xe8, 0x73, + 0xdc, 0xcb, 0x2c, 0x9a, 0x91, 0xbd, 0x84, 0x60, 0xe1, 0x81, 0x42, 0x2a, 0xcc, 0x12, 0x94, 0x97, + 0xae, 0x77, 0x24, 0x7a, 0xd4, 0x99, 0x73, 0x10, 0x42, 0x7c, 0x86, 0x8b, 0x5f, 0x45, 0x59, 0xe9, + 0xd2, 0x87, 0x3a, 0x14, 0x52, 0x61, 0xf2, 0xc8, 0xa2, 0xd1, 0xa0, 0x92, 0x45, 0xa5, 0xd8, 0x8a, + 0x17, 0x0d, 0xb3, 0x0b, 0x59, 0x90, 0xf4, 0xa3, 0x0a, 0x49, 0xff, 0x1e, 0xfa, 0x32, 0x4d, 0xd5, + 0xe2, 0xb6, 0x2f, 0x0a, 0x1b, 0x3f, 0xe9, 0xd6, 0x36, 0x8f, 0x4f, 0x35, 0xe5, 0xe4, 0x54, 0x53, + 0x7e, 0x9c, 0x6a, 0xca, 0xbb, 0x33, 0x2d, 0x71, 0x72, 0xa6, 0x25, 0xbe, 0x9d, 0x69, 0x89, 0x97, + 0xb7, 0x2c, 0x9b, 0xed, 0xb6, 0xaa, 0xc5, 0x1a, 0x71, 0x8c, 0x47, 0xb6, 0x4b, 0x6b, 0xbb, 0xb6, + 0x69, 0xec, 0x88, 0xc5, 0x22, 0xad, 0xbf, 0x36, 0x0e, 0x42, 0x3e, 0xd6, 0x6e, 0x60, 0x5a, 0x4d, + 0xf2, 0x5f, 0x4a, 0xcb, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x55, 0x64, 0x53, 0xe7, 0xa9, 0x09, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -658,6 +913,12 @@ type QueryClient interface { ConfirmedProvision(ctx context.Context, in *ConfirmedProvisionRequest, opts ...grpc.CallOption) (*ConfirmedProvisionResponse, error) // Get commitments of a specific sequence number Commitments(ctx context.Context, in *CommitmentsRequest, opts ...grpc.CallOption) (*CommitmentsResponse, error) + // Get a list of Guardians registered on the bridge + Guardians(ctx context.Context, in *GuardiansRequest, opts ...grpc.CallOption) (*GuardiansResponse, error) + // Get a list of Operators registered on the bridge + Operators(ctx context.Context, in *OperatorsRequest, opts ...grpc.CallOption) (*OperatorsResponse, error) + // Get a list of Judges registered on the bridge + Judges(ctx context.Context, in *JudgesRequest, opts ...grpc.CallOption) (*JudgesResponse, error) } type queryClient struct { @@ -722,6 +983,33 @@ func (c *queryClient) Commitments(ctx context.Context, in *CommitmentsRequest, o return out, nil } +func (c *queryClient) Guardians(ctx context.Context, in *GuardiansRequest, opts ...grpc.CallOption) (*GuardiansResponse, error) { + out := new(GuardiansResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Query/Guardians", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Operators(ctx context.Context, in *OperatorsRequest, opts ...grpc.CallOption) (*OperatorsResponse, error) { + out := new(OperatorsResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Query/Operators", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Judges(ctx context.Context, in *JudgesRequest, opts ...grpc.CallOption) (*JudgesResponse, error) { + out := new(JudgesResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Query/Judges", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Params queries the parameters of x/fbridge module. @@ -736,6 +1024,12 @@ type QueryServer interface { ConfirmedProvision(context.Context, *ConfirmedProvisionRequest) (*ConfirmedProvisionResponse, error) // Get commitments of a specific sequence number Commitments(context.Context, *CommitmentsRequest) (*CommitmentsResponse, error) + // Get a list of Guardians registered on the bridge + Guardians(context.Context, *GuardiansRequest) (*GuardiansResponse, error) + // Get a list of Operators registered on the bridge + Operators(context.Context, *OperatorsRequest) (*OperatorsResponse, error) + // Get a list of Judges registered on the bridge + Judges(context.Context, *JudgesRequest) (*JudgesResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -760,6 +1054,15 @@ func (*UnimplementedQueryServer) ConfirmedProvision(ctx context.Context, req *Co func (*UnimplementedQueryServer) Commitments(ctx context.Context, req *CommitmentsRequest) (*CommitmentsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Commitments not implemented") } +func (*UnimplementedQueryServer) Guardians(ctx context.Context, req *GuardiansRequest) (*GuardiansResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Guardians not implemented") +} +func (*UnimplementedQueryServer) Operators(ctx context.Context, req *OperatorsRequest) (*OperatorsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Operators not implemented") +} +func (*UnimplementedQueryServer) Judges(ctx context.Context, req *JudgesRequest) (*JudgesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Judges not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -873,6 +1176,60 @@ func _Query_Commitments_Handler(srv interface{}, ctx context.Context, dec func(i return interceptor(ctx, in, info, handler) } +func _Query_Guardians_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GuardiansRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Guardians(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Query/Guardians", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Guardians(ctx, req.(*GuardiansRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Operators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(OperatorsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Operators(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Query/Operators", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Operators(ctx, req.(*OperatorsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Judges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(JudgesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Judges(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Query/Judges", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Judges(ctx, req.(*JudgesRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "lbm.fbridge.v1.Query", HandlerType: (*QueryServer)(nil), @@ -901,6 +1258,18 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "Commitments", Handler: _Query_Commitments_Handler, }, + { + MethodName: "Guardians", + Handler: _Query_Guardians_Handler, + }, + { + MethodName: "Operators", + Handler: _Query_Operators_Handler, + }, + { + MethodName: "Judges", + Handler: _Query_Judges_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "lbm/fbridge/v1/query.proto", @@ -1280,53 +1649,218 @@ func (m *CommitmentsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 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 *QueryParamsRequest) Size() (n int) { - if m == nil { - return 0 +func (m *GuardiansRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *QueryParamsResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.Params.Size() - n += 1 + l + sovQuery(uint64(l)) - return n +func (m *GuardiansRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GreatestSeqByOperatorRequest) Size() (n int) { - if m == nil { - return 0 - } +func (m *GuardiansRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovQuery(uint64(l)) - } - return n + return len(dAtA) - i, nil } -func (m *GreatestSeqByOperatorResponse) Size() (n int) { - if m == nil { - return 0 +func (m *GuardiansResponse) 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 *GuardiansResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GuardiansResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Guardians) > 0 { + for iNdEx := len(m.Guardians) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Guardians[iNdEx]) + copy(dAtA[i:], m.Guardians[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Guardians[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *OperatorsRequest) 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 *OperatorsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OperatorsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *OperatorsResponse) 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 *OperatorsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OperatorsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Operators) > 0 { + for iNdEx := len(m.Operators) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Operators[iNdEx]) + copy(dAtA[i:], m.Operators[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Operators[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *JudgesRequest) 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 *JudgesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JudgesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *JudgesResponse) 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 *JudgesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JudgesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Judges) > 0 { + for iNdEx := len(m.Judges) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Judges[iNdEx]) + copy(dAtA[i:], m.Judges[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Judges[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + 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 *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *GreatestSeqByOperatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Operator) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *GreatestSeqByOperatorResponse) Size() (n int) { + if m == nil { + return 0 } var l int _ = l @@ -1438,6 +1972,78 @@ func (m *CommitmentsResponse) Size() (n int) { return n } +func (m *GuardiansRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *GuardiansResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Guardians) > 0 { + for _, s := range m.Guardians { + l = len(s) + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func (m *OperatorsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *OperatorsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Operators) > 0 { + for _, s := range m.Operators { + l = len(s) + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func (m *JudgesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *JudgesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Judges) > 0 { + for _, s := range m.Judges { + l = len(s) + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -2400,6 +3006,402 @@ func (m *CommitmentsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *GuardiansRequest) 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: GuardiansRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GuardiansRequest: 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 *GuardiansResponse) 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: GuardiansResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GuardiansResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Guardians", 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.Guardians = append(m.Guardians, 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 *OperatorsRequest) 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: OperatorsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OperatorsRequest: 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 *OperatorsResponse) 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: OperatorsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OperatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operators", 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.Operators = append(m.Operators, 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 *JudgesRequest) 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: JudgesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JudgesRequest: 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 *JudgesResponse) 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: JudgesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JudgesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Judges", 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.Judges = append(m.Judges, 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 skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/fbridge/types/query.pb.gw.go b/x/fbridge/types/query.pb.gw.go index 8dc109a27b..394633f441 100644 --- a/x/fbridge/types/query.pb.gw.go +++ b/x/fbridge/types/query.pb.gw.go @@ -305,6 +305,60 @@ func local_request_Query_Commitments_0(ctx context.Context, marshaler runtime.Ma } +func request_Query_Guardians_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GuardiansRequest + var metadata runtime.ServerMetadata + + msg, err := client.Guardians(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Guardians_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GuardiansRequest + var metadata runtime.ServerMetadata + + msg, err := server.Guardians(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_Operators_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq OperatorsRequest + var metadata runtime.ServerMetadata + + msg, err := client.Operators(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Operators_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq OperatorsRequest + var metadata runtime.ServerMetadata + + msg, err := server.Operators(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_Judges_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq JudgesRequest + var metadata runtime.ServerMetadata + + msg, err := client.Judges(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Judges_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq JudgesRequest + var metadata runtime.ServerMetadata + + msg, err := server.Judges(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -431,6 +485,66 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_Guardians_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_Guardians_0(rctx, inboundMarshaler, server, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Guardians_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_Operators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_Operators_0(rctx, inboundMarshaler, server, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Operators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_Judges_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_Judges_0(rctx, inboundMarshaler, server, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Judges_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -592,6 +706,66 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_Guardians_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_Guardians_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Guardians_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_Operators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_Operators_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Operators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_Judges_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_Judges_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Judges_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -607,6 +781,12 @@ var ( pattern_Query_ConfirmedProvision_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"lbm", "fbridge", "v1", "confirmed_provision", "seq"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_Commitments_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"lbm", "fbridge", "v1", "commitments", "seq"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_Guardians_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"lbm", "fbridge", "v1", "guardians"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_Operators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"lbm", "fbridge", "v1", "operators"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_Judges_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"lbm", "fbridge", "v1", "judges"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( @@ -621,4 +801,10 @@ var ( forward_Query_ConfirmedProvision_0 = runtime.ForwardResponseMessage forward_Query_Commitments_0 = runtime.ForwardResponseMessage + + forward_Query_Guardians_0 = runtime.ForwardResponseMessage + + forward_Query_Operators_0 = runtime.ForwardResponseMessage + + forward_Query_Judges_0 = runtime.ForwardResponseMessage ) diff --git a/x/fbridge/types/tx.pb.go b/x/fbridge/types/tx.pb.go index 9ef35bdffc..074ff0f75e 100644 --- a/x/fbridge/types/tx.pb.go +++ b/x/fbridge/types/tx.pb.go @@ -634,954 +634,2801 @@ func (m *ClaimResponse) XXX_DiscardUnknown() { var xxx_messageInfo_ClaimResponse proto.InternalMessageInfo -func init() { - proto.RegisterType((*TransferRequest)(nil), "lbm.fbridge.v1.TransferRequest") - proto.RegisterType((*TransferResponse)(nil), "lbm.fbridge.v1.TransferResponse") - proto.RegisterType((*ProvisionRequest)(nil), "lbm.fbridge.v1.ProvisionRequest") - proto.RegisterType((*ProvisionResponse)(nil), "lbm.fbridge.v1.ProvisionResponse") - proto.RegisterType((*HoldTransferRequest)(nil), "lbm.fbridge.v1.HoldTransferRequest") - proto.RegisterType((*HoldTransferResponse)(nil), "lbm.fbridge.v1.HoldTransferResponse") - proto.RegisterType((*ReleaseTransferRequest)(nil), "lbm.fbridge.v1.ReleaseTransferRequest") - proto.RegisterType((*ReleaseTransferResponse)(nil), "lbm.fbridge.v1.ReleaseTransferResponse") - proto.RegisterType((*RemoveProvisionRequest)(nil), "lbm.fbridge.v1.RemoveProvisionRequest") - proto.RegisterType((*RemoveProvisionResponse)(nil), "lbm.fbridge.v1.RemoveProvisionResponse") - proto.RegisterType((*ClaimBatchRequest)(nil), "lbm.fbridge.v1.ClaimBatchRequest") - proto.RegisterType((*ClaimBatchResponse)(nil), "lbm.fbridge.v1.ClaimBatchResponse") - proto.RegisterType((*ClaimRequest)(nil), "lbm.fbridge.v1.ClaimRequest") - proto.RegisterType((*ClaimResponse)(nil), "lbm.fbridge.v1.ClaimResponse") +// AddGuardianRequest is input values required for adding a guardian +type AddGuardianRequest struct { + // the guardian address to be added + Guardian string `protobuf:"bytes,1,opt,name=guardian,proto3" json:"guardian,omitempty"` } -func init() { proto.RegisterFile("lbm/fbridge/v1/tx.proto", fileDescriptor_54a336bc5ea063bb) } - -var fileDescriptor_54a336bc5ea063bb = []byte{ - // 523 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xcf, 0x6e, 0xd3, 0x40, - 0x10, 0xc6, 0xe3, 0x26, 0x44, 0xcd, 0xa8, 0x90, 0x74, 0x1b, 0xa5, 0xc1, 0xa2, 0x4e, 0x30, 0x88, - 0xa2, 0x4a, 0xd8, 0x34, 0xbc, 0x41, 0x40, 0x08, 0x2a, 0x55, 0xaa, 0x0c, 0x17, 0xb8, 0x20, 0xdb, - 0x99, 0x38, 0x16, 0xb6, 0x37, 0xf5, 0x3a, 0x56, 0x78, 0x0b, 0x78, 0x07, 0x1e, 0xa6, 0xc7, 0x1e, - 0x11, 0x87, 0x0a, 0x25, 0x3c, 0x08, 0x8a, 0xbd, 0x49, 0x1c, 0xff, 0x49, 0x0e, 0xdc, 0x76, 0x77, - 0xbe, 0xf9, 0xed, 0xb7, 0xb3, 0xa3, 0x81, 0x63, 0xc7, 0x70, 0xd5, 0xa1, 0xe1, 0xdb, 0x03, 0x0b, - 0xd5, 0xf0, 0x5c, 0x0d, 0xa6, 0xca, 0xd8, 0xa7, 0x01, 0x25, 0x0f, 0x1c, 0xc3, 0x55, 0x78, 0x40, - 0x09, 0xcf, 0xc5, 0xa6, 0x45, 0x2d, 0x1a, 0x85, 0xd4, 0xc5, 0x2a, 0x56, 0xc9, 0x3f, 0x04, 0xa8, - 0x7f, 0xf4, 0x75, 0x8f, 0x0d, 0xd1, 0xd7, 0xf0, 0x7a, 0x82, 0x2c, 0x20, 0x2d, 0xa8, 0x32, 0xf4, - 0x06, 0xe8, 0xb7, 0x85, 0xae, 0xf0, 0xbc, 0xa6, 0xf1, 0x1d, 0x11, 0x61, 0xdf, 0x47, 0x13, 0xed, - 0x10, 0xfd, 0xf6, 0x5e, 0x14, 0x59, 0xed, 0xc9, 0x05, 0x54, 0x75, 0x97, 0x4e, 0xbc, 0xa0, 0x5d, - 0x5e, 0x44, 0xfa, 0xbd, 0x9b, 0xbb, 0x4e, 0xe9, 0xf7, 0x5d, 0xe7, 0xcc, 0xb2, 0x83, 0xd1, 0xc4, - 0x50, 0x4c, 0xea, 0xaa, 0x6f, 0x6d, 0x8f, 0x99, 0x23, 0x5b, 0x57, 0x87, 0x7c, 0xf1, 0x82, 0x0d, - 0xbe, 0xaa, 0xc1, 0xb7, 0x31, 0x32, 0xe5, 0xbd, 0x17, 0x68, 0x9c, 0x20, 0x13, 0x68, 0xac, 0x2d, - 0xb1, 0x31, 0xf5, 0x18, 0xca, 0x3f, 0x05, 0x68, 0x5c, 0xf9, 0x34, 0xb4, 0x99, 0x4d, 0xbd, 0xa5, - 0xd1, 0x06, 0x94, 0x19, 0x5e, 0x47, 0x2e, 0x2b, 0xda, 0x62, 0x99, 0xb0, 0xbe, 0x57, 0x68, 0xbd, - 0x5c, 0x68, 0xbd, 0xf2, 0xdf, 0xd6, 0x8f, 0xe0, 0x30, 0xe1, 0x92, 0x7b, 0x3f, 0x85, 0xa3, 0x77, - 0xd4, 0x19, 0xa4, 0xcb, 0x9c, 0x71, 0x2f, 0xb7, 0xa0, 0xb9, 0x29, 0xe4, 0x80, 0x33, 0x68, 0x69, - 0xe8, 0xa0, 0xce, 0x70, 0x37, 0xe3, 0x21, 0x1c, 0x67, 0xb4, 0x49, 0x8c, 0x4b, 0x43, 0xdc, 0x5d, - 0xc8, 0x18, 0x93, 0xd2, 0x72, 0x4c, 0x0f, 0x0e, 0x5f, 0x3b, 0xba, 0xed, 0xf6, 0xf5, 0xc0, 0x1c, - 0x2d, 0x09, 0x27, 0x00, 0xae, 0x3e, 0xfd, 0x62, 0x2e, 0x02, 0x8c, 0x83, 0x6a, 0xae, 0x3e, 0x8d, - 0x94, 0x4c, 0x6e, 0x02, 0x49, 0xe6, 0x70, 0x52, 0x17, 0x0e, 0xa2, 0xd3, 0x62, 0x1b, 0x75, 0xb8, - 0xcf, 0x15, 0x71, 0x4a, 0xef, 0x6f, 0x05, 0xca, 0x97, 0xcc, 0x22, 0x97, 0xb0, 0xbf, 0x7c, 0x1f, - 0xe9, 0x28, 0x9b, 0xad, 0xae, 0xa4, 0xaa, 0x24, 0x76, 0x8b, 0x05, 0x31, 0x96, 0x5c, 0x41, 0x6d, - 0xf5, 0x50, 0x92, 0x91, 0xa7, 0xeb, 0x25, 0x3e, 0xde, 0xa2, 0xe0, 0xc4, 0x4f, 0x70, 0x90, 0xfc, - 0x4b, 0xf2, 0x24, 0x9d, 0x92, 0xd3, 0x12, 0xe2, 0xd3, 0xed, 0x22, 0x8e, 0x36, 0xa0, 0x9e, 0xfa, - 0x62, 0xf2, 0x2c, 0x9d, 0x98, 0xdf, 0x2f, 0xe2, 0xe9, 0x4e, 0x5d, 0xf2, 0x8e, 0x8d, 0xff, 0xcf, - 0xbb, 0x23, 0xaf, 0x99, 0xf2, 0xee, 0xc8, 0x6d, 0x24, 0xf2, 0x01, 0x60, 0xdd, 0x14, 0x24, 0x53, - 0xd3, 0x4c, 0x93, 0x89, 0xf2, 0x36, 0x09, 0x87, 0xbe, 0x81, 0x7b, 0xd1, 0x29, 0x79, 0x94, 0x2b, - 0x5e, 0xa2, 0x4e, 0x0a, 0xa2, 0x31, 0xa5, 0x7f, 0x71, 0x33, 0x93, 0x84, 0xdb, 0x99, 0x24, 0xfc, - 0x99, 0x49, 0xc2, 0xf7, 0xb9, 0x54, 0xba, 0x9d, 0x4b, 0xa5, 0x5f, 0x73, 0xa9, 0xf4, 0xf9, 0xe5, - 0xce, 0xa9, 0x30, 0x5d, 0x8d, 0xe3, 0x68, 0x3e, 0x18, 0xd5, 0x68, 0xd2, 0xbe, 0xfa, 0x17, 0x00, - 0x00, 0xff, 0xff, 0x3e, 0x4d, 0xae, 0x45, 0xaa, 0x05, 0x00, 0x00, +func (m *AddGuardianRequest) Reset() { *m = AddGuardianRequest{} } +func (m *AddGuardianRequest) String() string { return proto.CompactTextString(m) } +func (*AddGuardianRequest) ProtoMessage() {} +func (*AddGuardianRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{14} +} +func (m *AddGuardianRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddGuardianRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddGuardianRequest.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 *AddGuardianRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddGuardianRequest.Merge(m, src) +} +func (m *AddGuardianRequest) XXX_Size() int { + return m.Size() +} +func (m *AddGuardianRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AddGuardianRequest.DiscardUnknown(m) } -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +var xxx_messageInfo_AddGuardianRequest proto.InternalMessageInfo -// 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 +func (m *AddGuardianRequest) GetGuardian() string { + if m != nil { + return m.Guardian + } + return "" +} -// 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 { - // Submit a transfer request to the bridge module. - Transfer(ctx context.Context, in *TransferRequest, opts ...grpc.CallOption) (*TransferResponse, error) - // Submit a provision to the bridge module. - Provision(ctx context.Context, in *ProvisionRequest, opts ...grpc.CallOption) (*ProvisionResponse, error) - // Set the time lock value from default value to uint64.max for specific confirmed provision. - HoldTransfer(ctx context.Context, in *HoldTransferRequest, opts ...grpc.CallOption) (*HoldTransferResponse, error) - // Set the time lock value to 0 for specific confirmed provision. - ReleaseTransfer(ctx context.Context, in *ReleaseTransferRequest, opts ...grpc.CallOption) (*ReleaseTransferResponse, error) - // Remove a specific confirmed provision (reset for specific sequence number). - RemoveProvision(ctx context.Context, in *RemoveProvisionRequest, opts ...grpc.CallOption) (*RemoveProvisionResponse, error) - // ClaimBatch processes the claiming of multiple claimable provisions in a single operation - ClaimBatch(ctx context.Context, in *ClaimBatchRequest, opts ...grpc.CallOption) (*ClaimBatchResponse, error) - // Claim processes the claiming of a provision with a specific sequence number - Claim(ctx context.Context, in *ClaimRequest, opts ...grpc.CallOption) (*ClaimResponse, error) +type AddGuardianResponse struct { } -type msgClient struct { - cc grpc1.ClientConn +func (m *AddGuardianResponse) Reset() { *m = AddGuardianResponse{} } +func (m *AddGuardianResponse) String() string { return proto.CompactTextString(m) } +func (*AddGuardianResponse) ProtoMessage() {} +func (*AddGuardianResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{15} +} +func (m *AddGuardianResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddGuardianResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddGuardianResponse.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 *AddGuardianResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddGuardianResponse.Merge(m, src) +} +func (m *AddGuardianResponse) XXX_Size() int { + return m.Size() +} +func (m *AddGuardianResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AddGuardianResponse.DiscardUnknown(m) } -func NewMsgClient(cc grpc1.ClientConn) MsgClient { - return &msgClient{cc} +var xxx_messageInfo_AddGuardianResponse proto.InternalMessageInfo + +// RemoveGuardianRequest is input values required for removing a guardian +type RemoveGuardianRequest struct { + // the guardian address to be removed + Guardian string `protobuf:"bytes,1,opt,name=guardian,proto3" json:"guardian,omitempty"` } -func (c *msgClient) Transfer(ctx context.Context, in *TransferRequest, opts ...grpc.CallOption) (*TransferResponse, error) { - out := new(TransferResponse) - err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/Transfer", in, out, opts...) - if err != nil { - return nil, err +func (m *RemoveGuardianRequest) Reset() { *m = RemoveGuardianRequest{} } +func (m *RemoveGuardianRequest) String() string { return proto.CompactTextString(m) } +func (*RemoveGuardianRequest) ProtoMessage() {} +func (*RemoveGuardianRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{16} +} +func (m *RemoveGuardianRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RemoveGuardianRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RemoveGuardianRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *RemoveGuardianRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RemoveGuardianRequest.Merge(m, src) +} +func (m *RemoveGuardianRequest) XXX_Size() int { + return m.Size() +} +func (m *RemoveGuardianRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RemoveGuardianRequest.DiscardUnknown(m) } -func (c *msgClient) Provision(ctx context.Context, in *ProvisionRequest, opts ...grpc.CallOption) (*ProvisionResponse, error) { - out := new(ProvisionResponse) - err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/Provision", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_RemoveGuardianRequest proto.InternalMessageInfo + +func (m *RemoveGuardianRequest) GetGuardian() string { + if m != nil { + return m.Guardian } - return out, nil + return "" } -func (c *msgClient) HoldTransfer(ctx context.Context, in *HoldTransferRequest, opts ...grpc.CallOption) (*HoldTransferResponse, error) { - out := new(HoldTransferResponse) - err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/HoldTransfer", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type RemoveGuardianResponse struct { } -func (c *msgClient) ReleaseTransfer(ctx context.Context, in *ReleaseTransferRequest, opts ...grpc.CallOption) (*ReleaseTransferResponse, error) { - out := new(ReleaseTransferResponse) - err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/ReleaseTransfer", in, out, opts...) - if err != nil { - return nil, err +func (m *RemoveGuardianResponse) Reset() { *m = RemoveGuardianResponse{} } +func (m *RemoveGuardianResponse) String() string { return proto.CompactTextString(m) } +func (*RemoveGuardianResponse) ProtoMessage() {} +func (*RemoveGuardianResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{17} +} +func (m *RemoveGuardianResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RemoveGuardianResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RemoveGuardianResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *RemoveGuardianResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RemoveGuardianResponse.Merge(m, src) +} +func (m *RemoveGuardianResponse) XXX_Size() int { + return m.Size() +} +func (m *RemoveGuardianResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RemoveGuardianResponse.DiscardUnknown(m) } -func (c *msgClient) RemoveProvision(ctx context.Context, in *RemoveProvisionRequest, opts ...grpc.CallOption) (*RemoveProvisionResponse, error) { - out := new(RemoveProvisionResponse) - err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/RemoveProvision", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +var xxx_messageInfo_RemoveGuardianResponse proto.InternalMessageInfo + +// AddOperatorRequest is input values required for adding an operator +type AddOperatorRequest struct { + // the operator address to be added + Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"` } -func (c *msgClient) ClaimBatch(ctx context.Context, in *ClaimBatchRequest, opts ...grpc.CallOption) (*ClaimBatchResponse, error) { - out := new(ClaimBatchResponse) - err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/ClaimBatch", in, out, opts...) - if err != nil { - return nil, err +func (m *AddOperatorRequest) Reset() { *m = AddOperatorRequest{} } +func (m *AddOperatorRequest) String() string { return proto.CompactTextString(m) } +func (*AddOperatorRequest) ProtoMessage() {} +func (*AddOperatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{18} +} +func (m *AddOperatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddOperatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddOperatorRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *AddOperatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddOperatorRequest.Merge(m, src) +} +func (m *AddOperatorRequest) XXX_Size() int { + return m.Size() +} +func (m *AddOperatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AddOperatorRequest.DiscardUnknown(m) } -func (c *msgClient) Claim(ctx context.Context, in *ClaimRequest, opts ...grpc.CallOption) (*ClaimResponse, error) { - out := new(ClaimResponse) - err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/Claim", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_AddOperatorRequest proto.InternalMessageInfo + +func (m *AddOperatorRequest) GetOperator() string { + if m != nil { + return m.Operator } - return out, nil + return "" } -// MsgServer is the server API for Msg service. -type MsgServer interface { - // Submit a transfer request to the bridge module. - Transfer(context.Context, *TransferRequest) (*TransferResponse, error) - // Submit a provision to the bridge module. - Provision(context.Context, *ProvisionRequest) (*ProvisionResponse, error) - // Set the time lock value from default value to uint64.max for specific confirmed provision. - HoldTransfer(context.Context, *HoldTransferRequest) (*HoldTransferResponse, error) - // Set the time lock value to 0 for specific confirmed provision. - ReleaseTransfer(context.Context, *ReleaseTransferRequest) (*ReleaseTransferResponse, error) - // Remove a specific confirmed provision (reset for specific sequence number). - RemoveProvision(context.Context, *RemoveProvisionRequest) (*RemoveProvisionResponse, error) - // ClaimBatch processes the claiming of multiple claimable provisions in a single operation - ClaimBatch(context.Context, *ClaimBatchRequest) (*ClaimBatchResponse, error) - // Claim processes the claiming of a provision with a specific sequence number - Claim(context.Context, *ClaimRequest) (*ClaimResponse, error) +type AddOperatorResponse struct { } -// UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { +func (m *AddOperatorResponse) Reset() { *m = AddOperatorResponse{} } +func (m *AddOperatorResponse) String() string { return proto.CompactTextString(m) } +func (*AddOperatorResponse) ProtoMessage() {} +func (*AddOperatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{19} +} +func (m *AddOperatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddOperatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddOperatorResponse.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 *AddOperatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddOperatorResponse.Merge(m, src) +} +func (m *AddOperatorResponse) XXX_Size() int { + return m.Size() +} +func (m *AddOperatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AddOperatorResponse.DiscardUnknown(m) } -func (*UnimplementedMsgServer) Transfer(ctx context.Context, req *TransferRequest) (*TransferResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Transfer not implemented") +var xxx_messageInfo_AddOperatorResponse proto.InternalMessageInfo + +// RemoveOperatorRequest is input values required for removing an operator +type RemoveOperatorRequest struct { + // the operator address to be removed + Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"` } -func (*UnimplementedMsgServer) Provision(ctx context.Context, req *ProvisionRequest) (*ProvisionResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Provision not implemented") + +func (m *RemoveOperatorRequest) Reset() { *m = RemoveOperatorRequest{} } +func (m *RemoveOperatorRequest) String() string { return proto.CompactTextString(m) } +func (*RemoveOperatorRequest) ProtoMessage() {} +func (*RemoveOperatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{20} } -func (*UnimplementedMsgServer) HoldTransfer(ctx context.Context, req *HoldTransferRequest) (*HoldTransferResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method HoldTransfer not implemented") +func (m *RemoveOperatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } -func (*UnimplementedMsgServer) ReleaseTransfer(ctx context.Context, req *ReleaseTransferRequest) (*ReleaseTransferResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ReleaseTransfer not implemented") +func (m *RemoveOperatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RemoveOperatorRequest.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 (*UnimplementedMsgServer) RemoveProvision(ctx context.Context, req *RemoveProvisionRequest) (*RemoveProvisionResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method RemoveProvision not implemented") +func (m *RemoveOperatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RemoveOperatorRequest.Merge(m, src) } -func (*UnimplementedMsgServer) ClaimBatch(ctx context.Context, req *ClaimBatchRequest) (*ClaimBatchResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ClaimBatch not implemented") +func (m *RemoveOperatorRequest) XXX_Size() int { + return m.Size() } -func (*UnimplementedMsgServer) Claim(ctx context.Context, req *ClaimRequest) (*ClaimResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Claim not implemented") +func (m *RemoveOperatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RemoveOperatorRequest.DiscardUnknown(m) } -func RegisterMsgServer(s grpc1.Server, srv MsgServer) { - s.RegisterService(&_Msg_serviceDesc, srv) -} +var xxx_messageInfo_RemoveOperatorRequest proto.InternalMessageInfo -func _Msg_Transfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(TransferRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).Transfer(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/lbm.fbridge.v1.Msg/Transfer", +func (m *RemoveOperatorRequest) GetOperator() string { + if m != nil { + return m.Operator } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).Transfer(ctx, req.(*TransferRequest)) - } - return interceptor(ctx, in, info, handler) + return "" } -func _Msg_Provision_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ProvisionRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).Provision(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/lbm.fbridge.v1.Msg/Provision", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).Provision(ctx, req.(*ProvisionRequest)) - } - return interceptor(ctx, in, info, handler) +type RemoveOperatorResponse struct { } -func _Msg_HoldTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(HoldTransferRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).HoldTransfer(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/lbm.fbridge.v1.Msg/HoldTransfer", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).HoldTransfer(ctx, req.(*HoldTransferRequest)) - } - return interceptor(ctx, in, info, handler) +func (m *RemoveOperatorResponse) Reset() { *m = RemoveOperatorResponse{} } +func (m *RemoveOperatorResponse) String() string { return proto.CompactTextString(m) } +func (*RemoveOperatorResponse) ProtoMessage() {} +func (*RemoveOperatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{21} } - -func _Msg_ReleaseTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ReleaseTransferRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).ReleaseTransfer(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/lbm.fbridge.v1.Msg/ReleaseTransfer", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).ReleaseTransfer(ctx, req.(*ReleaseTransferRequest)) +func (m *RemoveOperatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RemoveOperatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RemoveOperatorResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return interceptor(ctx, in, info, handler) +} +func (m *RemoveOperatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RemoveOperatorResponse.Merge(m, src) +} +func (m *RemoveOperatorResponse) XXX_Size() int { + return m.Size() +} +func (m *RemoveOperatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RemoveOperatorResponse.DiscardUnknown(m) } -func _Msg_RemoveProvision_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(RemoveProvisionRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).RemoveProvision(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/lbm.fbridge.v1.Msg/RemoveProvision", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).RemoveProvision(ctx, req.(*RemoveProvisionRequest)) - } - return interceptor(ctx, in, info, handler) +var xxx_messageInfo_RemoveOperatorResponse proto.InternalMessageInfo + +// AddJudgeRequest is input values required for adding a judge +type AddJudgeRequest struct { + // the judge address to be added + Judge string `protobuf:"bytes,1,opt,name=judge,proto3" json:"judge,omitempty"` } -func _Msg_ClaimBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ClaimBatchRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).ClaimBatch(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/lbm.fbridge.v1.Msg/ClaimBatch", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).ClaimBatch(ctx, req.(*ClaimBatchRequest)) +func (m *AddJudgeRequest) Reset() { *m = AddJudgeRequest{} } +func (m *AddJudgeRequest) String() string { return proto.CompactTextString(m) } +func (*AddJudgeRequest) ProtoMessage() {} +func (*AddJudgeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{22} +} +func (m *AddJudgeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddJudgeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddJudgeRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return interceptor(ctx, in, info, handler) +} +func (m *AddJudgeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddJudgeRequest.Merge(m, src) +} +func (m *AddJudgeRequest) XXX_Size() int { + return m.Size() +} +func (m *AddJudgeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AddJudgeRequest.DiscardUnknown(m) } -func _Msg_Claim_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ClaimRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).Claim(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/lbm.fbridge.v1.Msg/Claim", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).Claim(ctx, req.(*ClaimRequest)) +var xxx_messageInfo_AddJudgeRequest proto.InternalMessageInfo + +func (m *AddJudgeRequest) GetJudge() string { + if m != nil { + return m.Judge } - return interceptor(ctx, in, info, handler) + return "" } -var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "lbm.fbridge.v1.Msg", - HandlerType: (*MsgServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "Transfer", - Handler: _Msg_Transfer_Handler, - }, - { - MethodName: "Provision", - Handler: _Msg_Provision_Handler, - }, - { - MethodName: "HoldTransfer", - Handler: _Msg_HoldTransfer_Handler, - }, - { - MethodName: "ReleaseTransfer", - Handler: _Msg_ReleaseTransfer_Handler, - }, - { - MethodName: "RemoveProvision", - Handler: _Msg_RemoveProvision_Handler, - }, - { - MethodName: "ClaimBatch", - Handler: _Msg_ClaimBatch_Handler, - }, - { - MethodName: "Claim", - Handler: _Msg_Claim_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "lbm/fbridge/v1/tx.proto", +type AddJudgeResponse struct { } -func (m *TransferRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *AddJudgeResponse) Reset() { *m = AddJudgeResponse{} } +func (m *AddJudgeResponse) String() string { return proto.CompactTextString(m) } +func (*AddJudgeResponse) ProtoMessage() {} +func (*AddJudgeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{23} +} +func (m *AddJudgeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AddJudgeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AddJudgeResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil +} +func (m *AddJudgeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddJudgeResponse.Merge(m, src) +} +func (m *AddJudgeResponse) XXX_Size() int { + return m.Size() +} +func (m *AddJudgeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AddJudgeResponse.DiscardUnknown(m) } -func (m *TransferRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +var xxx_messageInfo_AddJudgeResponse proto.InternalMessageInfo + +// RemoveJudgeRequest is input values required for removing a judge +type RemoveJudgeRequest struct { + // the judge address to be removed + Judge string `protobuf:"bytes,1,opt,name=judge,proto3" json:"judge,omitempty"` } -func (m *TransferRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.Amount.Size() - i -= size - if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { - return 0, err +func (m *RemoveJudgeRequest) Reset() { *m = RemoveJudgeRequest{} } +func (m *RemoveJudgeRequest) String() string { return proto.CompactTextString(m) } +func (*RemoveJudgeRequest) ProtoMessage() {} +func (*RemoveJudgeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{24} +} +func (m *RemoveJudgeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RemoveJudgeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RemoveJudgeRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if len(m.Receiver) > 0 { - i -= len(m.Receiver) - copy(dAtA[i:], m.Receiver) - i = encodeVarintTx(dAtA, i, uint64(len(m.Receiver))) - i-- - dAtA[i] = 0x12 - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *RemoveJudgeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RemoveJudgeRequest.Merge(m, src) +} +func (m *RemoveJudgeRequest) XXX_Size() int { + return m.Size() +} +func (m *RemoveJudgeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RemoveJudgeRequest.DiscardUnknown(m) } -func (m *TransferResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_RemoveJudgeRequest proto.InternalMessageInfo + +func (m *RemoveJudgeRequest) GetJudge() string { + if m != nil { + return m.Judge } - return dAtA[:n], nil + return "" } -func (m *TransferResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type RemoveJudgeResponse struct { } -func (m *TransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (m *RemoveJudgeResponse) Reset() { *m = RemoveJudgeResponse{} } +func (m *RemoveJudgeResponse) String() string { return proto.CompactTextString(m) } +func (*RemoveJudgeResponse) ProtoMessage() {} +func (*RemoveJudgeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_54a336bc5ea063bb, []int{25} } - -func (m *ProvisionRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *RemoveJudgeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RemoveJudgeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RemoveJudgeResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil +} +func (m *RemoveJudgeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RemoveJudgeResponse.Merge(m, src) +} +func (m *RemoveJudgeResponse) XXX_Size() int { + return m.Size() +} +func (m *RemoveJudgeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RemoveJudgeResponse.DiscardUnknown(m) } -func (m *ProvisionRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +var xxx_messageInfo_RemoveJudgeResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*TransferRequest)(nil), "lbm.fbridge.v1.TransferRequest") + proto.RegisterType((*TransferResponse)(nil), "lbm.fbridge.v1.TransferResponse") + proto.RegisterType((*ProvisionRequest)(nil), "lbm.fbridge.v1.ProvisionRequest") + proto.RegisterType((*ProvisionResponse)(nil), "lbm.fbridge.v1.ProvisionResponse") + proto.RegisterType((*HoldTransferRequest)(nil), "lbm.fbridge.v1.HoldTransferRequest") + proto.RegisterType((*HoldTransferResponse)(nil), "lbm.fbridge.v1.HoldTransferResponse") + proto.RegisterType((*ReleaseTransferRequest)(nil), "lbm.fbridge.v1.ReleaseTransferRequest") + proto.RegisterType((*ReleaseTransferResponse)(nil), "lbm.fbridge.v1.ReleaseTransferResponse") + proto.RegisterType((*RemoveProvisionRequest)(nil), "lbm.fbridge.v1.RemoveProvisionRequest") + proto.RegisterType((*RemoveProvisionResponse)(nil), "lbm.fbridge.v1.RemoveProvisionResponse") + proto.RegisterType((*ClaimBatchRequest)(nil), "lbm.fbridge.v1.ClaimBatchRequest") + proto.RegisterType((*ClaimBatchResponse)(nil), "lbm.fbridge.v1.ClaimBatchResponse") + proto.RegisterType((*ClaimRequest)(nil), "lbm.fbridge.v1.ClaimRequest") + proto.RegisterType((*ClaimResponse)(nil), "lbm.fbridge.v1.ClaimResponse") + proto.RegisterType((*AddGuardianRequest)(nil), "lbm.fbridge.v1.AddGuardianRequest") + proto.RegisterType((*AddGuardianResponse)(nil), "lbm.fbridge.v1.AddGuardianResponse") + proto.RegisterType((*RemoveGuardianRequest)(nil), "lbm.fbridge.v1.RemoveGuardianRequest") + proto.RegisterType((*RemoveGuardianResponse)(nil), "lbm.fbridge.v1.RemoveGuardianResponse") + proto.RegisterType((*AddOperatorRequest)(nil), "lbm.fbridge.v1.AddOperatorRequest") + proto.RegisterType((*AddOperatorResponse)(nil), "lbm.fbridge.v1.AddOperatorResponse") + proto.RegisterType((*RemoveOperatorRequest)(nil), "lbm.fbridge.v1.RemoveOperatorRequest") + proto.RegisterType((*RemoveOperatorResponse)(nil), "lbm.fbridge.v1.RemoveOperatorResponse") + proto.RegisterType((*AddJudgeRequest)(nil), "lbm.fbridge.v1.AddJudgeRequest") + proto.RegisterType((*AddJudgeResponse)(nil), "lbm.fbridge.v1.AddJudgeResponse") + proto.RegisterType((*RemoveJudgeRequest)(nil), "lbm.fbridge.v1.RemoveJudgeRequest") + proto.RegisterType((*RemoveJudgeResponse)(nil), "lbm.fbridge.v1.RemoveJudgeResponse") } -func (m *ProvisionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.Amount.Size() - i -= size - if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - if len(m.Receiver) > 0 { - i -= len(m.Receiver) - copy(dAtA[i:], m.Receiver) - i = encodeVarintTx(dAtA, i, uint64(len(m.Receiver))) - i-- - dAtA[i] = 0x1a - } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0x12 - } - if m.Seq != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Seq)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil +func init() { proto.RegisterFile("lbm/fbridge/v1/tx.proto", fileDescriptor_54a336bc5ea063bb) } + +var fileDescriptor_54a336bc5ea063bb = []byte{ + // 716 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x96, 0xef, 0x4e, 0xd3, 0x50, + 0x18, 0xc6, 0x57, 0x06, 0x64, 0xbc, 0x22, 0x83, 0xb3, 0x01, 0xb3, 0x91, 0x81, 0x45, 0xc1, 0x90, + 0xd8, 0xf2, 0xe7, 0x0a, 0x40, 0xe3, 0x1f, 0x12, 0x22, 0x99, 0xc6, 0x44, 0xbf, 0x90, 0x6e, 0x3d, + 0x94, 0xea, 0xda, 0x33, 0x7a, 0xba, 0x65, 0xde, 0x85, 0xde, 0x83, 0x17, 0xc3, 0x47, 0x3e, 0x1a, + 0x3f, 0x10, 0xc3, 0xae, 0xc3, 0xc4, 0xb4, 0x3d, 0xed, 0xda, 0x73, 0xda, 0x55, 0xe2, 0xb7, 0x9e, + 0x9e, 0xe7, 0xfd, 0x9d, 0x67, 0x6f, 0xce, 0xf3, 0xae, 0xb0, 0xda, 0x6d, 0xdb, 0xda, 0x79, 0xdb, + 0xb5, 0x0c, 0x13, 0x6b, 0x83, 0x3d, 0xcd, 0x1b, 0xaa, 0x3d, 0x97, 0x78, 0x04, 0x2d, 0x74, 0xdb, + 0xb6, 0xca, 0x36, 0xd4, 0xc1, 0x9e, 0x5c, 0x37, 0x89, 0x49, 0x82, 0x2d, 0xcd, 0x7f, 0x0a, 0x55, + 0xca, 0x77, 0x09, 0xaa, 0xef, 0x5d, 0xdd, 0xa1, 0xe7, 0xd8, 0x6d, 0xe1, 0xcb, 0x3e, 0xa6, 0x1e, + 0x5a, 0x81, 0x59, 0x8a, 0x1d, 0x03, 0xbb, 0x0d, 0x69, 0x43, 0x7a, 0x3a, 0xd7, 0x62, 0x2b, 0x24, + 0x43, 0xc5, 0xc5, 0x1d, 0x6c, 0x0d, 0xb0, 0xdb, 0x98, 0x0a, 0x76, 0xe2, 0x35, 0x3a, 0x86, 0x59, + 0xdd, 0x26, 0x7d, 0xc7, 0x6b, 0x94, 0xfd, 0x9d, 0xa3, 0xfd, 0xab, 0x9b, 0xf5, 0xd2, 0xaf, 0x9b, + 0xf5, 0x1d, 0xd3, 0xf2, 0x2e, 0xfa, 0x6d, 0xb5, 0x43, 0x6c, 0xed, 0xa5, 0xe5, 0xd0, 0xce, 0x85, + 0xa5, 0x6b, 0xe7, 0xec, 0xe1, 0x19, 0x35, 0xbe, 0x68, 0xde, 0xd7, 0x1e, 0xa6, 0xea, 0x1b, 0xc7, + 0x6b, 0x31, 0x82, 0x82, 0x60, 0x71, 0x6c, 0x89, 0xf6, 0x88, 0x43, 0xb1, 0xf2, 0x43, 0x82, 0xc5, + 0x53, 0x97, 0x0c, 0x2c, 0x6a, 0x11, 0x27, 0x32, 0xba, 0x08, 0x65, 0x8a, 0x2f, 0x03, 0x97, 0xd3, + 0x2d, 0xff, 0x31, 0x61, 0x7d, 0x2a, 0xd7, 0x7a, 0x39, 0xd7, 0xfa, 0xf4, 0x7f, 0x5b, 0xaf, 0xc1, + 0x52, 0xc2, 0x25, 0xf3, 0xbe, 0x0d, 0xb5, 0xd7, 0xa4, 0x6b, 0xf0, 0x6d, 0x16, 0xdc, 0x2b, 0x2b, + 0x50, 0x4f, 0x0b, 0x19, 0x60, 0x07, 0x56, 0x5a, 0xb8, 0x8b, 0x75, 0x8a, 0x8b, 0x19, 0x0f, 0x60, + 0x55, 0xd0, 0x26, 0x31, 0x36, 0x19, 0xe0, 0xe2, 0x46, 0x86, 0x18, 0x4e, 0xcb, 0x30, 0xfb, 0xb0, + 0xf4, 0xbc, 0xab, 0x5b, 0xf6, 0x91, 0xee, 0x75, 0x2e, 0x22, 0xc2, 0x1a, 0x80, 0xad, 0x0f, 0xcf, + 0x3a, 0xfe, 0x06, 0x65, 0xa0, 0x39, 0x5b, 0x1f, 0x06, 0x4a, 0xaa, 0xd4, 0x01, 0x25, 0x6b, 0x18, + 0x69, 0x03, 0xe6, 0x83, 0xb7, 0xf9, 0x36, 0xaa, 0x70, 0x9f, 0x29, 0x58, 0xc9, 0x2e, 0xa0, 0x43, + 0xc3, 0x78, 0xd5, 0xd7, 0x5d, 0xc3, 0xd2, 0x63, 0xff, 0x32, 0x54, 0x4c, 0xf6, 0x8a, 0xdd, 0xd9, + 0x78, 0xad, 0x2c, 0x43, 0x2d, 0x55, 0xc1, 0x40, 0x07, 0xb0, 0x1c, 0xfe, 0xc0, 0xbb, 0xb0, 0x1a, + 0x51, 0x07, 0x05, 0x5c, 0xe8, 0xeb, 0x6d, 0x0f, 0xbb, 0xba, 0x47, 0xdc, 0x04, 0x8b, 0xb0, 0x57, + 0x11, 0x2b, 0x5a, 0x33, 0x5f, 0xe3, 0x0a, 0xde, 0xd7, 0x5d, 0x58, 0xb1, 0x2f, 0x01, 0xb7, 0x0d, + 0xd5, 0x43, 0xc3, 0x38, 0xee, 0x1b, 0x26, 0x8e, 0x40, 0x75, 0x98, 0xf9, 0xec, 0xaf, 0x19, 0x25, + 0x5c, 0xf8, 0xa1, 0x1b, 0x0b, 0xe3, 0x0b, 0x83, 0x42, 0xec, 0x3f, 0xd4, 0x2f, 0x43, 0x2d, 0xa5, + 0x0d, 0x11, 0xfb, 0x7f, 0x2a, 0x50, 0x3e, 0xa1, 0x26, 0x3a, 0x81, 0x4a, 0x74, 0x1f, 0xd1, 0xba, + 0x9a, 0x1e, 0x4d, 0x2a, 0x77, 0xab, 0xe5, 0x8d, 0x7c, 0x41, 0x88, 0x45, 0xa7, 0x30, 0x17, 0x5f, + 0x4c, 0x24, 0xc8, 0xf9, 0xfb, 0x2d, 0x3f, 0x9a, 0xa0, 0x60, 0xc4, 0x8f, 0x30, 0x9f, 0xcc, 0x1e, + 0xda, 0xe4, 0x4b, 0x32, 0x22, 0x2c, 0x3f, 0x9e, 0x2c, 0x62, 0xe8, 0x36, 0x54, 0xb9, 0x48, 0xa2, + 0x2d, 0xbe, 0x30, 0x3b, 0xdf, 0xf2, 0x76, 0xa1, 0x2e, 0x79, 0x46, 0x2a, 0xaf, 0x59, 0x67, 0x64, + 0x85, 0x3f, 0xeb, 0x8c, 0xcc, 0xe0, 0xa3, 0x77, 0x00, 0xe3, 0x10, 0x23, 0xa1, 0xa7, 0xc2, 0x50, + 0x90, 0x95, 0x49, 0x12, 0x06, 0x7d, 0x01, 0x33, 0xc1, 0x5b, 0xf4, 0x30, 0x53, 0x1c, 0xa1, 0xd6, + 0x72, 0x76, 0x19, 0xe5, 0x03, 0xdc, 0x4b, 0x84, 0x1c, 0x09, 0x07, 0x8b, 0x33, 0x43, 0xde, 0x9c, + 0xa8, 0x61, 0xdc, 0x33, 0x58, 0x48, 0x07, 0x1e, 0x3d, 0xc9, 0xee, 0x16, 0x4f, 0xdf, 0x2a, 0x92, + 0xa5, 0x8c, 0x47, 0xb1, 0xcd, 0x34, 0xce, 0x0d, 0x82, 0x4c, 0xe3, 0x7c, 0xee, 0xc7, 0xc6, 0x63, + 0x74, 0x8e, 0x71, 0x9e, 0xbe, 0x55, 0x24, 0x63, 0x07, 0x9c, 0x40, 0x25, 0x9a, 0x17, 0x62, 0xa0, + 0xb9, 0x91, 0x23, 0x06, 0x9a, 0x1f, 0x35, 0x7e, 0x1f, 0x12, 0xe3, 0x43, 0xec, 0x83, 0x38, 0x87, + 0xc4, 0x3e, 0x64, 0xcc, 0x9f, 0xa3, 0xe3, 0xab, 0xdb, 0xa6, 0x74, 0x7d, 0xdb, 0x94, 0x7e, 0xdf, + 0x36, 0xa5, 0x6f, 0xa3, 0x66, 0xe9, 0x7a, 0xd4, 0x2c, 0xfd, 0x1c, 0x35, 0x4b, 0x9f, 0x76, 0x0b, + 0xff, 0xde, 0x87, 0xf1, 0x77, 0x55, 0xf0, 0x47, 0xdf, 0x9e, 0x0d, 0x3e, 0x99, 0x0e, 0xfe, 0x06, + 0x00, 0x00, 0xff, 0xff, 0xe3, 0xc7, 0x5c, 0xd8, 0x73, 0x09, 0x00, 0x00, } -func (m *ProvisionResponse) 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 +// 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 { + // Submit a transfer request to the bridge module. + Transfer(ctx context.Context, in *TransferRequest, opts ...grpc.CallOption) (*TransferResponse, error) + // Submit a provision to the bridge module. + Provision(ctx context.Context, in *ProvisionRequest, opts ...grpc.CallOption) (*ProvisionResponse, error) + // Set the time lock value from default value to uint64.max for specific confirmed provision. + HoldTransfer(ctx context.Context, in *HoldTransferRequest, opts ...grpc.CallOption) (*HoldTransferResponse, error) + // Set the time lock value to 0 for specific confirmed provision. + ReleaseTransfer(ctx context.Context, in *ReleaseTransferRequest, opts ...grpc.CallOption) (*ReleaseTransferResponse, error) + // Remove a specific confirmed provision (reset for specific sequence number). + RemoveProvision(ctx context.Context, in *RemoveProvisionRequest, opts ...grpc.CallOption) (*RemoveProvisionResponse, error) + // ClaimBatch processes the claiming of multiple claimable provisions in a single operation + ClaimBatch(ctx context.Context, in *ClaimBatchRequest, opts ...grpc.CallOption) (*ClaimBatchResponse, error) + // Claim processes the claiming of a provision with a specific sequence number + Claim(ctx context.Context, in *ClaimRequest, opts ...grpc.CallOption) (*ClaimResponse, error) + // AddGuardian adds a guardian to the bridge module. + AddGuardian(ctx context.Context, in *AddGuardianRequest, opts ...grpc.CallOption) (*AddGuardianResponse, error) + // RemoveGuardian removes a guardian from the bridge module. + RemoveGuardian(ctx context.Context, in *RemoveGuardianRequest, opts ...grpc.CallOption) (*RemoveGuardianResponse, error) + // AddOperator adds an operator to the bridge module. + AddOperator(ctx context.Context, in *AddOperatorRequest, opts ...grpc.CallOption) (*AddOperatorResponse, error) + // RemoveOperator removes an operator from the bridge module. + RemoveOperator(ctx context.Context, in *RemoveOperatorRequest, opts ...grpc.CallOption) (*RemoveOperatorResponse, error) + // AddJudge adds a judge to the bridge module. + AddJudge(ctx context.Context, in *AddJudgeRequest, opts ...grpc.CallOption) (*AddJudgeResponse, error) + // RemoveJudge removes a judge from the bridge module. + RemoveJudge(ctx context.Context, in *RemoveJudgeRequest, opts ...grpc.CallOption) (*RemoveJudgeResponse, error) } -func (m *ProvisionResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type msgClient struct { + cc grpc1.ClientConn } -func (m *ProvisionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} } -func (m *HoldTransferRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) Transfer(ctx context.Context, in *TransferRequest, opts ...grpc.CallOption) (*TransferResponse, error) { + out := new(TransferResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/Transfer", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *HoldTransferRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + return out, nil } -func (m *HoldTransferRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Seq != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Seq)) - i-- - dAtA[i] = 0x8 +func (c *msgClient) Provision(ctx context.Context, in *ProvisionRequest, opts ...grpc.CallOption) (*ProvisionResponse, error) { + out := new(ProvisionResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/Provision", in, out, opts...) + if err != nil { + return nil, err } - return len(dAtA) - i, nil + return out, nil } -func (m *HoldTransferResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) HoldTransfer(ctx context.Context, in *HoldTransferRequest, opts ...grpc.CallOption) (*HoldTransferResponse, error) { + out := new(HoldTransferResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/HoldTransfer", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *HoldTransferResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) ReleaseTransfer(ctx context.Context, in *ReleaseTransferRequest, opts ...grpc.CallOption) (*ReleaseTransferResponse, error) { + out := new(ReleaseTransferResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/ReleaseTransfer", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *HoldTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (c *msgClient) RemoveProvision(ctx context.Context, in *RemoveProvisionRequest, opts ...grpc.CallOption) (*RemoveProvisionResponse, error) { + out := new(RemoveProvisionResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/RemoveProvision", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *ReleaseTransferRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) ClaimBatch(ctx context.Context, in *ClaimBatchRequest, opts ...grpc.CallOption) (*ClaimBatchResponse, error) { + out := new(ClaimBatchResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/ClaimBatch", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *ReleaseTransferRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) Claim(ctx context.Context, in *ClaimRequest, opts ...grpc.CallOption) (*ClaimResponse, error) { + out := new(ClaimResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/Claim", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *ReleaseTransferRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Seq != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Seq)) - i-- - dAtA[i] = 0x8 +func (c *msgClient) AddGuardian(ctx context.Context, in *AddGuardianRequest, opts ...grpc.CallOption) (*AddGuardianResponse, error) { + out := new(AddGuardianResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/AddGuardian", in, out, opts...) + if err != nil { + return nil, err } - return len(dAtA) - i, nil + return out, nil } -func (m *ReleaseTransferResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) RemoveGuardian(ctx context.Context, in *RemoveGuardianRequest, opts ...grpc.CallOption) (*RemoveGuardianResponse, error) { + out := new(RemoveGuardianResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/RemoveGuardian", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *ReleaseTransferResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) AddOperator(ctx context.Context, in *AddOperatorRequest, opts ...grpc.CallOption) (*AddOperatorResponse, error) { + out := new(AddOperatorResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/AddOperator", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *ReleaseTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (c *msgClient) RemoveOperator(ctx context.Context, in *RemoveOperatorRequest, opts ...grpc.CallOption) (*RemoveOperatorResponse, error) { + out := new(RemoveOperatorResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/RemoveOperator", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *RemoveProvisionRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) AddJudge(ctx context.Context, in *AddJudgeRequest, opts ...grpc.CallOption) (*AddJudgeResponse, error) { + out := new(AddJudgeResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/AddJudge", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *RemoveProvisionRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) RemoveJudge(ctx context.Context, in *RemoveJudgeRequest, opts ...grpc.CallOption) (*RemoveJudgeResponse, error) { + out := new(RemoveJudgeResponse) + err := c.cc.Invoke(ctx, "/lbm.fbridge.v1.Msg/RemoveJudge", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (m *RemoveProvisionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Seq != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Seq)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil +// MsgServer is the server API for Msg service. +type MsgServer interface { + // Submit a transfer request to the bridge module. + Transfer(context.Context, *TransferRequest) (*TransferResponse, error) + // Submit a provision to the bridge module. + Provision(context.Context, *ProvisionRequest) (*ProvisionResponse, error) + // Set the time lock value from default value to uint64.max for specific confirmed provision. + HoldTransfer(context.Context, *HoldTransferRequest) (*HoldTransferResponse, error) + // Set the time lock value to 0 for specific confirmed provision. + ReleaseTransfer(context.Context, *ReleaseTransferRequest) (*ReleaseTransferResponse, error) + // Remove a specific confirmed provision (reset for specific sequence number). + RemoveProvision(context.Context, *RemoveProvisionRequest) (*RemoveProvisionResponse, error) + // ClaimBatch processes the claiming of multiple claimable provisions in a single operation + ClaimBatch(context.Context, *ClaimBatchRequest) (*ClaimBatchResponse, error) + // Claim processes the claiming of a provision with a specific sequence number + Claim(context.Context, *ClaimRequest) (*ClaimResponse, error) + // AddGuardian adds a guardian to the bridge module. + AddGuardian(context.Context, *AddGuardianRequest) (*AddGuardianResponse, error) + // RemoveGuardian removes a guardian from the bridge module. + RemoveGuardian(context.Context, *RemoveGuardianRequest) (*RemoveGuardianResponse, error) + // AddOperator adds an operator to the bridge module. + AddOperator(context.Context, *AddOperatorRequest) (*AddOperatorResponse, error) + // RemoveOperator removes an operator from the bridge module. + RemoveOperator(context.Context, *RemoveOperatorRequest) (*RemoveOperatorResponse, error) + // AddJudge adds a judge to the bridge module. + AddJudge(context.Context, *AddJudgeRequest) (*AddJudgeResponse, error) + // RemoveJudge removes a judge from the bridge module. + RemoveJudge(context.Context, *RemoveJudgeRequest) (*RemoveJudgeResponse, error) } -func (m *RemoveProvisionResponse) 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 +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { } -func (m *RemoveProvisionResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) Transfer(ctx context.Context, req *TransferRequest) (*TransferResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Transfer not implemented") } - -func (m *RemoveProvisionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (*UnimplementedMsgServer) Provision(ctx context.Context, req *ProvisionRequest) (*ProvisionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Provision not implemented") } - -func (m *ClaimBatchRequest) 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 (*UnimplementedMsgServer) HoldTransfer(ctx context.Context, req *HoldTransferRequest) (*HoldTransferResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HoldTransfer not implemented") } - -func (m *ClaimBatchRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) ReleaseTransfer(ctx context.Context, req *ReleaseTransferRequest) (*ReleaseTransferResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReleaseTransfer not implemented") } - -func (m *ClaimBatchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.MaxClaims != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.MaxClaims)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil +func (*UnimplementedMsgServer) RemoveProvision(ctx context.Context, req *RemoveProvisionRequest) (*RemoveProvisionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RemoveProvision not implemented") } - -func (m *ClaimBatchResponse) 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 (*UnimplementedMsgServer) ClaimBatch(ctx context.Context, req *ClaimBatchRequest) (*ClaimBatchResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClaimBatch not implemented") } - -func (m *ClaimBatchResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) Claim(ctx context.Context, req *ClaimRequest) (*ClaimResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Claim not implemented") } - -func (m *ClaimBatchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func (*UnimplementedMsgServer) AddGuardian(ctx context.Context, req *AddGuardianRequest) (*AddGuardianResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AddGuardian not implemented") } - -func (m *ClaimRequest) 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 (*UnimplementedMsgServer) RemoveGuardian(ctx context.Context, req *RemoveGuardianRequest) (*RemoveGuardianResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RemoveGuardian not implemented") } - -func (m *ClaimRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) AddOperator(ctx context.Context, req *AddOperatorRequest) (*AddOperatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AddOperator not implemented") } - -func (m *ClaimRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Seq != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Seq)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil +func (*UnimplementedMsgServer) RemoveOperator(ctx context.Context, req *RemoveOperatorRequest) (*RemoveOperatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RemoveOperator not implemented") } - -func (m *ClaimResponse) 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 (*UnimplementedMsgServer) AddJudge(ctx context.Context, req *AddJudgeRequest) (*AddJudgeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AddJudge not implemented") } - -func (m *ClaimResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) RemoveJudge(ctx context.Context, req *RemoveJudgeRequest) (*RemoveJudgeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RemoveJudge not implemented") } -func (m *ClaimResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) } -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++ +func _Msg_Transfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TransferRequest) + if err := dec(in); err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base -} -func (m *TransferRequest) Size() (n int) { - if m == nil { - return 0 + if interceptor == nil { + return srv.(MsgServer).Transfer(ctx, in) } - var l int - _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/Transfer", } - l = len(m.Receiver) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Transfer(ctx, req.(*TransferRequest)) } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return interceptor(ctx, in, info, handler) } -func (m *TransferResponse) Size() (n int) { - if m == nil { - return 0 +func _Msg_Provision_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProvisionRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - return n + if interceptor == nil { + return srv.(MsgServer).Provision(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/Provision", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Provision(ctx, req.(*ProvisionRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *ProvisionRequest) Size() (n int) { - if m == nil { - return 0 +func _Msg_HoldTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HoldTransferRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - if m.Seq != 0 { - n += 1 + sovTx(uint64(m.Seq)) + if interceptor == nil { + return srv.(MsgServer).HoldTransfer(ctx, in) } - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/HoldTransfer", } - l = len(m.Receiver) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).HoldTransfer(ctx, req.(*HoldTransferRequest)) } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return interceptor(ctx, in, info, handler) } -func (m *ProvisionResponse) Size() (n int) { - if m == nil { - return 0 +func _Msg_ReleaseTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReleaseTransferRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - return n + if interceptor == nil { + return srv.(MsgServer).ReleaseTransfer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/ReleaseTransfer", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ReleaseTransfer(ctx, req.(*ReleaseTransferRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *HoldTransferRequest) Size() (n int) { - if m == nil { - return 0 +func _Msg_RemoveProvision_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RemoveProvisionRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - if m.Seq != 0 { - n += 1 + sovTx(uint64(m.Seq)) + if interceptor == nil { + return srv.(MsgServer).RemoveProvision(ctx, in) } - return n + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/RemoveProvision", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RemoveProvision(ctx, req.(*RemoveProvisionRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *HoldTransferResponse) Size() (n int) { - if m == nil { - return 0 +func _Msg_ClaimBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ClaimBatchRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - return n + if interceptor == nil { + return srv.(MsgServer).ClaimBatch(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/ClaimBatch", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ClaimBatch(ctx, req.(*ClaimBatchRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *ReleaseTransferRequest) Size() (n int) { - if m == nil { - return 0 +func _Msg_Claim_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ClaimRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - if m.Seq != 0 { - n += 1 + sovTx(uint64(m.Seq)) + if interceptor == nil { + return srv.(MsgServer).Claim(ctx, in) } - return n + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/Claim", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Claim(ctx, req.(*ClaimRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *ReleaseTransferResponse) Size() (n int) { - if m == nil { - return 0 +func _Msg_AddGuardian_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddGuardianRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - return n + if interceptor == nil { + return srv.(MsgServer).AddGuardian(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/AddGuardian", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).AddGuardian(ctx, req.(*AddGuardianRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *RemoveProvisionRequest) Size() (n int) { - if m == nil { - return 0 +func _Msg_RemoveGuardian_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RemoveGuardianRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - if m.Seq != 0 { - n += 1 + sovTx(uint64(m.Seq)) + if interceptor == nil { + return srv.(MsgServer).RemoveGuardian(ctx, in) } - return n + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/RemoveGuardian", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RemoveGuardian(ctx, req.(*RemoveGuardianRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *RemoveProvisionResponse) Size() (n int) { - if m == nil { - return 0 +func _Msg_AddOperator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddOperatorRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - return n + if interceptor == nil { + return srv.(MsgServer).AddOperator(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/AddOperator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).AddOperator(ctx, req.(*AddOperatorRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *ClaimBatchRequest) Size() (n int) { - if m == nil { - return 0 +func _Msg_RemoveOperator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RemoveOperatorRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - if m.MaxClaims != 0 { - n += 1 + sovTx(uint64(m.MaxClaims)) + if interceptor == nil { + return srv.(MsgServer).RemoveOperator(ctx, in) } - return n + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/RemoveOperator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RemoveOperator(ctx, req.(*RemoveOperatorRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *ClaimBatchResponse) Size() (n int) { - if m == nil { - return 0 +func _Msg_AddJudge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddJudgeRequest) + if err := dec(in); err != nil { + return nil, err } - var l int - _ = l - return n + if interceptor == nil { + return srv.(MsgServer).AddJudge(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/AddJudge", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).AddJudge(ctx, req.(*AddJudgeRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *ClaimRequest) Size() (n int) { - if m == nil { - return 0 +func _Msg_RemoveJudge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RemoveJudgeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RemoveJudge(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lbm.fbridge.v1.Msg/RemoveJudge", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RemoveJudge(ctx, req.(*RemoveJudgeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "lbm.fbridge.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Transfer", + Handler: _Msg_Transfer_Handler, + }, + { + MethodName: "Provision", + Handler: _Msg_Provision_Handler, + }, + { + MethodName: "HoldTransfer", + Handler: _Msg_HoldTransfer_Handler, + }, + { + MethodName: "ReleaseTransfer", + Handler: _Msg_ReleaseTransfer_Handler, + }, + { + MethodName: "RemoveProvision", + Handler: _Msg_RemoveProvision_Handler, + }, + { + MethodName: "ClaimBatch", + Handler: _Msg_ClaimBatch_Handler, + }, + { + MethodName: "Claim", + Handler: _Msg_Claim_Handler, + }, + { + MethodName: "AddGuardian", + Handler: _Msg_AddGuardian_Handler, + }, + { + MethodName: "RemoveGuardian", + Handler: _Msg_RemoveGuardian_Handler, + }, + { + MethodName: "AddOperator", + Handler: _Msg_AddOperator_Handler, + }, + { + MethodName: "RemoveOperator", + Handler: _Msg_RemoveOperator_Handler, + }, + { + MethodName: "AddJudge", + Handler: _Msg_AddJudge_Handler, + }, + { + MethodName: "RemoveJudge", + Handler: _Msg_RemoveJudge_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "lbm/fbridge/v1/tx.proto", +} + +func (m *TransferRequest) 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 *TransferRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TransferRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Seq != 0 { - n += 1 + sovTx(uint64(m.Seq)) + { + size := m.Amount.Size() + i -= size + if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.Receiver) > 0 { + i -= len(m.Receiver) + copy(dAtA[i:], m.Receiver) + i = encodeVarintTx(dAtA, i, uint64(len(m.Receiver))) + i-- + dAtA[i] = 0x12 + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TransferResponse) 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 *TransferResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *ProvisionRequest) 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 *ProvisionRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProvisionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Amount.Size() + i -= size + if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + if len(m.Receiver) > 0 { + i -= len(m.Receiver) + copy(dAtA[i:], m.Receiver) + i = encodeVarintTx(dAtA, i, uint64(len(m.Receiver))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0x12 + } + if m.Seq != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Seq)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ProvisionResponse) 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 *ProvisionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ProvisionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *HoldTransferRequest) 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 *HoldTransferRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HoldTransferRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Seq != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Seq)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *HoldTransferResponse) 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 *HoldTransferResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HoldTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *ReleaseTransferRequest) 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 *ReleaseTransferRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReleaseTransferRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Seq != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Seq)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ReleaseTransferResponse) 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 *ReleaseTransferResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReleaseTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *RemoveProvisionRequest) 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 *RemoveProvisionRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RemoveProvisionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Seq != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Seq)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *RemoveProvisionResponse) 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 *RemoveProvisionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RemoveProvisionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *ClaimBatchRequest) 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 *ClaimBatchRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClaimBatchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MaxClaims != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.MaxClaims)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ClaimBatchResponse) 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 *ClaimBatchResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClaimBatchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *ClaimRequest) 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 *ClaimRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClaimRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Seq != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Seq)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ClaimResponse) 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 *ClaimResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClaimResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *AddGuardianRequest) 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 *AddGuardianRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddGuardianRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Guardian) > 0 { + i -= len(m.Guardian) + copy(dAtA[i:], m.Guardian) + i = encodeVarintTx(dAtA, i, uint64(len(m.Guardian))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AddGuardianResponse) 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 *AddGuardianResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddGuardianResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *RemoveGuardianRequest) 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 *RemoveGuardianRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RemoveGuardianRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Guardian) > 0 { + i -= len(m.Guardian) + copy(dAtA[i:], m.Guardian) + i = encodeVarintTx(dAtA, i, uint64(len(m.Guardian))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RemoveGuardianResponse) 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 *RemoveGuardianResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RemoveGuardianResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *AddOperatorRequest) 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 *AddOperatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddOperatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Operator) > 0 { + i -= len(m.Operator) + copy(dAtA[i:], m.Operator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Operator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AddOperatorResponse) 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 *AddOperatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddOperatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *RemoveOperatorRequest) 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 *RemoveOperatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RemoveOperatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Operator) > 0 { + i -= len(m.Operator) + copy(dAtA[i:], m.Operator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Operator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RemoveOperatorResponse) 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 *RemoveOperatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RemoveOperatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *AddJudgeRequest) 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 *AddJudgeRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddJudgeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Judge) > 0 { + i -= len(m.Judge) + copy(dAtA[i:], m.Judge) + i = encodeVarintTx(dAtA, i, uint64(len(m.Judge))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AddJudgeResponse) 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 *AddJudgeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AddJudgeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *RemoveJudgeRequest) 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 *RemoveJudgeRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RemoveJudgeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Judge) > 0 { + i -= len(m.Judge) + copy(dAtA[i:], m.Judge) + i = encodeVarintTx(dAtA, i, uint64(len(m.Judge))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RemoveJudgeResponse) 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 *RemoveJudgeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RemoveJudgeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + 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 *TransferRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Receiver) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *TransferResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ProvisionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Seq != 0 { + n += 1 + sovTx(uint64(m.Seq)) + } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Receiver) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *ProvisionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *HoldTransferRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Seq != 0 { + n += 1 + sovTx(uint64(m.Seq)) + } + return n +} + +func (m *HoldTransferResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ReleaseTransferRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Seq != 0 { + n += 1 + sovTx(uint64(m.Seq)) + } + return n +} + +func (m *ReleaseTransferResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *RemoveProvisionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Seq != 0 { + n += 1 + sovTx(uint64(m.Seq)) + } + return n +} + +func (m *RemoveProvisionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ClaimBatchRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MaxClaims != 0 { + n += 1 + sovTx(uint64(m.MaxClaims)) + } + return n +} + +func (m *ClaimBatchResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ClaimRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Seq != 0 { + n += 1 + sovTx(uint64(m.Seq)) + } + return n +} + +func (m *ClaimResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *AddGuardianRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Guardian) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *AddGuardianResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *RemoveGuardianRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Guardian) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *RemoveGuardianResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *AddOperatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Operator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *AddOperatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *RemoveOperatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Operator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *RemoveOperatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *AddJudgeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Judge) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *AddJudgeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *RemoveJudgeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Judge) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *RemoveJudgeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = 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 *TransferRequest) 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: TransferRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TransferRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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 + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TransferResponse) 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: TransferResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TransferResponse: 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 *ProvisionRequest) 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: ProvisionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProvisionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) + } + m.Seq = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Seq |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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 + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProvisionResponse) 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: ProvisionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProvisionResponse: 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 *HoldTransferRequest) 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: HoldTransferRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HoldTransferRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) + } + m.Seq = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Seq |= 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 *HoldTransferResponse) 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: HoldTransferResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HoldTransferResponse: 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 *ReleaseTransferRequest) 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: ReleaseTransferRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReleaseTransferRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) + } + m.Seq = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Seq |= 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 *ReleaseTransferResponse) 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: ReleaseTransferResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReleaseTransferResponse: 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 + } } - return n -} -func (m *ClaimResponse) Size() (n int) { - if m == nil { - return 0 + if iNdEx > l { + return io.ErrUnexpectedEOF } - var l int - _ = 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)))) + return nil } -func (m *TransferRequest) Unmarshal(dAtA []byte) error { +func (m *RemoveProvisionRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1604,17 +3451,17 @@ func (m *TransferRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TransferRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RemoveProvisionRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TransferRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RemoveProvisionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) } - var stringLen uint64 + m.Seq = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -1624,29 +3471,116 @@ func (m *TransferRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Seq |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RemoveProvisionResponse) 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: RemoveProvisionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RemoveProvisionResponse: 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 postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.Sender = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClaimBatchRequest) 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 } - var stringLen uint64 + 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: ClaimBatchRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClaimBatchRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxClaims", wireType) + } + m.MaxClaims = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -1656,29 +3590,116 @@ func (m *TransferRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.MaxClaims |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClaimBatchResponse) 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: ClaimBatchResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClaimBatchResponse: 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 postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.Receiver = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClaimRequest) 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: ClaimRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClaimRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) } - var stringLen uint64 + m.Seq = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -1688,26 +3709,11 @@ func (m *TransferRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Seq |= 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 - } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -1729,7 +3735,7 @@ func (m *TransferRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransferResponse) Unmarshal(dAtA []byte) error { +func (m *ClaimResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1752,10 +3758,10 @@ func (m *TransferResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TransferResponse: wiretype end group for non-group") + return fmt.Errorf("proto: ClaimResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TransferResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ClaimResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -1779,7 +3785,7 @@ func (m *TransferResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ProvisionRequest) Unmarshal(dAtA []byte) error { +func (m *AddGuardianRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1802,98 +3808,15 @@ func (m *ProvisionRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ProvisionRequest: wiretype end group for non-group") + return fmt.Errorf("proto: AddGuardianRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ProvisionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AddGuardianRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) - } - m.Seq = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Seq |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 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.Sender = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Guardian", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -1921,9 +3844,7 @@ func (m *ProvisionRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Guardian = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -1946,7 +3867,7 @@ func (m *ProvisionRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ProvisionResponse) Unmarshal(dAtA []byte) error { +func (m *AddGuardianResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1969,10 +3890,10 @@ func (m *ProvisionResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ProvisionResponse: wiretype end group for non-group") + return fmt.Errorf("proto: AddGuardianResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ProvisionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AddGuardianResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -1996,7 +3917,7 @@ func (m *ProvisionResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *HoldTransferRequest) Unmarshal(dAtA []byte) error { +func (m *RemoveGuardianRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2019,17 +3940,17 @@ func (m *HoldTransferRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: HoldTransferRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RemoveGuardianRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: HoldTransferRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RemoveGuardianRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Guardian", wireType) } - m.Seq = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -2039,11 +3960,24 @@ func (m *HoldTransferRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Seq |= uint64(b&0x7F) << shift + 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.Guardian = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -2065,7 +3999,7 @@ func (m *HoldTransferRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *HoldTransferResponse) Unmarshal(dAtA []byte) error { +func (m *RemoveGuardianResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2088,10 +4022,10 @@ func (m *HoldTransferResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: HoldTransferResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RemoveGuardianResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: HoldTransferResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RemoveGuardianResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -2115,7 +4049,7 @@ func (m *HoldTransferResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ReleaseTransferRequest) Unmarshal(dAtA []byte) error { +func (m *AddOperatorRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2138,17 +4072,17 @@ func (m *ReleaseTransferRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ReleaseTransferRequest: wiretype end group for non-group") + return fmt.Errorf("proto: AddOperatorRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ReleaseTransferRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AddOperatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } - m.Seq = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -2158,11 +4092,24 @@ func (m *ReleaseTransferRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Seq |= uint64(b&0x7F) << shift + 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.Operator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -2184,7 +4131,7 @@ func (m *ReleaseTransferRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ReleaseTransferResponse) Unmarshal(dAtA []byte) error { +func (m *AddOperatorResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2207,10 +4154,10 @@ func (m *ReleaseTransferResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ReleaseTransferResponse: wiretype end group for non-group") + return fmt.Errorf("proto: AddOperatorResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ReleaseTransferResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AddOperatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -2234,7 +4181,7 @@ func (m *ReleaseTransferResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *RemoveProvisionRequest) Unmarshal(dAtA []byte) error { +func (m *RemoveOperatorRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2257,17 +4204,17 @@ func (m *RemoveProvisionRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RemoveProvisionRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RemoveOperatorRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RemoveProvisionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RemoveOperatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } - m.Seq = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -2277,11 +4224,24 @@ func (m *RemoveProvisionRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Seq |= uint64(b&0x7F) << shift + 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.Operator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -2303,7 +4263,7 @@ func (m *RemoveProvisionRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *RemoveProvisionResponse) Unmarshal(dAtA []byte) error { +func (m *RemoveOperatorResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2326,10 +4286,10 @@ func (m *RemoveProvisionResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RemoveProvisionResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RemoveOperatorResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RemoveProvisionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RemoveOperatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -2353,7 +4313,7 @@ func (m *RemoveProvisionResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ClaimBatchRequest) Unmarshal(dAtA []byte) error { +func (m *AddJudgeRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2376,17 +4336,17 @@ func (m *ClaimBatchRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ClaimBatchRequest: wiretype end group for non-group") + return fmt.Errorf("proto: AddJudgeRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ClaimBatchRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AddJudgeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxClaims", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Judge", wireType) } - m.MaxClaims = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -2396,11 +4356,24 @@ func (m *ClaimBatchRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MaxClaims |= uint64(b&0x7F) << shift + 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.Judge = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -2422,7 +4395,7 @@ func (m *ClaimBatchRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ClaimBatchResponse) Unmarshal(dAtA []byte) error { +func (m *AddJudgeResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2445,10 +4418,10 @@ func (m *ClaimBatchResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ClaimBatchResponse: wiretype end group for non-group") + return fmt.Errorf("proto: AddJudgeResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ClaimBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AddJudgeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -2472,7 +4445,7 @@ func (m *ClaimBatchResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ClaimRequest) Unmarshal(dAtA []byte) error { +func (m *RemoveJudgeRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2495,17 +4468,17 @@ func (m *ClaimRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ClaimRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RemoveJudgeRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ClaimRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RemoveJudgeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Judge", wireType) } - m.Seq = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -2515,11 +4488,24 @@ func (m *ClaimRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Seq |= uint64(b&0x7F) << shift + 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.Judge = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -2541,7 +4527,7 @@ func (m *ClaimRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ClaimResponse) Unmarshal(dAtA []byte) error { +func (m *RemoveJudgeResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2564,10 +4550,10 @@ func (m *ClaimResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ClaimResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RemoveJudgeResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ClaimResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RemoveJudgeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: