diff --git a/README.md b/README.md index a0dd66ae..9b21a71f 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,10 @@ ![CI Status](https://github.com/spacemeshos/api/workflows/CI/badge.svg) -[Protobuf](https://developers.google.com/protocol-buffers) implementation of the Spacemesh API. This repository contains only API design, not implementation. For implementation work, see [go-spacemesh](https://github.com/spacemeshos/go-spacemesh/tree/develop/api/grpcserver). Note that API implementation may lag design. +[Protobuf](https://developers.google.com/protocol-buffers) implementation of the Spacemesh API. This repository contains +only API design, not implementation. For implementation work, see +[go-spacemesh](https://github.com/spacemeshos/go-spacemesh/tree/develop/api/grpcserver). Note that API implementation +may lag design. ## Design @@ -10,46 +13,85 @@ The API was designed with the following considerations in mind. ### Mesh vs. global state -In Spacemesh, "the mesh" refers to data structures that are _explicitly_ stored by all full nodes and are subject to consensus. This consists of transactions, collated into blocks, which in turn are collated into layers. Note that, in addition to transactions, blocks contain metadata such as layer number and signature. The mesh also includes ATXs (activations). +In Spacemesh, "the mesh" refers to data structures that are _explicitly_ stored by all full nodes and are subject to +consensus. This consists of transactions, collated into blocks, which in turn are collated into layers. Note that, in +addition to transactions, blocks contain metadata such as layer number and signature. The mesh also includes ATXs +(activations). -By contrast, "global state" refers to data structures that are calculated _implicitly_ based on mesh data. These data are not explicitly stored anywhere in the mesh. Global state includes account state (balance, counter/nonce value, and, for smart contract accounts, code), transaction receipts, and smart contract event logs. These data need not be stored indefinitely by all full nodes (although they should be stored indefinitely by archive nodes). +By contrast, "global state" refers to data structures that are calculated _implicitly_ based on mesh data. These data +are not explicitly stored anywhere in the mesh. Global state includes account state (balance, counter/nonce value, and, +for smart contract accounts, code), transaction receipts, and smart contract event logs. These data need not be stored +indefinitely by all full nodes (although they should be stored indefinitely by archive nodes). -The API provides access to both types of data, but they are divided into different API services. For more information on this distinction, see [SMIP-0003: Global state data, STF, APIs](https://github.com/spacemeshos/SMIPS/issues/13), as well as the [`MeshService`](/proto/spacemesh/v1/mesh.proto) and the [`GlobalStateService`](/proto/spacemesh/v1/global_state.proto). +The API provides access to both types of data, but they are divided into different API services. For more information on +this distinction, see [SMIP-0003: Global state data, STF, APIs](https://github.com/spacemeshos/SMIPS/issues/13), as well +as the [`MeshService`](/proto/spacemesh/v1/mesh.proto) and the +[`GlobalStateService`](/proto/spacemesh/v1/global_state.proto). ### Transactions -Transactions span mesh and global state data. They are submitted to a node, which may or may not admit the transaction to its mempool. If the transaction is admitted to the mempool, it will probably end up being added to a newly-mined block, and that block will be submitted to the mesh in some layer. After that, the layer containing the block will eventually be approved, and then confirmed, by the consensus mechanism. After the layer is approved, the transaction will be run through the STF (state transition function), and if it succeeds, it may update global state. +Transactions span mesh and global state data. They are submitted to a node, which may or may not admit the transaction +to its mempool. If the transaction is admitted to the mempool, it will probably end up being added to a newly-mined +block, and that block will be submitted to the mesh in some layer. After that, the layer containing the block will +eventually be approved, and then confirmed, by the consensus mechanism. After the layer is approved, the transaction +will be run through the STF (state transition function), and if it succeeds, it may update global state. -Since transactions span multiple layers of abstraction, the API exposes transaction data in its own service, [`TransactionService`](/proto/spacemesh/v1/tx.proto). +Since transactions span multiple layers of abstraction, the API exposes transaction data in its own service, +[`TransactionService`](/proto/spacemesh/v1/tx.proto). ### Types of endpoints -Broadly speaking, there are four types of endpoints: simple, command, query, and stream. Each type is described below. Note that in some cases, the same data are exposed through multiple endpoints, e.g., both a query and a stream endpoint. - -- **Simple** endpoints are used to query a single data element. Some simple endpoints accept a request object (e.g., [`GlobalStateService.Account`](https://github.com/spacemeshos/api/blob/ab285df4d52af4663335a4bcccb0b52f1e5003ee/proto/spacemesh/v1/global_state.proto#L14)), while some which return data that's global to a node accept no request object (e.g., [`NodeService.Version`](https://github.com/spacemeshos/api/blob/ab285df4d52af4663335a4bcccb0b52f1e5003ee/proto/spacemesh/v1/node.proto#L13)). -- **Command** endpoints are used to send a command to a node. Examples include [`TransactionService.SubmitTransaction`](https://github.com/spacemeshos/api/blob/ab285df4d52af4663335a4bcccb0b52f1e5003ee/proto/spacemesh/v1/tx.proto#L15) and [`SmesherService.StartSmeshing`](https://github.com/spacemeshos/api/blob/ab285df4d52af4663335a4bcccb0b52f1e5003ee/proto/spacemesh/v1/smesher.proto#L16). -- **Query** endpoints are used to read paginated historical data. A `*Query` endpoint accepts a `*Request` message that typically contains the following: +Broadly speaking, there are four types of endpoints: simple, command, query, and stream. Each type is described below. +Note that in some cases, the same data are exposed through multiple endpoints, e.g., both a query and a stream endpoint. + +- **Simple** endpoints are used to query a single data element. Some simple endpoints accept a request object (e.g., + [`GlobalStateService.Account`](https://github.com/spacemeshos/api/blob/ab285df4d52af4663335a4bcccb0b52f1e5003ee/proto/spacemesh/v1/global_state.proto#L14)), + while some which return data that's global to a node accept no request object (e.g., + [`NodeService.Version`](https://github.com/spacemeshos/api/blob/ab285df4d52af4663335a4bcccb0b52f1e5003ee/proto/spacemesh/v1/node.proto#L13)). +- **Command** endpoints are used to send a command to a node. Examples include + [`TransactionService.SubmitTransaction`](https://github.com/spacemeshos/api/blob/ab285df4d52af4663335a4bcccb0b52f1e5003ee/proto/spacemesh/v1/tx.proto#L15) + and + [`SmesherService.StartSmeshing`](https://github.com/spacemeshos/api/blob/ab285df4d52af4663335a4bcccb0b52f1e5003ee/proto/spacemesh/v1/smesher.proto#L16). +- **Query** endpoints are used to read paginated historical data. A `*Query` endpoint accepts a `*Request` message that + typically contains the following: - `filter`: A filter (see Streams, below) - `min_layer`: The first layer to return results from - `max_results`: The maximum number of results to return - `offset`: Page offset -- **Stream** endpoints are used to read realtime data. They do not return historical data. Each time the node creates, or learns of, a piece of data matching the filter and type, or sees an update to a matching piece of data, it sends it over the stream. A `*Stream` endpoint accepts a `*Request` message, containing the following, that functions as a filter: +- **Stream** endpoints are used to read realtime data. They do not return historical data. Each time the node creates, + or learns of, a piece of data matching the filter and type, or sees an update to a matching piece of data, it sends it + over the stream. A `*Stream` endpoint accepts a `*Request` message, containing the following, that functions as a + filter: - `*_id`: The ID of the data type to filter on (e.g., "show me all data items that touch this `account_id`") - - `flags`: A bit field that allows the client to select which, among multiple types multiplexed on this stream, to receive + - `flags`: A bit field that allows the client to select which, among multiple types multiplexed on this stream, to + receive ## Services -The Spacemesh API consists of several logical services, each of which contains a set of one or more RPC endpoints. The node operator can enable or disable each service independently using the CLI. The current set of services is as follows: - -- [DebugService](/proto/spacemesh/v1/debug.proto) is an experimental service designed for debugging and testing. The endpoints in this service are volatile and subject to change without notice. They should not be relied on in production. -- [GatewayService](/proto/spacemesh/v1/gateway.proto) is a read-write interface that allows a [poet server](https://github.com/spacemeshos/poet) to broadcast proofs to the network via a gateway node. -- [GlobalStateService](/proto/spacemesh/v1/global_state.proto) is a readonly interface that provides access to data elements that are not explicitly part of the mesh such as accounts, rewards, and transaction state and receipts. -- [MeshService](/proto/spacemesh/v1/mesh.proto) is a readonly interface that provides access to mesh data such as layer number, epoch number, and network ID. It provides streams for watching layers (which contain blocks, transactions, etc.). In the future this service will be expanded to include other mesh-related endpoints. -- [NodeService](/proto/spacemesh/v1/node.proto) is a readonly interface for reading basic node-related data such as node status, software version and build number, and errors. It also allows a consumer to request that the node start the sync process, thus enabling the stream endpoints. -- [SmesherService](/proto/spacemesh/v1/smesher.proto) is a read-write interface that allows the client to query, and set, parameters related to smeshing (mining), such as PoST commitment, coinbase, etc. -- [TransactionService](/proto/spacemesh/v1/tx.proto) is a read-write interface that allows the client to submit a new transaction, and to follow the state of one or more transactions on its journey from submission to mempool to block to mesh to STF. - -Each of these services relies on one or more sets of message types, which live in `*types.proto` files in the same directory as the service definition files. +The Spacemesh API consists of several logical services, each of which contains a set of one or more RPC endpoints. The +node operator can enable or disable each service independently using the CLI. The current set of services is as follows: + +- [DebugService](/proto/spacemesh/v1/debug.proto) is an experimental service designed for debugging and testing. The + endpoints in this service are volatile and subject to change without notice. They should not be relied on in + production. +- [GatewayService](/proto/spacemesh/v1/gateway.proto) is a read-write interface that allows a [poet + server](https://github.com/spacemeshos/poet) to broadcast proofs to the network via a gateway node. +- [GlobalStateService](/proto/spacemesh/v1/global_state.proto) is a readonly interface that provides access to data + elements that are not explicitly part of the mesh such as accounts, rewards, and transaction state and receipts. +- [MeshService](/proto/spacemesh/v1/mesh.proto) is a readonly interface that provides access to mesh data such as layer + number, epoch number, and network ID. It provides streams for watching layers (which contain blocks, transactions, + etc.). In the future this service will be expanded to include other mesh-related endpoints. +- [NodeService](/proto/spacemesh/v1/node.proto) is a readonly interface for reading basic node-related data such as node + status, software version and build number, and errors. It also allows a consumer to request that the node start the + sync process, thus enabling the stream endpoints. +- [SmesherService](/proto/spacemesh/v1/smesher.proto) is a read-write interface that allows the client to query, and + set, parameters related to smeshing (mining), such as PoST commitment, coinbase, etc. +- [TransactionService](/proto/spacemesh/v1/tx.proto) is a read-write interface that allows the client to submit a new + transaction, and to follow the state of one or more transactions on its journey from submission to mempool to block to + mesh to STF. + +Each of these services relies on one or more sets of message types, which live in `*types.proto` files in the same +directory as the service definition files. ## Intended Usage Pattern @@ -57,28 +99,41 @@ Each of these services relies on one or more sets of message types, which live i 1. Client starts a full node with one or more relevant GRPC endpoints enabled 1. Client subscribes to the streaming GRPC api methods that are of interest -1. Client calls `NodeService.SyncStart()` to request that the node start syncing (note that, at present, sync is on by default and this step is unnecessary, but in future, it will be possible to [start the node with sync turned off](https://github.com/spacemeshos/go-spacemesh/issues/2080) so that the client can subscribe to streams before the sync process begins, ensuring they don't miss any data) +1. Client calls `NodeService.SyncStart()` to request that the node start syncing (note that, at present, sync is on by + default and this step is unnecessary, but in future, it will be possible to [start the node with sync turned + off](https://github.com/spacemeshos/go-spacemesh/issues/2080) so that the client can subscribe to streams before the + sync process begins, ensuring they don't miss any data) 1. Client processes streaming data it receives from the node -1. Client monitors node using `NodeService.SyncStatusStream()` and `NodeService.ErrorStream()` and handles node critical errors. Return to step 1 as necessary. +1. Client monitors node using `NodeService.SyncStatusStream()` and `NodeService.ErrorStream()` and handles node critical + errors. Return to step 1 as necessary. 1. Client gracefully shuts down the node by calling `NodeService.Shutdown()` when it is done processing data. ## Development ### Versioning -We use standard [semantic versioning](https://semver.org/). Please regularly cut releases against the `master` branch and increment the version accordingly. Releases are managed at [Releases](https://github.com/spacemeshos/api/releases) and the current version line is 1.x. Note that this is especially important for downstream code that relies on individual builds, such as the golang build. +We use standard [semantic versioning](https://semver.org/). Please regularly cut releases against the `master` branch +and increment the version accordingly. Releases are managed at [Releases](https://github.com/spacemeshos/api/releases) +and the current version line is 1.x. Note that this is especially important for downstream code that relies on +individual builds, such as the golang build. ### Build targets -This repository currently contains builds for two targets: golang and grpc-gateway. **Every time a protobuf definition file is changed, you must update the build** and include the updated build files with your PR in order to keep everything in sync. You can check this at any time by running `make check`, and it's also enforced by CI (see below for more information). +This repository currently contains builds for two targets: golang and grpc-gateway. **Every time a protobuf definition +file is changed, you must update the build** and include the updated build files with your PR in order to keep +everything in sync. You can check this at any time by running `make check`, and it's also enforced by CI (see below for +more information). -- golang builds live in [`release/go`](/release/go). You may use this repository directly as a go module with an import statement such as `import "github.com/spacemeshos/api/release/go/spacemesh/v1"`. -- grpc-gateway builds live alongside the golang builds in [`release/go/spacemesh/v1`](/release/go/spacemesh/v1) (they have a `.gw.go` extension). +- golang builds live in [`release/go`](/release/go). You may use this repository directly as a go module with an import + statement such as `import "github.com/spacemeshos/api/release/go/spacemesh/v1"`. +- grpc-gateway builds live alongside the golang builds in [`release/go/spacemesh/v1`](/release/go/spacemesh/v1) (they + have a `.gw.go` extension). ### Makefile The repository includes a [`Makefile`](Makefile) that makes it easy to run most regular tasks: +- `make install` installs all used protoc-plugins - `make lint` runs the linter (see below) - `make local` checks for breaking changes against local `master` (see below) - `make breaking` checks for breaking changes against github repository (see below) @@ -89,7 +144,8 @@ Under the hood, it uses a helpful tool called `buf`. ### Buf -In addition to running `make` commands, you can also manually use the [`buf`](https://buf.build/) tool to compile the API to an [image](https://buf.build/docs/inputs). First, [install `buf`](https://buf.build/docs/installation), then run: +In addition to running `make` commands, you can also manually use the [`buf`](https://buf.build/) tool to compile the +API to an [image](https://buf.build/docs/inputs). First, [install `buf`](https://buf.build/docs/installation), then run: ```console > buf image build -o /dev/null @@ -103,7 +159,8 @@ to test the build. To output the image in json format, run: #### Breaking changes detection -`buf` also supports [detection of breaking changes](https://buf.build/docs/tour-5). To do this, first create an image from the current state: +`buf` also supports [detection of breaking changes](https://buf.build/docs/tour-5). To do this, first create an image +from the current state: ```console > buf image build -o image.bin @@ -119,7 +176,9 @@ Make a breaking change, then run against this change: #### Linting -`buf` runs several [linters](https://buf.build/docs/lint-checkers). It's pretty strict about things such as naming conventions, to prevent downstream issues in the various languages and framework that rely upon the protobuf definition files. You can run the linter like this: +`buf` runs several [linters](https://buf.build/docs/lint-checkers). It's pretty strict about things such as naming +conventions, to prevent downstream issues in the various languages and framework that rely upon the protobuf definition +files. You can run the linter like this: ```console > buf lint @@ -127,10 +186,15 @@ Make a breaking change, then run against this change: If there are no issues, this command should have exit code 0 and no output. -For more information on linting, see the [style guide](https://buf.build/docs/style-guide). For more information on the difference between the `buf` tool and the `protoc` compiler, see [Use protoc input instead of the internal compiler](https://buf.build/docs/tour-7). +For more information on linting, see the [style guide](https://buf.build/docs/style-guide). For more information on the +difference between the `buf` tool and the `protoc` compiler, see [Use protoc input instead of the internal +compiler](https://buf.build/docs/tour-7). ### Continuous integration -This repository has a continuous integration (CI) [workflow](.github/workflows/ci.yml) built on GitHub Actions. In addition to linting and breaking changes detection, it also runs the `protoc` compiler, since that tends to surface a slightly different set of warnings and errors than `buf`. +This repository has a continuous integration (CI) [workflow](.github/workflows/ci.yml) built on GitHub Actions. In +addition to linting and breaking changes detection, it also runs the `protoc` compiler, since that tends to surface a +slightly different set of warnings and errors than `buf`. -You can use a nifty tool called [`act`](https://github.com/nektos/act) to run the CI workflow locally, although it [doesn't always play nice](https://github.com/nektos/act/issues/322) with our workflow configuration. +You can use a nifty tool called [`act`](https://github.com/nektos/act) to run the CI workflow locally, although it +[doesn't always play nice](https://github.com/nektos/act/issues/322) with our workflow configuration. diff --git a/release/go/spacemesh/v2alpha1/smeshing_identities.pb.go b/release/go/spacemesh/v2alpha1/smeshing_identities.pb.go new file mode 100644 index 00000000..d10b4800 --- /dev/null +++ b/release/go/spacemesh/v2alpha1/smeshing_identities.pb.go @@ -0,0 +1,2818 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.33.0 +// protoc (unknown) +// source: spacemesh/v2alpha1/smeshing_identities.proto + +package spacemeshv2alpha1 + +import ( + _ "google.golang.org/genproto/googleapis/api/annotations" + _ "google.golang.org/genproto/googleapis/api/visibility" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + _ "google.golang.org/protobuf/types/known/emptypb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type IdentityState int32 + +const ( + IdentityState_UNSPECIFIED IdentityState = 0 + IdentityState_WAIT_FOR_ATX_SYNCED IdentityState = 1 + IdentityState_RETRYING IdentityState = 2 + IdentityState_WAITING_FOR_POET_REGISTRATION_WINDOW IdentityState = 3 + IdentityState_POET_CHALLENGE_READY IdentityState = 4 + IdentityState_POET_REGISTERED IdentityState = 5 + IdentityState_WAIT_FOR_POET_ROUND_END IdentityState = 6 + IdentityState_POET_PROOF_RECEIVED IdentityState = 7 + IdentityState_GENERATING_POST_PROOF IdentityState = 8 + IdentityState_POST_PROOF_READY IdentityState = 9 + IdentityState_ATX_READY IdentityState = 10 + IdentityState_ATX_BROADCASTED IdentityState = 11 + IdentityState_PROPOSAL_BUILD_FAILED IdentityState = 12 + IdentityState_PROPOSAL_PUBLISH_FAILED IdentityState = 13 + IdentityState_PROPOSAL_PUBLISHED IdentityState = 14 + IdentityState_ELIGIBLE IdentityState = 15 +) + +// Enum value maps for IdentityState. +var ( + IdentityState_name = map[int32]string{ + 0: "UNSPECIFIED", + 1: "WAIT_FOR_ATX_SYNCED", + 2: "RETRYING", + 3: "WAITING_FOR_POET_REGISTRATION_WINDOW", + 4: "POET_CHALLENGE_READY", + 5: "POET_REGISTERED", + 6: "WAIT_FOR_POET_ROUND_END", + 7: "POET_PROOF_RECEIVED", + 8: "GENERATING_POST_PROOF", + 9: "POST_PROOF_READY", + 10: "ATX_READY", + 11: "ATX_BROADCASTED", + 12: "PROPOSAL_BUILD_FAILED", + 13: "PROPOSAL_PUBLISH_FAILED", + 14: "PROPOSAL_PUBLISHED", + 15: "ELIGIBLE", + } + IdentityState_value = map[string]int32{ + "UNSPECIFIED": 0, + "WAIT_FOR_ATX_SYNCED": 1, + "RETRYING": 2, + "WAITING_FOR_POET_REGISTRATION_WINDOW": 3, + "POET_CHALLENGE_READY": 4, + "POET_REGISTERED": 5, + "WAIT_FOR_POET_ROUND_END": 6, + "POET_PROOF_RECEIVED": 7, + "GENERATING_POST_PROOF": 8, + "POST_PROOF_READY": 9, + "ATX_READY": 10, + "ATX_BROADCASTED": 11, + "PROPOSAL_BUILD_FAILED": 12, + "PROPOSAL_PUBLISH_FAILED": 13, + "PROPOSAL_PUBLISHED": 14, + "ELIGIBLE": 15, + } +) + +func (x IdentityState) Enum() *IdentityState { + p := new(IdentityState) + *p = x + return p +} + +func (x IdentityState) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (IdentityState) Descriptor() protoreflect.EnumDescriptor { + return file_spacemesh_v2alpha1_smeshing_identities_proto_enumTypes[0].Descriptor() +} + +func (IdentityState) Type() protoreflect.EnumType { + return &file_spacemesh_v2alpha1_smeshing_identities_proto_enumTypes[0] +} + +func (x IdentityState) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use IdentityState.Descriptor instead. +func (IdentityState) EnumDescriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{0} +} + +type IdentityStatesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *IdentityStatesRequest) Reset() { + *x = IdentityStatesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IdentityStatesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdentityStatesRequest) ProtoMessage() {} + +func (x *IdentityStatesRequest) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IdentityStatesRequest.ProtoReflect.Descriptor instead. +func (*IdentityStatesRequest) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{0} +} + +type RetryingState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` +} + +func (x *RetryingState) Reset() { + *x = RetryingState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RetryingState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RetryingState) ProtoMessage() {} + +func (x *RetryingState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RetryingState.ProtoReflect.Descriptor instead. +func (*RetryingState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{1} +} + +func (x *RetryingState) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type WaitForAtxSyncedState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *WaitForAtxSyncedState) Reset() { + *x = WaitForAtxSyncedState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WaitForAtxSyncedState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WaitForAtxSyncedState) ProtoMessage() {} + +func (x *WaitForAtxSyncedState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WaitForAtxSyncedState.ProtoReflect.Descriptor instead. +func (*WaitForAtxSyncedState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{2} +} + +type WaitingForPoetRegistrationWindowState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *WaitingForPoetRegistrationWindowState) Reset() { + *x = WaitingForPoetRegistrationWindowState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WaitingForPoetRegistrationWindowState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WaitingForPoetRegistrationWindowState) ProtoMessage() {} + +func (x *WaitingForPoetRegistrationWindowState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WaitingForPoetRegistrationWindowState.ProtoReflect.Descriptor instead. +func (*WaitingForPoetRegistrationWindowState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{3} +} + +type PoetChallengeReadyState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *PoetChallengeReadyState) Reset() { + *x = PoetChallengeReadyState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PoetChallengeReadyState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PoetChallengeReadyState) ProtoMessage() {} + +func (x *PoetChallengeReadyState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PoetChallengeReadyState.ProtoReflect.Descriptor instead. +func (*PoetChallengeReadyState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{4} +} + +type PoETRegistration struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ChallengeHash []byte `protobuf:"bytes,1,opt,name=challenge_hash,json=challengeHash,proto3" json:"challenge_hash,omitempty"` + Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` + RoundId string `protobuf:"bytes,3,opt,name=round_id,json=roundId,proto3" json:"round_id,omitempty"` + RoundEnd *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=round_end,json=roundEnd,proto3" json:"round_end,omitempty"` +} + +func (x *PoETRegistration) Reset() { + *x = PoETRegistration{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PoETRegistration) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PoETRegistration) ProtoMessage() {} + +func (x *PoETRegistration) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PoETRegistration.ProtoReflect.Descriptor instead. +func (*PoETRegistration) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{5} +} + +func (x *PoETRegistration) GetChallengeHash() []byte { + if x != nil { + return x.ChallengeHash + } + return nil +} + +func (x *PoETRegistration) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *PoETRegistration) GetRoundId() string { + if x != nil { + return x.RoundId + } + return "" +} + +func (x *PoETRegistration) GetRoundEnd() *timestamppb.Timestamp { + if x != nil { + return x.RoundEnd + } + return nil +} + +type PoetRegisteredState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Registrations []*PoETRegistration `protobuf:"bytes,1,rep,name=registrations,proto3" json:"registrations,omitempty"` +} + +func (x *PoetRegisteredState) Reset() { + *x = PoetRegisteredState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PoetRegisteredState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PoetRegisteredState) ProtoMessage() {} + +func (x *PoetRegisteredState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PoetRegisteredState.ProtoReflect.Descriptor instead. +func (*PoetRegisteredState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{6} +} + +func (x *PoetRegisteredState) GetRegistrations() []*PoETRegistration { + if x != nil { + return x.Registrations + } + return nil +} + +type WaitForPoetRoundEndState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RoundEnd *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=round_end,json=roundEnd,proto3" json:"round_end,omitempty"` + PublishEpochEnd *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=publish_epoch_end,json=publishEpochEnd,proto3" json:"publish_epoch_end,omitempty"` +} + +func (x *WaitForPoetRoundEndState) Reset() { + *x = WaitForPoetRoundEndState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WaitForPoetRoundEndState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WaitForPoetRoundEndState) ProtoMessage() {} + +func (x *WaitForPoetRoundEndState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WaitForPoetRoundEndState.ProtoReflect.Descriptor instead. +func (*WaitForPoetRoundEndState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{7} +} + +func (x *WaitForPoetRoundEndState) GetRoundEnd() *timestamppb.Timestamp { + if x != nil { + return x.RoundEnd + } + return nil +} + +func (x *WaitForPoetRoundEndState) GetPublishEpochEnd() *timestamppb.Timestamp { + if x != nil { + return x.PublishEpochEnd + } + return nil +} + +type PoetProofReceivedState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PoetUrl string `protobuf:"bytes,1,opt,name=poet_url,json=poetUrl,proto3" json:"poet_url,omitempty"` +} + +func (x *PoetProofReceivedState) Reset() { + *x = PoetProofReceivedState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PoetProofReceivedState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PoetProofReceivedState) ProtoMessage() {} + +func (x *PoetProofReceivedState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PoetProofReceivedState.ProtoReflect.Descriptor instead. +func (*PoetProofReceivedState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{8} +} + +func (x *PoetProofReceivedState) GetPoetUrl() string { + if x != nil { + return x.PoetUrl + } + return "" +} + +type GeneratingPostProofState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *GeneratingPostProofState) Reset() { + *x = GeneratingPostProofState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GeneratingPostProofState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GeneratingPostProofState) ProtoMessage() {} + +func (x *GeneratingPostProofState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GeneratingPostProofState.ProtoReflect.Descriptor instead. +func (*GeneratingPostProofState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{9} +} + +type PostProofReadyState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *PostProofReadyState) Reset() { + *x = PostProofReadyState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PostProofReadyState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PostProofReadyState) ProtoMessage() {} + +func (x *PostProofReadyState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PostProofReadyState.ProtoReflect.Descriptor instead. +func (*PostProofReadyState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{10} +} + +type AtxReadyState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *AtxReadyState) Reset() { + *x = AtxReadyState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AtxReadyState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AtxReadyState) ProtoMessage() {} + +func (x *AtxReadyState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AtxReadyState.ProtoReflect.Descriptor instead. +func (*AtxReadyState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{11} +} + +type AtxBroadcastedState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AtxId []byte `protobuf:"bytes,1,opt,name=atx_id,json=atxId,proto3" json:"atx_id,omitempty"` +} + +func (x *AtxBroadcastedState) Reset() { + *x = AtxBroadcastedState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AtxBroadcastedState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AtxBroadcastedState) ProtoMessage() {} + +func (x *AtxBroadcastedState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AtxBroadcastedState.ProtoReflect.Descriptor instead. +func (*AtxBroadcastedState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{12} +} + +func (x *AtxBroadcastedState) GetAtxId() []byte { + if x != nil { + return x.AtxId + } + return nil +} + +type ProposalBuildFailedState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + Layer uint32 `protobuf:"varint,2,opt,name=layer,proto3" json:"layer,omitempty"` +} + +func (x *ProposalBuildFailedState) Reset() { + *x = ProposalBuildFailedState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProposalBuildFailedState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProposalBuildFailedState) ProtoMessage() {} + +func (x *ProposalBuildFailedState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProposalBuildFailedState.ProtoReflect.Descriptor instead. +func (*ProposalBuildFailedState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{13} +} + +func (x *ProposalBuildFailedState) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *ProposalBuildFailedState) GetLayer() uint32 { + if x != nil { + return x.Layer + } + return 0 +} + +type ProposalPublishFailedState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + Proposal []byte `protobuf:"bytes,2,opt,name=proposal,proto3" json:"proposal,omitempty"` + Layer uint32 `protobuf:"varint,3,opt,name=layer,proto3" json:"layer,omitempty"` +} + +func (x *ProposalPublishFailedState) Reset() { + *x = ProposalPublishFailedState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProposalPublishFailedState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProposalPublishFailedState) ProtoMessage() {} + +func (x *ProposalPublishFailedState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProposalPublishFailedState.ProtoReflect.Descriptor instead. +func (*ProposalPublishFailedState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{14} +} + +func (x *ProposalPublishFailedState) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *ProposalPublishFailedState) GetProposal() []byte { + if x != nil { + return x.Proposal + } + return nil +} + +func (x *ProposalPublishFailedState) GetLayer() uint32 { + if x != nil { + return x.Layer + } + return 0 +} + +type ProposalPublishedState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Proposal []byte `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + Layer uint32 `protobuf:"varint,2,opt,name=layer,proto3" json:"layer,omitempty"` +} + +func (x *ProposalPublishedState) Reset() { + *x = ProposalPublishedState{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProposalPublishedState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProposalPublishedState) ProtoMessage() {} + +func (x *ProposalPublishedState) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProposalPublishedState.ProtoReflect.Descriptor instead. +func (*ProposalPublishedState) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{15} +} + +func (x *ProposalPublishedState) GetProposal() []byte { + if x != nil { + return x.Proposal + } + return nil +} + +func (x *ProposalPublishedState) GetLayer() uint32 { + if x != nil { + return x.Layer + } + return 0 +} + +type Eligibility struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Layer uint32 `protobuf:"varint,1,opt,name=layer,proto3" json:"layer,omitempty"` + Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` +} + +func (x *Eligibility) Reset() { + *x = Eligibility{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Eligibility) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Eligibility) ProtoMessage() {} + +func (x *Eligibility) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Eligibility.ProtoReflect.Descriptor instead. +func (*Eligibility) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{16} +} + +func (x *Eligibility) GetLayer() uint32 { + if x != nil { + return x.Layer + } + return 0 +} + +func (x *Eligibility) GetCount() uint32 { + if x != nil { + return x.Count + } + return 0 +} + +type Eligible struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Layers []*Eligibility `protobuf:"bytes,2,rep,name=layers,proto3" json:"layers,omitempty"` +} + +func (x *Eligible) Reset() { + *x = Eligible{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Eligible) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Eligible) ProtoMessage() {} + +func (x *Eligible) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Eligible.ProtoReflect.Descriptor instead. +func (*Eligible) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{17} +} + +func (x *Eligible) GetLayers() []*Eligibility { + if x != nil { + return x.Layers + } + return nil +} + +type IdentityStateInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + State IdentityState `protobuf:"varint,1,opt,name=state,proto3,enum=spacemesh.v2alpha1.IdentityState" json:"state,omitempty"` + PublishEpoch *uint32 `protobuf:"varint,2,opt,name=publish_epoch,json=publishEpoch,proto3,oneof" json:"publish_epoch,omitempty"` + Time *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=time,proto3" json:"time,omitempty"` + // Types that are assignable to Metadata: + // + // *IdentityStateInfo_Retrying + // *IdentityStateInfo_WaitForAtxSynced + // *IdentityStateInfo_WaitingForPoetRegistrationWindow + // *IdentityStateInfo_PoetChallengeReady + // *IdentityStateInfo_PoetRegistered + // *IdentityStateInfo_WaitForPoetRoundEnd + // *IdentityStateInfo_PoetProofReceived + // *IdentityStateInfo_GeneratingPostProof + // *IdentityStateInfo_PostProofReady + // *IdentityStateInfo_AtxReady + // *IdentityStateInfo_AtxBroadcasted + // *IdentityStateInfo_ProposalBuildFailed + // *IdentityStateInfo_ProposalPublishFailed + // *IdentityStateInfo_ProposalPublished + // *IdentityStateInfo_Eligible + Metadata isIdentityStateInfo_Metadata `protobuf_oneof:"metadata"` +} + +func (x *IdentityStateInfo) Reset() { + *x = IdentityStateInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IdentityStateInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdentityStateInfo) ProtoMessage() {} + +func (x *IdentityStateInfo) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IdentityStateInfo.ProtoReflect.Descriptor instead. +func (*IdentityStateInfo) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{18} +} + +func (x *IdentityStateInfo) GetState() IdentityState { + if x != nil { + return x.State + } + return IdentityState_UNSPECIFIED +} + +func (x *IdentityStateInfo) GetPublishEpoch() uint32 { + if x != nil && x.PublishEpoch != nil { + return *x.PublishEpoch + } + return 0 +} + +func (x *IdentityStateInfo) GetTime() *timestamppb.Timestamp { + if x != nil { + return x.Time + } + return nil +} + +func (m *IdentityStateInfo) GetMetadata() isIdentityStateInfo_Metadata { + if m != nil { + return m.Metadata + } + return nil +} + +func (x *IdentityStateInfo) GetRetrying() *RetryingState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_Retrying); ok { + return x.Retrying + } + return nil +} + +func (x *IdentityStateInfo) GetWaitForAtxSynced() *WaitForAtxSyncedState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_WaitForAtxSynced); ok { + return x.WaitForAtxSynced + } + return nil +} + +func (x *IdentityStateInfo) GetWaitingForPoetRegistrationWindow() *WaitingForPoetRegistrationWindowState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_WaitingForPoetRegistrationWindow); ok { + return x.WaitingForPoetRegistrationWindow + } + return nil +} + +func (x *IdentityStateInfo) GetPoetChallengeReady() *PoetChallengeReadyState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_PoetChallengeReady); ok { + return x.PoetChallengeReady + } + return nil +} + +func (x *IdentityStateInfo) GetPoetRegistered() *PoetRegisteredState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_PoetRegistered); ok { + return x.PoetRegistered + } + return nil +} + +func (x *IdentityStateInfo) GetWaitForPoetRoundEnd() *WaitForPoetRoundEndState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_WaitForPoetRoundEnd); ok { + return x.WaitForPoetRoundEnd + } + return nil +} + +func (x *IdentityStateInfo) GetPoetProofReceived() *PoetProofReceivedState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_PoetProofReceived); ok { + return x.PoetProofReceived + } + return nil +} + +func (x *IdentityStateInfo) GetGeneratingPostProof() *GeneratingPostProofState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_GeneratingPostProof); ok { + return x.GeneratingPostProof + } + return nil +} + +func (x *IdentityStateInfo) GetPostProofReady() *PostProofReadyState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_PostProofReady); ok { + return x.PostProofReady + } + return nil +} + +func (x *IdentityStateInfo) GetAtxReady() *AtxReadyState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_AtxReady); ok { + return x.AtxReady + } + return nil +} + +func (x *IdentityStateInfo) GetAtxBroadcasted() *AtxBroadcastedState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_AtxBroadcasted); ok { + return x.AtxBroadcasted + } + return nil +} + +func (x *IdentityStateInfo) GetProposalBuildFailed() *ProposalBuildFailedState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_ProposalBuildFailed); ok { + return x.ProposalBuildFailed + } + return nil +} + +func (x *IdentityStateInfo) GetProposalPublishFailed() *ProposalPublishFailedState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_ProposalPublishFailed); ok { + return x.ProposalPublishFailed + } + return nil +} + +func (x *IdentityStateInfo) GetProposalPublished() *ProposalPublishedState { + if x, ok := x.GetMetadata().(*IdentityStateInfo_ProposalPublished); ok { + return x.ProposalPublished + } + return nil +} + +func (x *IdentityStateInfo) GetEligible() *Eligible { + if x, ok := x.GetMetadata().(*IdentityStateInfo_Eligible); ok { + return x.Eligible + } + return nil +} + +type isIdentityStateInfo_Metadata interface { + isIdentityStateInfo_Metadata() +} + +type IdentityStateInfo_Retrying struct { + Retrying *RetryingState `protobuf:"bytes,4,opt,name=retrying,proto3,oneof"` +} + +type IdentityStateInfo_WaitForAtxSynced struct { + WaitForAtxSynced *WaitForAtxSyncedState `protobuf:"bytes,5,opt,name=wait_for_atx_synced,json=waitForAtxSynced,proto3,oneof"` +} + +type IdentityStateInfo_WaitingForPoetRegistrationWindow struct { + WaitingForPoetRegistrationWindow *WaitingForPoetRegistrationWindowState `protobuf:"bytes,6,opt,name=waiting_for_poet_registration_window,json=waitingForPoetRegistrationWindow,proto3,oneof"` +} + +type IdentityStateInfo_PoetChallengeReady struct { + PoetChallengeReady *PoetChallengeReadyState `protobuf:"bytes,7,opt,name=poet_challenge_ready,json=poetChallengeReady,proto3,oneof"` +} + +type IdentityStateInfo_PoetRegistered struct { + PoetRegistered *PoetRegisteredState `protobuf:"bytes,8,opt,name=poet_registered,json=poetRegistered,proto3,oneof"` +} + +type IdentityStateInfo_WaitForPoetRoundEnd struct { + WaitForPoetRoundEnd *WaitForPoetRoundEndState `protobuf:"bytes,9,opt,name=wait_for_poet_round_end,json=waitForPoetRoundEnd,proto3,oneof"` +} + +type IdentityStateInfo_PoetProofReceived struct { + PoetProofReceived *PoetProofReceivedState `protobuf:"bytes,10,opt,name=poet_proof_received,json=poetProofReceived,proto3,oneof"` +} + +type IdentityStateInfo_GeneratingPostProof struct { + GeneratingPostProof *GeneratingPostProofState `protobuf:"bytes,11,opt,name=generating_post_proof,json=generatingPostProof,proto3,oneof"` +} + +type IdentityStateInfo_PostProofReady struct { + PostProofReady *PostProofReadyState `protobuf:"bytes,12,opt,name=post_proof_ready,json=postProofReady,proto3,oneof"` +} + +type IdentityStateInfo_AtxReady struct { + AtxReady *AtxReadyState `protobuf:"bytes,13,opt,name=atx_ready,json=atxReady,proto3,oneof"` +} + +type IdentityStateInfo_AtxBroadcasted struct { + AtxBroadcasted *AtxBroadcastedState `protobuf:"bytes,14,opt,name=atx_broadcasted,json=atxBroadcasted,proto3,oneof"` +} + +type IdentityStateInfo_ProposalBuildFailed struct { + ProposalBuildFailed *ProposalBuildFailedState `protobuf:"bytes,15,opt,name=proposal_build_failed,json=proposalBuildFailed,proto3,oneof"` +} + +type IdentityStateInfo_ProposalPublishFailed struct { + ProposalPublishFailed *ProposalPublishFailedState `protobuf:"bytes,16,opt,name=proposal_publish_failed,json=proposalPublishFailed,proto3,oneof"` +} + +type IdentityStateInfo_ProposalPublished struct { + ProposalPublished *ProposalPublishedState `protobuf:"bytes,17,opt,name=proposal_published,json=proposalPublished,proto3,oneof"` +} + +type IdentityStateInfo_Eligible struct { + Eligible *Eligible `protobuf:"bytes,18,opt,name=eligible,proto3,oneof"` +} + +func (*IdentityStateInfo_Retrying) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_WaitForAtxSynced) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_WaitingForPoetRegistrationWindow) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_PoetChallengeReady) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_PoetRegistered) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_WaitForPoetRoundEnd) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_PoetProofReceived) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_GeneratingPostProof) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_PostProofReady) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_AtxReady) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_AtxBroadcasted) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_ProposalBuildFailed) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_ProposalPublishFailed) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_ProposalPublished) isIdentityStateInfo_Metadata() {} + +func (*IdentityStateInfo_Eligible) isIdentityStateInfo_Metadata() {} + +type Identity struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + History []*IdentityStateInfo `protobuf:"bytes,1,rep,name=history,proto3" json:"history,omitempty"` +} + +func (x *Identity) Reset() { + *x = Identity{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Identity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Identity) ProtoMessage() {} + +func (x *Identity) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Identity.ProtoReflect.Descriptor instead. +func (*Identity) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{19} +} + +func (x *Identity) GetHistory() []*IdentityStateInfo { + if x != nil { + return x.History + } + return nil +} + +type IdentityStatesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Identities map[string]*Identity `protobuf:"bytes,1,rep,name=identities,proto3" json:"identities,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *IdentityStatesResponse) Reset() { + *x = IdentityStatesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IdentityStatesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdentityStatesResponse) ProtoMessage() {} + +func (x *IdentityStatesResponse) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IdentityStatesResponse.ProtoReflect.Descriptor instead. +func (*IdentityStatesResponse) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{20} +} + +func (x *IdentityStatesResponse) GetIdentities() map[string]*Identity { + if x != nil { + return x.Identities + } + return nil +} + +// PoetInfo rpc +type PoetInfoRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *PoetInfoRequest) Reset() { + *x = PoetInfoRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PoetInfoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PoetInfoRequest) ProtoMessage() {} + +func (x *PoetInfoRequest) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PoetInfoRequest.ProtoReflect.Descriptor instead. +func (*PoetInfoRequest) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{21} +} + +type PoetConfig struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PhaseShift *durationpb.Duration `protobuf:"bytes,1,opt,name=phase_shift,json=phaseShift,proto3" json:"phase_shift,omitempty"` + CycleGap *durationpb.Duration `protobuf:"bytes,2,opt,name=cycle_gap,json=cycleGap,proto3" json:"cycle_gap,omitempty"` +} + +func (x *PoetConfig) Reset() { + *x = PoetConfig{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PoetConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PoetConfig) ProtoMessage() {} + +func (x *PoetConfig) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PoetConfig.ProtoReflect.Descriptor instead. +func (*PoetConfig) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{22} +} + +func (x *PoetConfig) GetPhaseShift() *durationpb.Duration { + if x != nil { + return x.PhaseShift + } + return nil +} + +func (x *PoetConfig) GetCycleGap() *durationpb.Duration { + if x != nil { + return x.CycleGap + } + return nil +} + +type PoetInfoResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Poets []string `protobuf:"bytes,1,rep,name=poets,proto3" json:"poets,omitempty"` + Config *PoetConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"` +} + +func (x *PoetInfoResponse) Reset() { + *x = PoetInfoResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PoetInfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PoetInfoResponse) ProtoMessage() {} + +func (x *PoetInfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PoetInfoResponse.ProtoReflect.Descriptor instead. +func (*PoetInfoResponse) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{23} +} + +func (x *PoetInfoResponse) GetPoets() []string { + if x != nil { + return x.Poets + } + return nil +} + +func (x *PoetInfoResponse) GetConfig() *PoetConfig { + if x != nil { + return x.Config + } + return nil +} + +// Proposals and eligibilities +type Eligibilities struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Eligibilities []*ProposalEligibility `protobuf:"bytes,5,rep,name=eligibilities,proto3" json:"eligibilities,omitempty"` +} + +func (x *Eligibilities) Reset() { + *x = Eligibilities{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Eligibilities) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Eligibilities) ProtoMessage() {} + +func (x *Eligibilities) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Eligibilities.ProtoReflect.Descriptor instead. +func (*Eligibilities) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{24} +} + +func (x *Eligibilities) GetEligibilities() []*ProposalEligibility { + if x != nil { + return x.Eligibilities + } + return nil +} + +type ProposalEligibility struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Layer uint32 `protobuf:"varint,1,opt,name=layer,proto3" json:"layer,omitempty"` + Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` +} + +func (x *ProposalEligibility) Reset() { + *x = ProposalEligibility{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProposalEligibility) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProposalEligibility) ProtoMessage() {} + +func (x *ProposalEligibility) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[25] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProposalEligibility.ProtoReflect.Descriptor instead. +func (*ProposalEligibility) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{25} +} + +func (x *ProposalEligibility) GetLayer() uint32 { + if x != nil { + return x.Layer + } + return 0 +} + +func (x *ProposalEligibility) GetCount() uint32 { + if x != nil { + return x.Count + } + return 0 +} + +type EpochEligibilities struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Epochs map[uint32]*Eligibilities `protobuf:"bytes,1,rep,name=epochs,proto3" json:"epochs,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *EpochEligibilities) Reset() { + *x = EpochEligibilities{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EpochEligibilities) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EpochEligibilities) ProtoMessage() {} + +func (x *EpochEligibilities) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[26] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EpochEligibilities.ProtoReflect.Descriptor instead. +func (*EpochEligibilities) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{26} +} + +func (x *EpochEligibilities) GetEpochs() map[uint32]*Eligibilities { + if x != nil { + return x.Epochs + } + return nil +} + +type EligibilitiesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *EligibilitiesRequest) Reset() { + *x = EligibilitiesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EligibilitiesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EligibilitiesRequest) ProtoMessage() {} + +func (x *EligibilitiesRequest) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[27] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EligibilitiesRequest.ProtoReflect.Descriptor instead. +func (*EligibilitiesRequest) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{27} +} + +type EligibilitiesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Identities map[string]*EpochEligibilities `protobuf:"bytes,1,rep,name=identities,proto3" json:"identities,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *EligibilitiesResponse) Reset() { + *x = EligibilitiesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EligibilitiesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EligibilitiesResponse) ProtoMessage() {} + +func (x *EligibilitiesResponse) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[28] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EligibilitiesResponse.ProtoReflect.Descriptor instead. +func (*EligibilitiesResponse) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{28} +} + +func (x *EligibilitiesResponse) GetIdentities() map[string]*EpochEligibilities { + if x != nil { + return x.Identities + } + return nil +} + +type ProposalsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ProposalsRequest) Reset() { + *x = ProposalsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProposalsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProposalsRequest) ProtoMessage() {} + +func (x *ProposalsRequest) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[29] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProposalsRequest.ProtoReflect.Descriptor instead. +func (*ProposalsRequest) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{29} +} + +type Proposal struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Layer uint32 `protobuf:"varint,1,opt,name=layer,proto3" json:"layer,omitempty"` + Proposal []byte `protobuf:"bytes,2,opt,name=proposal,proto3" json:"proposal,omitempty"` +} + +func (x *Proposal) Reset() { + *x = Proposal{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Proposal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Proposal) ProtoMessage() {} + +func (x *Proposal) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[30] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Proposal.ProtoReflect.Descriptor instead. +func (*Proposal) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{30} +} + +func (x *Proposal) GetLayer() uint32 { + if x != nil { + return x.Layer + } + return 0 +} + +func (x *Proposal) GetProposal() []byte { + if x != nil { + return x.Proposal + } + return nil +} + +type Proposals struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Proposals []*Proposal `protobuf:"bytes,1,rep,name=proposals,proto3" json:"proposals,omitempty"` +} + +func (x *Proposals) Reset() { + *x = Proposals{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Proposals) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Proposals) ProtoMessage() {} + +func (x *Proposals) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[31] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Proposals.ProtoReflect.Descriptor instead. +func (*Proposals) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{31} +} + +func (x *Proposals) GetProposals() []*Proposal { + if x != nil { + return x.Proposals + } + return nil +} + +type ProposalsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Proposals map[string]*Proposals `protobuf:"bytes,1,rep,name=proposals,proto3" json:"proposals,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *ProposalsResponse) Reset() { + *x = ProposalsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProposalsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProposalsResponse) ProtoMessage() {} + +func (x *ProposalsResponse) ProtoReflect() protoreflect.Message { + mi := &file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[32] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProposalsResponse.ProtoReflect.Descriptor instead. +func (*ProposalsResponse) Descriptor() ([]byte, []int) { + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP(), []int{32} +} + +func (x *ProposalsResponse) GetProposals() map[string]*Proposals { + if x != nil { + return x.Proposals + } + return nil +} + +var File_spacemesh_v2alpha1_smeshing_identities_proto protoreflect.FileDescriptor + +var file_spacemesh_v2alpha1_smeshing_identities_proto_rawDesc = []byte{ + 0x0a, 0x2c, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2f, 0x76, 0x32, 0x61, 0x6c, + 0x70, 0x68, 0x61, 0x31, 0x2f, 0x73, 0x6d, 0x65, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, + 0x61, 0x31, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, + 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x69, 0x73, + 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, + 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x17, 0x0a, 0x15, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x22, 0x29, 0x0a, 0x0d, 0x52, 0x65, 0x74, 0x72, 0x79, 0x69, 0x6e, 0x67, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, + 0x17, 0x0a, 0x15, 0x57, 0x61, 0x69, 0x74, 0x46, 0x6f, 0x72, 0x41, 0x74, 0x78, 0x53, 0x79, 0x6e, + 0x63, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x22, 0x27, 0x0a, 0x25, 0x57, 0x61, 0x69, 0x74, + 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x65, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x22, 0x19, 0x0a, 0x17, 0x50, 0x6f, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, + 0x67, 0x65, 0x52, 0x65, 0x61, 0x64, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x22, 0xa7, 0x01, 0x0a, + 0x10, 0x50, 0x6f, 0x45, 0x54, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x5f, 0x68, + 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x63, 0x68, 0x61, 0x6c, 0x6c, + 0x65, 0x6e, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x49, 0x64, 0x12, 0x37, 0x0a, + 0x09, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x65, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x08, 0x72, 0x6f, + 0x75, 0x6e, 0x64, 0x45, 0x6e, 0x64, 0x22, 0x61, 0x0a, 0x13, 0x50, 0x6f, 0x65, 0x74, 0x52, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x4a, 0x0a, + 0x0d, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, + 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x6f, 0x45, 0x54, 0x52, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x72, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x9b, 0x01, 0x0a, 0x18, 0x57, 0x61, + 0x69, 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x6e, 0x64, 0x45, 0x6e, + 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x09, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, + 0x65, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x08, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x45, 0x6e, 0x64, 0x12, + 0x46, 0x0a, 0x11, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, + 0x5f, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x45, + 0x70, 0x6f, 0x63, 0x68, 0x45, 0x6e, 0x64, 0x22, 0x33, 0x0a, 0x16, 0x50, 0x6f, 0x65, 0x74, 0x50, + 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x6f, 0x65, 0x74, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x65, 0x74, 0x55, 0x72, 0x6c, 0x22, 0x1a, 0x0a, 0x18, + 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x74, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x53, 0x74, 0x61, 0x74, 0x65, 0x22, 0x15, 0x0a, 0x13, 0x50, 0x6f, 0x73, 0x74, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x61, 0x64, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x22, + 0x0f, 0x0a, 0x0d, 0x41, 0x74, 0x78, 0x52, 0x65, 0x61, 0x64, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x22, 0x2c, 0x0a, 0x13, 0x41, 0x74, 0x78, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, + 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x61, 0x74, 0x78, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x61, 0x74, 0x78, 0x49, 0x64, 0x22, 0x4a, + 0x0a, 0x18, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x46, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x68, 0x0a, 0x1a, 0x50, 0x72, + 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x46, 0x61, 0x69, + 0x6c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x14, + 0x0a, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, + 0x61, 0x79, 0x65, 0x72, 0x22, 0x4a, 0x0a, 0x16, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, + 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1a, + 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, + 0x79, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, + 0x22, 0x39, 0x0a, 0x0b, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, + 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x43, 0x0a, 0x08, 0x45, + 0x6c, 0x69, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x12, 0x37, 0x0a, 0x06, 0x6c, 0x61, 0x79, 0x65, 0x72, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, + 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x6c, 0x69, + 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x06, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, + 0x22, 0x9e, 0x0c, 0x0a, 0x11, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x37, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, + 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x28, 0x0a, 0x0d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x01, 0x52, 0x0c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, + 0x68, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x3f, 0x0a, 0x08, 0x72, 0x65, 0x74, + 0x72, 0x79, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, + 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, + 0x52, 0x08, 0x72, 0x65, 0x74, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x12, 0x5a, 0x0a, 0x13, 0x77, 0x61, + 0x69, 0x74, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x61, 0x74, 0x78, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x65, + 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, + 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x57, 0x61, 0x69, + 0x74, 0x46, 0x6f, 0x72, 0x41, 0x74, 0x78, 0x53, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x48, 0x00, 0x52, 0x10, 0x77, 0x61, 0x69, 0x74, 0x46, 0x6f, 0x72, 0x41, 0x74, 0x78, + 0x53, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x12, 0x8b, 0x01, 0x0a, 0x24, 0x77, 0x61, 0x69, 0x74, 0x69, + 0x6e, 0x67, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, + 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x57, 0x61, 0x69, 0x74, 0x69, + 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x65, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x48, 0x00, 0x52, 0x20, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x50, 0x6f, + 0x65, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x12, 0x5f, 0x0a, 0x14, 0x70, 0x6f, 0x65, 0x74, 0x5f, 0x63, 0x68, 0x61, + 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, + 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x6f, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6c, + 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x61, 0x64, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, + 0x00, 0x52, 0x12, 0x70, 0x6f, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, + 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x52, 0x0a, 0x0f, 0x70, 0x6f, 0x65, 0x74, 0x5f, 0x72, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, + 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, + 0x68, 0x61, 0x31, 0x2e, 0x50, 0x6f, 0x65, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x70, 0x6f, 0x65, 0x74, 0x52, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x12, 0x64, 0x0a, 0x17, 0x77, 0x61, 0x69, + 0x74, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x65, 0x74, 0x5f, 0x72, 0x6f, 0x75, 0x6e, 0x64, + 0x5f, 0x65, 0x6e, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, + 0x57, 0x61, 0x69, 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x6e, 0x64, + 0x45, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x13, 0x77, 0x61, 0x69, 0x74, + 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x6e, 0x64, 0x45, 0x6e, 0x64, 0x12, + 0x5c, 0x0a, 0x13, 0x70, 0x6f, 0x65, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x72, 0x65, + 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, + 0x31, 0x2e, 0x50, 0x6f, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x63, 0x65, 0x69, + 0x76, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x11, 0x70, 0x6f, 0x65, 0x74, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x12, 0x62, 0x0a, + 0x15, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x73, 0x74, + 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, + 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x74, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x13, 0x67, 0x65, + 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 0x12, 0x53, 0x0a, 0x10, 0x70, 0x6f, 0x73, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, + 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, + 0x2e, 0x50, 0x6f, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x61, 0x64, 0x79, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x70, 0x6f, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x40, 0x0a, 0x09, 0x61, 0x74, 0x78, 0x5f, 0x72, 0x65, + 0x61, 0x64, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, + 0x74, 0x78, 0x52, 0x65, 0x61, 0x64, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x08, + 0x61, 0x74, 0x78, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x52, 0x0a, 0x0f, 0x61, 0x74, 0x78, 0x5f, + 0x62, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x65, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x74, 0x78, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, + 0x61, 0x73, 0x74, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x61, 0x74, + 0x78, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x65, 0x64, 0x12, 0x62, 0x0a, 0x15, + 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x66, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, + 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x46, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x13, 0x70, 0x72, 0x6f, + 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, + 0x12, 0x68, 0x0a, 0x17, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x70, 0x75, 0x62, + 0x6c, 0x69, 0x73, 0x68, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18, 0x10, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2e, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x50, + 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x48, 0x00, 0x52, 0x15, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x50, 0x75, 0x62, + 0x6c, 0x69, 0x73, 0x68, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x12, 0x5b, 0x0a, 0x12, 0x70, 0x72, + 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, + 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, + 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, + 0x6f, 0x73, 0x61, 0x6c, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x48, 0x00, 0x52, 0x11, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x50, 0x75, + 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x6c, 0x69, 0x67, 0x69, + 0x62, 0x6c, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, + 0x6c, 0x69, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x48, 0x00, 0x52, 0x08, 0x65, 0x6c, 0x69, 0x67, 0x69, + 0x62, 0x6c, 0x65, 0x42, 0x0a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, + 0x10, 0x0a, 0x0e, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x5f, 0x65, 0x70, 0x6f, 0x63, + 0x68, 0x22, 0x4b, 0x0a, 0x08, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x3f, 0x0a, + 0x07, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, + 0x68, 0x61, 0x31, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x22, 0xd1, + 0x01, 0x0a, 0x16, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5a, 0x0a, 0x0a, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, + 0x61, 0x31, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x5b, 0x0a, 0x0f, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x32, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0x11, 0x0a, 0x0f, 0x50, 0x6f, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x80, 0x01, 0x0a, 0x0a, 0x50, 0x6f, 0x65, 0x74, 0x43, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x12, 0x3a, 0x0a, 0x0b, 0x70, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x73, 0x68, + 0x69, 0x66, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x70, 0x68, 0x61, 0x73, 0x65, 0x53, 0x68, 0x69, 0x66, 0x74, + 0x12, 0x36, 0x0a, 0x09, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x5f, 0x67, 0x61, 0x70, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, + 0x63, 0x79, 0x63, 0x6c, 0x65, 0x47, 0x61, 0x70, 0x22, 0x60, 0x0a, 0x10, 0x50, 0x6f, 0x65, 0x74, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x70, 0x6f, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x6f, 0x65, + 0x74, 0x73, 0x12, 0x36, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, + 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x6f, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x5e, 0x0a, 0x0d, 0x45, 0x6c, + 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x4d, 0x0a, 0x0d, 0x65, + 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, + 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, + 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0d, 0x65, 0x6c, 0x69, + 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x41, 0x0a, 0x13, 0x50, 0x72, + 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xbe, 0x01, + 0x0a, 0x12, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, + 0x74, 0x69, 0x65, 0x73, 0x12, 0x4a, 0x0a, 0x06, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, + 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x45, + 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x45, 0x70, 0x6f, + 0x63, 0x68, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, + 0x1a, 0x5c, 0x0a, 0x0b, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x37, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x21, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, + 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, + 0x69, 0x65, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x16, + 0x0a, 0x14, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xd9, 0x01, 0x0a, 0x15, 0x45, 0x6c, 0x69, 0x67, 0x69, + 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x59, 0x0a, 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, + 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, + 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x65, 0x0a, 0x0f, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x3c, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x26, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, + 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, + 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0x12, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x3c, 0x0a, 0x08, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, + 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x70, + 0x6f, 0x73, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x70, + 0x6f, 0x73, 0x61, 0x6c, 0x22, 0x47, 0x0a, 0x09, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, + 0x73, 0x12, 0x3a, 0x0a, 0x09, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, + 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, + 0x61, 0x6c, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x22, 0xc4, 0x01, + 0x0a, 0x11, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x52, 0x0a, 0x09, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, + 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, + 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x50, 0x72, + 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x70, 0x72, + 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x1a, 0x5b, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x70, 0x6f, + 0x73, 0x61, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x33, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, + 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x2a, 0x89, 0x03, 0x0a, 0x0d, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, + 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x57, 0x41, 0x49, 0x54, 0x5f, + 0x46, 0x4f, 0x52, 0x5f, 0x41, 0x54, 0x58, 0x5f, 0x53, 0x59, 0x4e, 0x43, 0x45, 0x44, 0x10, 0x01, + 0x12, 0x0c, 0x0a, 0x08, 0x52, 0x45, 0x54, 0x52, 0x59, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x28, + 0x0a, 0x24, 0x57, 0x41, 0x49, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x46, 0x4f, 0x52, 0x5f, 0x50, 0x4f, + 0x45, 0x54, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x53, 0x54, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x57, 0x49, 0x4e, 0x44, 0x4f, 0x57, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x50, 0x4f, 0x45, 0x54, + 0x5f, 0x43, 0x48, 0x41, 0x4c, 0x4c, 0x45, 0x4e, 0x47, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x59, + 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x4f, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x47, 0x49, 0x53, + 0x54, 0x45, 0x52, 0x45, 0x44, 0x10, 0x05, 0x12, 0x1b, 0x0a, 0x17, 0x57, 0x41, 0x49, 0x54, 0x5f, + 0x46, 0x4f, 0x52, 0x5f, 0x50, 0x4f, 0x45, 0x54, 0x5f, 0x52, 0x4f, 0x55, 0x4e, 0x44, 0x5f, 0x45, + 0x4e, 0x44, 0x10, 0x06, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x4f, 0x45, 0x54, 0x5f, 0x50, 0x52, 0x4f, + 0x4f, 0x46, 0x5f, 0x52, 0x45, 0x43, 0x45, 0x49, 0x56, 0x45, 0x44, 0x10, 0x07, 0x12, 0x19, 0x0a, + 0x15, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x50, 0x4f, 0x53, 0x54, + 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x10, 0x08, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x4f, 0x53, 0x54, + 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x09, 0x12, 0x0d, + 0x0a, 0x09, 0x41, 0x54, 0x58, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x0a, 0x12, 0x13, 0x0a, + 0x0f, 0x41, 0x54, 0x58, 0x5f, 0x42, 0x52, 0x4f, 0x41, 0x44, 0x43, 0x41, 0x53, 0x54, 0x45, 0x44, + 0x10, 0x0b, 0x12, 0x19, 0x0a, 0x15, 0x50, 0x52, 0x4f, 0x50, 0x4f, 0x53, 0x41, 0x4c, 0x5f, 0x42, + 0x55, 0x49, 0x4c, 0x44, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x0c, 0x12, 0x1b, 0x0a, + 0x17, 0x50, 0x52, 0x4f, 0x50, 0x4f, 0x53, 0x41, 0x4c, 0x5f, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x53, + 0x48, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x0d, 0x12, 0x16, 0x0a, 0x12, 0x50, 0x52, + 0x4f, 0x50, 0x4f, 0x53, 0x41, 0x4c, 0x5f, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x53, 0x48, 0x45, 0x44, + 0x10, 0x0e, 0x12, 0x0c, 0x0a, 0x08, 0x45, 0x4c, 0x49, 0x47, 0x49, 0x42, 0x4c, 0x45, 0x10, 0x0f, + 0x32, 0xa7, 0x03, 0x0a, 0x19, 0x53, 0x6d, 0x65, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x61, + 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x29, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, + 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x57, 0x0a, 0x08, 0x50, 0x6f, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x23, 0x2e, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, + 0x61, 0x31, 0x2e, 0x50, 0x6f, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, + 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x6f, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x0d, 0x45, 0x6c, + 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x28, 0x2e, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, + 0x2e, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, + 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x45, 0x6c, 0x69, 0x67, 0x69, + 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x09, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x12, + 0x24, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, + 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, + 0x68, 0x2e, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, + 0x73, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x1a, 0x0a, + 0xfa, 0xd2, 0xe4, 0x93, 0x02, 0x04, 0x12, 0x02, 0x56, 0x32, 0x42, 0xe6, 0x01, 0x0a, 0x16, 0x63, + 0x6f, 0x6d, 0x2e, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x32, 0x61, + 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x17, 0x53, 0x6d, 0x65, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, + 0x5a, 0x4a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x6f, 0x73, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x72, 0x65, 0x6c, + 0x65, 0x61, 0x73, 0x65, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, + 0x68, 0x2f, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x6d, 0x65, 0x73, 0x68, 0x76, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x53, + 0x58, 0x58, 0xaa, 0x02, 0x12, 0x53, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x56, + 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x12, 0x53, 0x70, 0x61, 0x63, 0x65, 0x6d, + 0x65, 0x73, 0x68, 0x5c, 0x56, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xe2, 0x02, 0x1e, 0x53, + 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x5c, 0x56, 0x32, 0x61, 0x6c, 0x70, 0x68, 0x61, + 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, + 0x53, 0x70, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x73, 0x68, 0x3a, 0x3a, 0x56, 0x32, 0x61, 0x6c, 0x70, + 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescOnce sync.Once + file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescData = file_spacemesh_v2alpha1_smeshing_identities_proto_rawDesc +) + +func file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescGZIP() []byte { + file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescOnce.Do(func() { + file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescData = protoimpl.X.CompressGZIP(file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescData) + }) + return file_spacemesh_v2alpha1_smeshing_identities_proto_rawDescData +} + +var file_spacemesh_v2alpha1_smeshing_identities_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes = make([]protoimpl.MessageInfo, 37) +var file_spacemesh_v2alpha1_smeshing_identities_proto_goTypes = []interface{}{ + (IdentityState)(0), // 0: spacemesh.v2alpha1.IdentityState + (*IdentityStatesRequest)(nil), // 1: spacemesh.v2alpha1.IdentityStatesRequest + (*RetryingState)(nil), // 2: spacemesh.v2alpha1.RetryingState + (*WaitForAtxSyncedState)(nil), // 3: spacemesh.v2alpha1.WaitForAtxSyncedState + (*WaitingForPoetRegistrationWindowState)(nil), // 4: spacemesh.v2alpha1.WaitingForPoetRegistrationWindowState + (*PoetChallengeReadyState)(nil), // 5: spacemesh.v2alpha1.PoetChallengeReadyState + (*PoETRegistration)(nil), // 6: spacemesh.v2alpha1.PoETRegistration + (*PoetRegisteredState)(nil), // 7: spacemesh.v2alpha1.PoetRegisteredState + (*WaitForPoetRoundEndState)(nil), // 8: spacemesh.v2alpha1.WaitForPoetRoundEndState + (*PoetProofReceivedState)(nil), // 9: spacemesh.v2alpha1.PoetProofReceivedState + (*GeneratingPostProofState)(nil), // 10: spacemesh.v2alpha1.GeneratingPostProofState + (*PostProofReadyState)(nil), // 11: spacemesh.v2alpha1.PostProofReadyState + (*AtxReadyState)(nil), // 12: spacemesh.v2alpha1.AtxReadyState + (*AtxBroadcastedState)(nil), // 13: spacemesh.v2alpha1.AtxBroadcastedState + (*ProposalBuildFailedState)(nil), // 14: spacemesh.v2alpha1.ProposalBuildFailedState + (*ProposalPublishFailedState)(nil), // 15: spacemesh.v2alpha1.ProposalPublishFailedState + (*ProposalPublishedState)(nil), // 16: spacemesh.v2alpha1.ProposalPublishedState + (*Eligibility)(nil), // 17: spacemesh.v2alpha1.Eligibility + (*Eligible)(nil), // 18: spacemesh.v2alpha1.Eligible + (*IdentityStateInfo)(nil), // 19: spacemesh.v2alpha1.IdentityStateInfo + (*Identity)(nil), // 20: spacemesh.v2alpha1.Identity + (*IdentityStatesResponse)(nil), // 21: spacemesh.v2alpha1.IdentityStatesResponse + (*PoetInfoRequest)(nil), // 22: spacemesh.v2alpha1.PoetInfoRequest + (*PoetConfig)(nil), // 23: spacemesh.v2alpha1.PoetConfig + (*PoetInfoResponse)(nil), // 24: spacemesh.v2alpha1.PoetInfoResponse + (*Eligibilities)(nil), // 25: spacemesh.v2alpha1.Eligibilities + (*ProposalEligibility)(nil), // 26: spacemesh.v2alpha1.ProposalEligibility + (*EpochEligibilities)(nil), // 27: spacemesh.v2alpha1.EpochEligibilities + (*EligibilitiesRequest)(nil), // 28: spacemesh.v2alpha1.EligibilitiesRequest + (*EligibilitiesResponse)(nil), // 29: spacemesh.v2alpha1.EligibilitiesResponse + (*ProposalsRequest)(nil), // 30: spacemesh.v2alpha1.ProposalsRequest + (*Proposal)(nil), // 31: spacemesh.v2alpha1.Proposal + (*Proposals)(nil), // 32: spacemesh.v2alpha1.Proposals + (*ProposalsResponse)(nil), // 33: spacemesh.v2alpha1.ProposalsResponse + nil, // 34: spacemesh.v2alpha1.IdentityStatesResponse.IdentitiesEntry + nil, // 35: spacemesh.v2alpha1.EpochEligibilities.EpochsEntry + nil, // 36: spacemesh.v2alpha1.EligibilitiesResponse.IdentitiesEntry + nil, // 37: spacemesh.v2alpha1.ProposalsResponse.ProposalsEntry + (*timestamppb.Timestamp)(nil), // 38: google.protobuf.Timestamp + (*durationpb.Duration)(nil), // 39: google.protobuf.Duration +} +var file_spacemesh_v2alpha1_smeshing_identities_proto_depIdxs = []int32{ + 38, // 0: spacemesh.v2alpha1.PoETRegistration.round_end:type_name -> google.protobuf.Timestamp + 6, // 1: spacemesh.v2alpha1.PoetRegisteredState.registrations:type_name -> spacemesh.v2alpha1.PoETRegistration + 38, // 2: spacemesh.v2alpha1.WaitForPoetRoundEndState.round_end:type_name -> google.protobuf.Timestamp + 38, // 3: spacemesh.v2alpha1.WaitForPoetRoundEndState.publish_epoch_end:type_name -> google.protobuf.Timestamp + 17, // 4: spacemesh.v2alpha1.Eligible.layers:type_name -> spacemesh.v2alpha1.Eligibility + 0, // 5: spacemesh.v2alpha1.IdentityStateInfo.state:type_name -> spacemesh.v2alpha1.IdentityState + 38, // 6: spacemesh.v2alpha1.IdentityStateInfo.time:type_name -> google.protobuf.Timestamp + 2, // 7: spacemesh.v2alpha1.IdentityStateInfo.retrying:type_name -> spacemesh.v2alpha1.RetryingState + 3, // 8: spacemesh.v2alpha1.IdentityStateInfo.wait_for_atx_synced:type_name -> spacemesh.v2alpha1.WaitForAtxSyncedState + 4, // 9: spacemesh.v2alpha1.IdentityStateInfo.waiting_for_poet_registration_window:type_name -> spacemesh.v2alpha1.WaitingForPoetRegistrationWindowState + 5, // 10: spacemesh.v2alpha1.IdentityStateInfo.poet_challenge_ready:type_name -> spacemesh.v2alpha1.PoetChallengeReadyState + 7, // 11: spacemesh.v2alpha1.IdentityStateInfo.poet_registered:type_name -> spacemesh.v2alpha1.PoetRegisteredState + 8, // 12: spacemesh.v2alpha1.IdentityStateInfo.wait_for_poet_round_end:type_name -> spacemesh.v2alpha1.WaitForPoetRoundEndState + 9, // 13: spacemesh.v2alpha1.IdentityStateInfo.poet_proof_received:type_name -> spacemesh.v2alpha1.PoetProofReceivedState + 10, // 14: spacemesh.v2alpha1.IdentityStateInfo.generating_post_proof:type_name -> spacemesh.v2alpha1.GeneratingPostProofState + 11, // 15: spacemesh.v2alpha1.IdentityStateInfo.post_proof_ready:type_name -> spacemesh.v2alpha1.PostProofReadyState + 12, // 16: spacemesh.v2alpha1.IdentityStateInfo.atx_ready:type_name -> spacemesh.v2alpha1.AtxReadyState + 13, // 17: spacemesh.v2alpha1.IdentityStateInfo.atx_broadcasted:type_name -> spacemesh.v2alpha1.AtxBroadcastedState + 14, // 18: spacemesh.v2alpha1.IdentityStateInfo.proposal_build_failed:type_name -> spacemesh.v2alpha1.ProposalBuildFailedState + 15, // 19: spacemesh.v2alpha1.IdentityStateInfo.proposal_publish_failed:type_name -> spacemesh.v2alpha1.ProposalPublishFailedState + 16, // 20: spacemesh.v2alpha1.IdentityStateInfo.proposal_published:type_name -> spacemesh.v2alpha1.ProposalPublishedState + 18, // 21: spacemesh.v2alpha1.IdentityStateInfo.eligible:type_name -> spacemesh.v2alpha1.Eligible + 19, // 22: spacemesh.v2alpha1.Identity.history:type_name -> spacemesh.v2alpha1.IdentityStateInfo + 34, // 23: spacemesh.v2alpha1.IdentityStatesResponse.identities:type_name -> spacemesh.v2alpha1.IdentityStatesResponse.IdentitiesEntry + 39, // 24: spacemesh.v2alpha1.PoetConfig.phase_shift:type_name -> google.protobuf.Duration + 39, // 25: spacemesh.v2alpha1.PoetConfig.cycle_gap:type_name -> google.protobuf.Duration + 23, // 26: spacemesh.v2alpha1.PoetInfoResponse.config:type_name -> spacemesh.v2alpha1.PoetConfig + 26, // 27: spacemesh.v2alpha1.Eligibilities.eligibilities:type_name -> spacemesh.v2alpha1.ProposalEligibility + 35, // 28: spacemesh.v2alpha1.EpochEligibilities.epochs:type_name -> spacemesh.v2alpha1.EpochEligibilities.EpochsEntry + 36, // 29: spacemesh.v2alpha1.EligibilitiesResponse.identities:type_name -> spacemesh.v2alpha1.EligibilitiesResponse.IdentitiesEntry + 31, // 30: spacemesh.v2alpha1.Proposals.proposals:type_name -> spacemesh.v2alpha1.Proposal + 37, // 31: spacemesh.v2alpha1.ProposalsResponse.proposals:type_name -> spacemesh.v2alpha1.ProposalsResponse.ProposalsEntry + 20, // 32: spacemesh.v2alpha1.IdentityStatesResponse.IdentitiesEntry.value:type_name -> spacemesh.v2alpha1.Identity + 25, // 33: spacemesh.v2alpha1.EpochEligibilities.EpochsEntry.value:type_name -> spacemesh.v2alpha1.Eligibilities + 27, // 34: spacemesh.v2alpha1.EligibilitiesResponse.IdentitiesEntry.value:type_name -> spacemesh.v2alpha1.EpochEligibilities + 32, // 35: spacemesh.v2alpha1.ProposalsResponse.ProposalsEntry.value:type_name -> spacemesh.v2alpha1.Proposals + 1, // 36: spacemesh.v2alpha1.SmeshingIdentitiesService.States:input_type -> spacemesh.v2alpha1.IdentityStatesRequest + 22, // 37: spacemesh.v2alpha1.SmeshingIdentitiesService.PoetInfo:input_type -> spacemesh.v2alpha1.PoetInfoRequest + 28, // 38: spacemesh.v2alpha1.SmeshingIdentitiesService.Eligibilities:input_type -> spacemesh.v2alpha1.EligibilitiesRequest + 30, // 39: spacemesh.v2alpha1.SmeshingIdentitiesService.Proposals:input_type -> spacemesh.v2alpha1.ProposalsRequest + 21, // 40: spacemesh.v2alpha1.SmeshingIdentitiesService.States:output_type -> spacemesh.v2alpha1.IdentityStatesResponse + 24, // 41: spacemesh.v2alpha1.SmeshingIdentitiesService.PoetInfo:output_type -> spacemesh.v2alpha1.PoetInfoResponse + 29, // 42: spacemesh.v2alpha1.SmeshingIdentitiesService.Eligibilities:output_type -> spacemesh.v2alpha1.EligibilitiesResponse + 33, // 43: spacemesh.v2alpha1.SmeshingIdentitiesService.Proposals:output_type -> spacemesh.v2alpha1.ProposalsResponse + 40, // [40:44] is the sub-list for method output_type + 36, // [36:40] is the sub-list for method input_type + 36, // [36:36] is the sub-list for extension type_name + 36, // [36:36] is the sub-list for extension extendee + 0, // [0:36] is the sub-list for field type_name +} + +func init() { file_spacemesh_v2alpha1_smeshing_identities_proto_init() } +func file_spacemesh_v2alpha1_smeshing_identities_proto_init() { + if File_spacemesh_v2alpha1_smeshing_identities_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IdentityStatesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RetryingState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WaitForAtxSyncedState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WaitingForPoetRegistrationWindowState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PoetChallengeReadyState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PoETRegistration); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PoetRegisteredState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WaitForPoetRoundEndState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PoetProofReceivedState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GeneratingPostProofState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PostProofReadyState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AtxReadyState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AtxBroadcastedState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProposalBuildFailedState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProposalPublishFailedState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProposalPublishedState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Eligibility); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Eligible); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IdentityStateInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Identity); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IdentityStatesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PoetInfoRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PoetConfig); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PoetInfoResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Eligibilities); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProposalEligibility); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EpochEligibilities); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EligibilitiesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EligibilitiesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProposalsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Proposal); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Proposals); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProposalsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes[18].OneofWrappers = []interface{}{ + (*IdentityStateInfo_Retrying)(nil), + (*IdentityStateInfo_WaitForAtxSynced)(nil), + (*IdentityStateInfo_WaitingForPoetRegistrationWindow)(nil), + (*IdentityStateInfo_PoetChallengeReady)(nil), + (*IdentityStateInfo_PoetRegistered)(nil), + (*IdentityStateInfo_WaitForPoetRoundEnd)(nil), + (*IdentityStateInfo_PoetProofReceived)(nil), + (*IdentityStateInfo_GeneratingPostProof)(nil), + (*IdentityStateInfo_PostProofReady)(nil), + (*IdentityStateInfo_AtxReady)(nil), + (*IdentityStateInfo_AtxBroadcasted)(nil), + (*IdentityStateInfo_ProposalBuildFailed)(nil), + (*IdentityStateInfo_ProposalPublishFailed)(nil), + (*IdentityStateInfo_ProposalPublished)(nil), + (*IdentityStateInfo_Eligible)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_spacemesh_v2alpha1_smeshing_identities_proto_rawDesc, + NumEnums: 1, + NumMessages: 37, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_spacemesh_v2alpha1_smeshing_identities_proto_goTypes, + DependencyIndexes: file_spacemesh_v2alpha1_smeshing_identities_proto_depIdxs, + EnumInfos: file_spacemesh_v2alpha1_smeshing_identities_proto_enumTypes, + MessageInfos: file_spacemesh_v2alpha1_smeshing_identities_proto_msgTypes, + }.Build() + File_spacemesh_v2alpha1_smeshing_identities_proto = out.File + file_spacemesh_v2alpha1_smeshing_identities_proto_rawDesc = nil + file_spacemesh_v2alpha1_smeshing_identities_proto_goTypes = nil + file_spacemesh_v2alpha1_smeshing_identities_proto_depIdxs = nil +} diff --git a/release/go/spacemesh/v2alpha1/smeshing_identities.pb.gw.go b/release/go/spacemesh/v2alpha1/smeshing_identities.pb.gw.go new file mode 100644 index 00000000..5a8cb6b6 --- /dev/null +++ b/release/go/spacemesh/v2alpha1/smeshing_identities.pb.gw.go @@ -0,0 +1,394 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: spacemesh/v2alpha1/smeshing_identities.proto + +/* +Package spacemeshv2alpha1 is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package spacemeshv2alpha1 + +import ( + "context" + "io" + "net/http" + + "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "github.com/grpc-ecosystem/grpc-gateway/v2/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = metadata.Join + +func request_SmeshingIdentitiesService_States_0(ctx context.Context, marshaler runtime.Marshaler, client SmeshingIdentitiesServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq IdentityStatesRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.States(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SmeshingIdentitiesService_States_0(ctx context.Context, marshaler runtime.Marshaler, server SmeshingIdentitiesServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq IdentityStatesRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.States(ctx, &protoReq) + return msg, metadata, err + +} + +func request_SmeshingIdentitiesService_PoetInfo_0(ctx context.Context, marshaler runtime.Marshaler, client SmeshingIdentitiesServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq PoetInfoRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.PoetInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SmeshingIdentitiesService_PoetInfo_0(ctx context.Context, marshaler runtime.Marshaler, server SmeshingIdentitiesServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq PoetInfoRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.PoetInfo(ctx, &protoReq) + return msg, metadata, err + +} + +func request_SmeshingIdentitiesService_Eligibilities_0(ctx context.Context, marshaler runtime.Marshaler, client SmeshingIdentitiesServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq EligibilitiesRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Eligibilities(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SmeshingIdentitiesService_Eligibilities_0(ctx context.Context, marshaler runtime.Marshaler, server SmeshingIdentitiesServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq EligibilitiesRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.Eligibilities(ctx, &protoReq) + return msg, metadata, err + +} + +func request_SmeshingIdentitiesService_Proposals_0(ctx context.Context, marshaler runtime.Marshaler, client SmeshingIdentitiesServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ProposalsRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.Proposals(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_SmeshingIdentitiesService_Proposals_0(ctx context.Context, marshaler runtime.Marshaler, server SmeshingIdentitiesServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ProposalsRequest + var metadata runtime.ServerMetadata + + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.Proposals(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterSmeshingIdentitiesServiceHandlerServer registers the http handlers for service SmeshingIdentitiesService to "mux". +// UnaryRPC :call SmeshingIdentitiesServiceServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSmeshingIdentitiesServiceHandlerFromEndpoint instead. +func RegisterSmeshingIdentitiesServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SmeshingIdentitiesServiceServer) error { + + mux.Handle("POST", pattern_SmeshingIdentitiesService_States_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/spacemesh.v2alpha1.SmeshingIdentitiesService/States", runtime.WithHTTPPathPattern("/spacemesh.v2alpha1.SmeshingIdentitiesService/States")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SmeshingIdentitiesService_States_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SmeshingIdentitiesService_States_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_SmeshingIdentitiesService_PoetInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/spacemesh.v2alpha1.SmeshingIdentitiesService/PoetInfo", runtime.WithHTTPPathPattern("/spacemesh.v2alpha1.SmeshingIdentitiesService/PoetInfo")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SmeshingIdentitiesService_PoetInfo_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SmeshingIdentitiesService_PoetInfo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_SmeshingIdentitiesService_Eligibilities_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/spacemesh.v2alpha1.SmeshingIdentitiesService/Eligibilities", runtime.WithHTTPPathPattern("/spacemesh.v2alpha1.SmeshingIdentitiesService/Eligibilities")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SmeshingIdentitiesService_Eligibilities_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SmeshingIdentitiesService_Eligibilities_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_SmeshingIdentitiesService_Proposals_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/spacemesh.v2alpha1.SmeshingIdentitiesService/Proposals", runtime.WithHTTPPathPattern("/spacemesh.v2alpha1.SmeshingIdentitiesService/Proposals")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SmeshingIdentitiesService_Proposals_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SmeshingIdentitiesService_Proposals_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterSmeshingIdentitiesServiceHandlerFromEndpoint is same as RegisterSmeshingIdentitiesServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterSmeshingIdentitiesServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.DialContext(ctx, endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterSmeshingIdentitiesServiceHandler(ctx, mux, conn) +} + +// RegisterSmeshingIdentitiesServiceHandler registers the http handlers for service SmeshingIdentitiesService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterSmeshingIdentitiesServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterSmeshingIdentitiesServiceHandlerClient(ctx, mux, NewSmeshingIdentitiesServiceClient(conn)) +} + +// RegisterSmeshingIdentitiesServiceHandlerClient registers the http handlers for service SmeshingIdentitiesService +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SmeshingIdentitiesServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SmeshingIdentitiesServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "SmeshingIdentitiesServiceClient" to call the correct interceptors. +func RegisterSmeshingIdentitiesServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SmeshingIdentitiesServiceClient) error { + + mux.Handle("POST", pattern_SmeshingIdentitiesService_States_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) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/spacemesh.v2alpha1.SmeshingIdentitiesService/States", runtime.WithHTTPPathPattern("/spacemesh.v2alpha1.SmeshingIdentitiesService/States")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SmeshingIdentitiesService_States_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SmeshingIdentitiesService_States_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_SmeshingIdentitiesService_PoetInfo_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) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/spacemesh.v2alpha1.SmeshingIdentitiesService/PoetInfo", runtime.WithHTTPPathPattern("/spacemesh.v2alpha1.SmeshingIdentitiesService/PoetInfo")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SmeshingIdentitiesService_PoetInfo_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SmeshingIdentitiesService_PoetInfo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_SmeshingIdentitiesService_Eligibilities_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) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/spacemesh.v2alpha1.SmeshingIdentitiesService/Eligibilities", runtime.WithHTTPPathPattern("/spacemesh.v2alpha1.SmeshingIdentitiesService/Eligibilities")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SmeshingIdentitiesService_Eligibilities_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SmeshingIdentitiesService_Eligibilities_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_SmeshingIdentitiesService_Proposals_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) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/spacemesh.v2alpha1.SmeshingIdentitiesService/Proposals", runtime.WithHTTPPathPattern("/spacemesh.v2alpha1.SmeshingIdentitiesService/Proposals")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SmeshingIdentitiesService_Proposals_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_SmeshingIdentitiesService_Proposals_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_SmeshingIdentitiesService_States_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"spacemesh.v2alpha1.SmeshingIdentitiesService", "States"}, "")) + + pattern_SmeshingIdentitiesService_PoetInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"spacemesh.v2alpha1.SmeshingIdentitiesService", "PoetInfo"}, "")) + + pattern_SmeshingIdentitiesService_Eligibilities_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"spacemesh.v2alpha1.SmeshingIdentitiesService", "Eligibilities"}, "")) + + pattern_SmeshingIdentitiesService_Proposals_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"spacemesh.v2alpha1.SmeshingIdentitiesService", "Proposals"}, "")) +) + +var ( + forward_SmeshingIdentitiesService_States_0 = runtime.ForwardResponseMessage + + forward_SmeshingIdentitiesService_PoetInfo_0 = runtime.ForwardResponseMessage + + forward_SmeshingIdentitiesService_Eligibilities_0 = runtime.ForwardResponseMessage + + forward_SmeshingIdentitiesService_Proposals_0 = runtime.ForwardResponseMessage +) diff --git a/release/go/spacemesh/v2alpha1/smeshing_identities_grpc.pb.go b/release/go/spacemesh/v2alpha1/smeshing_identities_grpc.pb.go new file mode 100644 index 00000000..22ce4c5c --- /dev/null +++ b/release/go/spacemesh/v2alpha1/smeshing_identities_grpc.pb.go @@ -0,0 +1,218 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: spacemesh/v2alpha1/smeshing_identities.proto + +package spacemeshv2alpha1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + SmeshingIdentitiesService_States_FullMethodName = "/spacemesh.v2alpha1.SmeshingIdentitiesService/States" + SmeshingIdentitiesService_PoetInfo_FullMethodName = "/spacemesh.v2alpha1.SmeshingIdentitiesService/PoetInfo" + SmeshingIdentitiesService_Eligibilities_FullMethodName = "/spacemesh.v2alpha1.SmeshingIdentitiesService/Eligibilities" + SmeshingIdentitiesService_Proposals_FullMethodName = "/spacemesh.v2alpha1.SmeshingIdentitiesService/Proposals" +) + +// SmeshingIdentitiesServiceClient is the client API for SmeshingIdentitiesService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type SmeshingIdentitiesServiceClient interface { + States(ctx context.Context, in *IdentityStatesRequest, opts ...grpc.CallOption) (*IdentityStatesResponse, error) + PoetInfo(ctx context.Context, in *PoetInfoRequest, opts ...grpc.CallOption) (*PoetInfoResponse, error) + Eligibilities(ctx context.Context, in *EligibilitiesRequest, opts ...grpc.CallOption) (*EligibilitiesResponse, error) + Proposals(ctx context.Context, in *ProposalsRequest, opts ...grpc.CallOption) (*ProposalsResponse, error) +} + +type smeshingIdentitiesServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewSmeshingIdentitiesServiceClient(cc grpc.ClientConnInterface) SmeshingIdentitiesServiceClient { + return &smeshingIdentitiesServiceClient{cc} +} + +func (c *smeshingIdentitiesServiceClient) States(ctx context.Context, in *IdentityStatesRequest, opts ...grpc.CallOption) (*IdentityStatesResponse, error) { + out := new(IdentityStatesResponse) + err := c.cc.Invoke(ctx, SmeshingIdentitiesService_States_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *smeshingIdentitiesServiceClient) PoetInfo(ctx context.Context, in *PoetInfoRequest, opts ...grpc.CallOption) (*PoetInfoResponse, error) { + out := new(PoetInfoResponse) + err := c.cc.Invoke(ctx, SmeshingIdentitiesService_PoetInfo_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *smeshingIdentitiesServiceClient) Eligibilities(ctx context.Context, in *EligibilitiesRequest, opts ...grpc.CallOption) (*EligibilitiesResponse, error) { + out := new(EligibilitiesResponse) + err := c.cc.Invoke(ctx, SmeshingIdentitiesService_Eligibilities_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *smeshingIdentitiesServiceClient) Proposals(ctx context.Context, in *ProposalsRequest, opts ...grpc.CallOption) (*ProposalsResponse, error) { + out := new(ProposalsResponse) + err := c.cc.Invoke(ctx, SmeshingIdentitiesService_Proposals_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// SmeshingIdentitiesServiceServer is the server API for SmeshingIdentitiesService service. +// All implementations should embed UnimplementedSmeshingIdentitiesServiceServer +// for forward compatibility +type SmeshingIdentitiesServiceServer interface { + States(context.Context, *IdentityStatesRequest) (*IdentityStatesResponse, error) + PoetInfo(context.Context, *PoetInfoRequest) (*PoetInfoResponse, error) + Eligibilities(context.Context, *EligibilitiesRequest) (*EligibilitiesResponse, error) + Proposals(context.Context, *ProposalsRequest) (*ProposalsResponse, error) +} + +// UnimplementedSmeshingIdentitiesServiceServer should be embedded to have forward compatible implementations. +type UnimplementedSmeshingIdentitiesServiceServer struct { +} + +func (UnimplementedSmeshingIdentitiesServiceServer) States(context.Context, *IdentityStatesRequest) (*IdentityStatesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method States not implemented") +} +func (UnimplementedSmeshingIdentitiesServiceServer) PoetInfo(context.Context, *PoetInfoRequest) (*PoetInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PoetInfo not implemented") +} +func (UnimplementedSmeshingIdentitiesServiceServer) Eligibilities(context.Context, *EligibilitiesRequest) (*EligibilitiesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Eligibilities not implemented") +} +func (UnimplementedSmeshingIdentitiesServiceServer) Proposals(context.Context, *ProposalsRequest) (*ProposalsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Proposals not implemented") +} + +// UnsafeSmeshingIdentitiesServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to SmeshingIdentitiesServiceServer will +// result in compilation errors. +type UnsafeSmeshingIdentitiesServiceServer interface { + mustEmbedUnimplementedSmeshingIdentitiesServiceServer() +} + +func RegisterSmeshingIdentitiesServiceServer(s grpc.ServiceRegistrar, srv SmeshingIdentitiesServiceServer) { + s.RegisterService(&SmeshingIdentitiesService_ServiceDesc, srv) +} + +func _SmeshingIdentitiesService_States_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IdentityStatesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SmeshingIdentitiesServiceServer).States(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SmeshingIdentitiesService_States_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SmeshingIdentitiesServiceServer).States(ctx, req.(*IdentityStatesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SmeshingIdentitiesService_PoetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PoetInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SmeshingIdentitiesServiceServer).PoetInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SmeshingIdentitiesService_PoetInfo_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SmeshingIdentitiesServiceServer).PoetInfo(ctx, req.(*PoetInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SmeshingIdentitiesService_Eligibilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EligibilitiesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SmeshingIdentitiesServiceServer).Eligibilities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SmeshingIdentitiesService_Eligibilities_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SmeshingIdentitiesServiceServer).Eligibilities(ctx, req.(*EligibilitiesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SmeshingIdentitiesService_Proposals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProposalsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SmeshingIdentitiesServiceServer).Proposals(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SmeshingIdentitiesService_Proposals_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SmeshingIdentitiesServiceServer).Proposals(ctx, req.(*ProposalsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// SmeshingIdentitiesService_ServiceDesc is the grpc.ServiceDesc for SmeshingIdentitiesService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var SmeshingIdentitiesService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "spacemesh.v2alpha1.SmeshingIdentitiesService", + HandlerType: (*SmeshingIdentitiesServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "States", + Handler: _SmeshingIdentitiesService_States_Handler, + }, + { + MethodName: "PoetInfo", + Handler: _SmeshingIdentitiesService_PoetInfo_Handler, + }, + { + MethodName: "Eligibilities", + Handler: _SmeshingIdentitiesService_Eligibilities_Handler, + }, + { + MethodName: "Proposals", + Handler: _SmeshingIdentitiesService_Proposals_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "spacemesh/v2alpha1/smeshing_identities.proto", +} diff --git a/release/openapi/swagger/src/api.swagger.json b/release/openapi/swagger/src/api.swagger.json index edf97d5a..d654cf0e 100644 --- a/release/openapi/swagger/src/api.swagger.json +++ b/release/openapi/swagger/src/api.swagger.json @@ -295,6 +295,134 @@ } } }, + "/spacemesh.v2alpha1.SmeshingIdentitiesService/Eligibilities": { + "post": { + "tags": [ + "SmeshingIdentitiesService" + ], + "operationId": "SmeshingIdentitiesService_Eligibilities", + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v2alpha1EligibilitiesRequest" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v2alpha1EligibilitiesResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + } + } + }, + "/spacemesh.v2alpha1.SmeshingIdentitiesService/PoetInfo": { + "post": { + "tags": [ + "SmeshingIdentitiesService" + ], + "operationId": "SmeshingIdentitiesService_PoetInfo", + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v2alpha1PoetInfoRequest" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v2alpha1PoetInfoResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + } + } + }, + "/spacemesh.v2alpha1.SmeshingIdentitiesService/Proposals": { + "post": { + "tags": [ + "SmeshingIdentitiesService" + ], + "operationId": "SmeshingIdentitiesService_Proposals", + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v2alpha1ProposalsRequest" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v2alpha1ProposalsResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + } + } + }, + "/spacemesh.v2alpha1.SmeshingIdentitiesService/States": { + "post": { + "tags": [ + "SmeshingIdentitiesService" + ], + "operationId": "SmeshingIdentitiesService_States", + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v2alpha1IdentityStatesRequest" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v2alpha1IdentityStatesResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + } + } + }, "/spacemesh.v2alpha1.TransactionService/EstimateGas": { "post": { "description": "EstimateGas is a method that takes a \"EstimateGasRequest\" body and returns an \"EstimateGasResponse\".\nThis method is used to estimate the recommended maximum gas for a signed binary transaction.", @@ -607,6 +735,32 @@ } } }, + "spacemeshv2alpha1Eligibilities": { + "type": "object", + "title": "Proposals and eligibilities", + "properties": { + "eligibilities": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/spacemeshv2alpha1ProposalEligibility" + } + } + } + }, + "spacemeshv2alpha1Eligibility": { + "type": "object", + "properties": { + "count": { + "type": "integer", + "format": "int64" + }, + "layer": { + "type": "integer", + "format": "int64" + } + } + }, "spacemeshv2alpha1Layer": { "type": "object", "properties": { @@ -766,6 +920,44 @@ } } }, + "spacemeshv2alpha1Proposal": { + "type": "object", + "properties": { + "layer": { + "type": "integer", + "format": "int64" + }, + "proposal": { + "type": "string", + "format": "byte" + } + } + }, + "spacemeshv2alpha1ProposalEligibility": { + "type": "object", + "properties": { + "count": { + "type": "integer", + "format": "int64" + }, + "layer": { + "type": "integer", + "format": "int64" + } + } + }, + "spacemeshv2alpha1Proposals": { + "type": "object", + "properties": { + "proposals": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/spacemeshv2alpha1Proposal" + } + } + } + }, "spacemeshv2alpha1Reward": { "type": "object", "properties": { @@ -1024,6 +1216,18 @@ } } }, + "v2alpha1AtxBroadcastedState": { + "type": "object", + "properties": { + "atxId": { + "type": "string", + "format": "byte" + } + } + }, + "v2alpha1AtxReadyState": { + "type": "object" + }, "v2alpha1ContentsDrainVault": { "type": "object", "properties": { @@ -1104,6 +1308,43 @@ } } }, + "v2alpha1EligibilitiesRequest": { + "type": "object" + }, + "v2alpha1EligibilitiesResponse": { + "type": "object", + "properties": { + "identities": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/v2alpha1EpochEligibilities" + } + } + } + }, + "v2alpha1Eligible": { + "type": "object", + "properties": { + "layers": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/spacemeshv2alpha1Eligibility" + } + } + } + }, + "v2alpha1EpochEligibilities": { + "type": "object", + "properties": { + "epochs": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/spacemeshv2alpha1Eligibilities" + } + } + } + }, "v2alpha1EstimateGasRequest": { "type": "object", "properties": { @@ -1127,6 +1368,118 @@ } } }, + "v2alpha1GeneratingPostProofState": { + "type": "object" + }, + "v2alpha1Identity": { + "type": "object", + "properties": { + "history": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/v2alpha1IdentityStateInfo" + } + } + } + }, + "v2alpha1IdentityState": { + "type": "string", + "default": "UNSPECIFIED", + "enum": [ + "UNSPECIFIED", + "WAIT_FOR_ATX_SYNCED", + "RETRYING", + "WAITING_FOR_POET_REGISTRATION_WINDOW", + "POET_CHALLENGE_READY", + "POET_REGISTERED", + "WAIT_FOR_POET_ROUND_END", + "POET_PROOF_RECEIVED", + "GENERATING_POST_PROOF", + "POST_PROOF_READY", + "ATX_READY", + "ATX_BROADCASTED", + "PROPOSAL_BUILD_FAILED", + "PROPOSAL_PUBLISH_FAILED", + "PROPOSAL_PUBLISHED", + "ELIGIBLE" + ] + }, + "v2alpha1IdentityStateInfo": { + "type": "object", + "properties": { + "atxBroadcasted": { + "$ref": "#/definitions/v2alpha1AtxBroadcastedState" + }, + "atxReady": { + "$ref": "#/definitions/v2alpha1AtxReadyState" + }, + "eligible": { + "$ref": "#/definitions/v2alpha1Eligible" + }, + "generatingPostProof": { + "$ref": "#/definitions/v2alpha1GeneratingPostProofState" + }, + "poetChallengeReady": { + "$ref": "#/definitions/v2alpha1PoetChallengeReadyState" + }, + "poetProofReceived": { + "$ref": "#/definitions/v2alpha1PoetProofReceivedState" + }, + "poetRegistered": { + "$ref": "#/definitions/v2alpha1PoetRegisteredState" + }, + "postProofReady": { + "$ref": "#/definitions/v2alpha1PostProofReadyState" + }, + "proposalBuildFailed": { + "$ref": "#/definitions/v2alpha1ProposalBuildFailedState" + }, + "proposalPublishFailed": { + "$ref": "#/definitions/v2alpha1ProposalPublishFailedState" + }, + "proposalPublished": { + "$ref": "#/definitions/v2alpha1ProposalPublishedState" + }, + "publishEpoch": { + "type": "integer", + "format": "int64" + }, + "retrying": { + "$ref": "#/definitions/v2alpha1RetryingState" + }, + "state": { + "$ref": "#/definitions/v2alpha1IdentityState" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "waitForAtxSynced": { + "$ref": "#/definitions/v2alpha1WaitForAtxSyncedState" + }, + "waitForPoetRoundEnd": { + "$ref": "#/definitions/v2alpha1WaitForPoetRoundEndState" + }, + "waitingForPoetRegistrationWindow": { + "$ref": "#/definitions/v2alpha1WaitingForPoetRegistrationWindowState" + } + } + }, + "v2alpha1IdentityStatesRequest": { + "type": "object" + }, + "v2alpha1IdentityStatesResponse": { + "type": "object", + "properties": { + "identities": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/v2alpha1Identity" + } + } + } + }, "v2alpha1LayerList": { "type": "object", "properties": { @@ -1222,6 +1575,143 @@ } } }, + "v2alpha1PoETRegistration": { + "type": "object", + "properties": { + "address": { + "type": "string" + }, + "challengeHash": { + "type": "string", + "format": "byte" + }, + "roundEnd": { + "type": "string", + "format": "date-time" + }, + "roundId": { + "type": "string" + } + } + }, + "v2alpha1PoetChallengeReadyState": { + "type": "object" + }, + "v2alpha1PoetConfig": { + "type": "object", + "properties": { + "cycleGap": { + "type": "string" + }, + "phaseShift": { + "type": "string" + } + } + }, + "v2alpha1PoetInfoRequest": { + "type": "object", + "title": "PoetInfo rpc" + }, + "v2alpha1PoetInfoResponse": { + "type": "object", + "properties": { + "config": { + "$ref": "#/definitions/v2alpha1PoetConfig" + }, + "poets": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v2alpha1PoetProofReceivedState": { + "type": "object", + "properties": { + "poetUrl": { + "type": "string" + } + } + }, + "v2alpha1PoetRegisteredState": { + "type": "object", + "properties": { + "registrations": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/v2alpha1PoETRegistration" + } + } + } + }, + "v2alpha1PostProofReadyState": { + "type": "object" + }, + "v2alpha1ProposalBuildFailedState": { + "type": "object", + "properties": { + "layer": { + "type": "integer", + "format": "int64" + }, + "message": { + "type": "string" + } + } + }, + "v2alpha1ProposalPublishFailedState": { + "type": "object", + "properties": { + "layer": { + "type": "integer", + "format": "int64" + }, + "message": { + "type": "string" + }, + "proposal": { + "type": "string", + "format": "byte" + } + } + }, + "v2alpha1ProposalPublishedState": { + "type": "object", + "properties": { + "layer": { + "type": "integer", + "format": "int64" + }, + "proposal": { + "type": "string", + "format": "byte" + } + } + }, + "v2alpha1ProposalsRequest": { + "type": "object" + }, + "v2alpha1ProposalsResponse": { + "type": "object", + "properties": { + "proposals": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/spacemeshv2alpha1Proposals" + } + } + } + }, + "v2alpha1RetryingState": { + "type": "object", + "properties": { + "message": { + "type": "string" + } + } + }, "v2alpha1RewardList": { "type": "object", "properties": { @@ -1382,6 +1872,25 @@ "$ref": "#/definitions/spacemeshv2alpha1TransactionState" } } + }, + "v2alpha1WaitForAtxSyncedState": { + "type": "object" + }, + "v2alpha1WaitForPoetRoundEndState": { + "type": "object", + "properties": { + "publishEpochEnd": { + "type": "string", + "format": "date-time" + }, + "roundEnd": { + "type": "string", + "format": "date-time" + } + } + }, + "v2alpha1WaitingForPoetRegistrationWindowState": { + "type": "object" } }, "tags": [ @@ -1408,6 +1917,9 @@ }, { "name": "RewardService" + }, + { + "name": "SmeshingIdentitiesService" } ] } \ No newline at end of file diff --git a/spacemesh/v2alpha1/smeshing_identities.proto b/spacemesh/v2alpha1/smeshing_identities.proto new file mode 100644 index 00000000..425b3a37 --- /dev/null +++ b/spacemesh/v2alpha1/smeshing_identities.proto @@ -0,0 +1,180 @@ +syntax = "proto3"; + +package spacemesh.v2alpha1; + +import "google/api/annotations.proto"; +import "google/api/visibility.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/empty.proto"; + +message IdentityStatesRequest {} + +enum IdentityState { + UNSPECIFIED = 0; + + WAIT_FOR_ATX_SYNCED = 1; + RETRYING = 2; + + WAITING_FOR_POET_REGISTRATION_WINDOW = 3; + POET_CHALLENGE_READY = 4; + POET_REGISTERED = 5; + WAIT_FOR_POET_ROUND_END = 6; + POET_PROOF_RECEIVED = 7; + + GENERATING_POST_PROOF = 8; + POST_PROOF_READY = 9; + + ATX_READY = 10; + ATX_BROADCASTED = 11; + + + PROPOSAL_BUILD_FAILED = 12; + PROPOSAL_PUBLISH_FAILED = 13; + PROPOSAL_PUBLISHED = 14; + + ELIGIBLE = 15; +} + +message RetryingState { + string message = 1; +} +message WaitForAtxSyncedState {} +message WaitingForPoetRegistrationWindowState {} +message PoetChallengeReadyState {} + +message PoETRegistration { + bytes challenge_hash = 1; + string address = 2; + string round_id = 3; + google.protobuf.Timestamp round_end = 4; +} +message PoetRegisteredState { + repeated PoETRegistration registrations = 1; +} + +message WaitForPoetRoundEndState { + google.protobuf.Timestamp round_end = 1; + google.protobuf.Timestamp publish_epoch_end = 2; +} +message PoetProofReceivedState { + string poet_url = 1; +} +message GeneratingPostProofState {} +message PostProofReadyState {} +message AtxReadyState {} +message AtxBroadcastedState { + bytes atx_id = 1; +} +message ProposalBuildFailedState { + string message = 1; + uint32 layer = 2; +} +message ProposalPublishFailedState { + string message = 1; + bytes proposal = 2; + uint32 layer = 3; +} +message ProposalPublishedState { + bytes proposal = 1; + uint32 layer = 2; +} + +message Eligibility { + uint32 layer = 1; + uint32 count = 2; +} +message Eligible { + repeated Eligibility layers = 2; +} + +message IdentityStateInfo { + IdentityState state = 1; + optional uint32 publish_epoch = 2; + google.protobuf.Timestamp time = 3; + oneof metadata { + RetryingState retrying = 4; + WaitForAtxSyncedState wait_for_atx_synced = 5; + WaitingForPoetRegistrationWindowState waiting_for_poet_registration_window = 6; + PoetChallengeReadyState poet_challenge_ready = 7; + PoetRegisteredState poet_registered = 8; + WaitForPoetRoundEndState wait_for_poet_round_end = 9; + PoetProofReceivedState poet_proof_received = 10; + GeneratingPostProofState generating_post_proof = 11; + PostProofReadyState post_proof_ready = 12; + AtxReadyState atx_ready = 13; + AtxBroadcastedState atx_broadcasted = 14; + ProposalBuildFailedState proposal_build_failed = 15; + ProposalPublishFailedState proposal_publish_failed = 16; + ProposalPublishedState proposal_published = 17; + Eligible eligible = 18; + } +} + +message Identity { + repeated IdentityStateInfo history = 1; +} + +message IdentityStatesResponse { + map identities = 1; +} + +// PoetInfo rpc +message PoetInfoRequest {} + +message PoetConfig { + google.protobuf.Duration phase_shift = 1; + google.protobuf.Duration cycle_gap = 2; +} + +message PoetInfoResponse { + repeated string poets = 1; + PoetConfig config = 2; +} + +// Proposals and eligibilities +message Eligibilities { + repeated ProposalEligibility eligibilities = 5; +} + +message ProposalEligibility { + uint32 layer = 1; + uint32 count = 2; +} + +message EpochEligibilities { + map epochs = 1; +} + +message EligibilitiesRequest {} + +message EligibilitiesResponse { + map identities = 1; +} + +message ProposalsRequest {} + +message Proposal { + uint32 layer = 1; + bytes proposal = 2; +} + +message Proposals { + repeated Proposal proposals = 1; +} + +message ProposalsResponse { + map proposals = 1; +} + +service SmeshingIdentitiesService { + option (google.api.api_visibility).restriction = "V2"; + + rpc States(IdentityStatesRequest) returns (IdentityStatesResponse) {} + + rpc PoetInfo(PoetInfoRequest) returns (PoetInfoResponse) {} + + rpc Eligibilities(EligibilitiesRequest) returns (EligibilitiesResponse) {} + + rpc Proposals(ProposalsRequest) returns (ProposalsResponse) {} +}