spacemeshv2alpha1

type Activation struct {

	// Types that are assignable to Versioned:
	//
	//	*Activation_V1
	Versioned isActivation_Versioned `protobuf_oneof:"versioned"`
	// contains filtered or unexported fields
}

type ActivationList struct {
	Activations []*Activation `protobuf:"bytes,1,rep,name=activations,proto3" json:"activations,omitempty"`
	// contains filtered or unexported fields
}

type ActivationRequest struct {
	StartEpoch uint32 `protobuf:"varint,1,opt,name=start_epoch,json=startEpoch,proto3" json:"start_epoch,omitempty"` // Apply `start_epoch/end_epoch` filters together with `coinbase` filter for better performance.
	EndEpoch   uint32 `protobuf:"varint,2,opt,name=end_epoch,json=endEpoch,proto3" json:"end_epoch,omitempty"`
	Id         []byte `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	NodeId     []byte `protobuf:"bytes,4,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	Coinbase   string `protobuf:"bytes,5,opt,name=coinbase,proto3" json:"coinbase,omitempty"` // `coinbase` filter is not supported by database index and will result in sequential scan.
	Offset     uint64 `protobuf:"varint,6,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit      uint64 `protobuf:"varint,7,opt,name=limit,proto3" json:"limit,omitempty"`
	// contains filtered or unexported fields
}

type ActivationServiceClient interface {
	List(ctx context.Context, in *ActivationRequest, opts ...grpc.CallOption) (*ActivationList, error)
	ActivationsCount(ctx context.Context, in *ActivationsCountRequest, opts ...grpc.CallOption) (*ActivationsCountResponse, error)
}

type ActivationServiceServer interface {
	List(context.Context, *ActivationRequest) (*ActivationList, error)
	ActivationsCount(context.Context, *ActivationsCountRequest) (*ActivationsCountResponse, error)
}

type ActivationStreamRequest struct {
	StartEpoch uint32 `protobuf:"varint,1,opt,name=start_epoch,json=startEpoch,proto3" json:"start_epoch,omitempty"` // Apply `start_epoch/end_epoch` filters together with `coinbase` filter for better performance.
	EndEpoch   uint32 `protobuf:"varint,2,opt,name=end_epoch,json=endEpoch,proto3" json:"end_epoch,omitempty"`
	Id         []byte `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	NodeId     []byte `protobuf:"bytes,4,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	Coinbase   string `protobuf:"bytes,5,opt,name=coinbase,proto3" json:"coinbase,omitempty"` // `coinbase` filter is not supported by database index and will result in sequential scan.
	Watch      bool   `protobuf:"varint,6,opt,name=watch,proto3" json:"watch,omitempty"`
	// contains filtered or unexported fields
}

type ActivationStreamServiceClient interface {
	Stream(ctx context.Context, in *ActivationStreamRequest, opts ...grpc.CallOption) (ActivationStreamService_StreamClient, error)
}

type ActivationStreamServiceServer interface {
	Stream(*ActivationStreamRequest, ActivationStreamService_StreamServer) error
}

type ActivationStreamService_StreamClient interface {
	Recv() (*Activation, error)
	grpc.ClientStream
}

type ActivationStreamService_StreamServer interface {
	Send(*Activation) error
	grpc.ServerStream
}

type ActivationV1 struct {
	Id           []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SmesherId    []byte `protobuf:"bytes,2,opt,name=smesher_id,json=smesherId,proto3" json:"smesher_id,omitempty"`
	Signature    []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	PublishEpoch uint32 `protobuf:"varint,4,opt,name=publish_epoch,json=publishEpoch,proto3" json:"publish_epoch,omitempty"`
	PreviousAtx  []byte `protobuf:"bytes,5,opt,name=previous_atx,json=previousAtx,proto3" json:"previous_atx,omitempty"`
	Coinbase     string `protobuf:"bytes,6,opt,name=coinbase,proto3" json:"coinbase,omitempty"`
	Weight       uint64 `protobuf:"varint,7,opt,name=weight,proto3" json:"weight,omitempty"`
	Height       uint64 `protobuf:"varint,8,opt,name=height,proto3" json:"height,omitempty"`
	// contains filtered or unexported fields
}

type Activation_V1 struct {
	V1 *ActivationV1 `protobuf:"bytes,1,opt,name=v1,proto3,oneof"`
}

type ActivationsCountRequest struct {
	Epoch *uint32 `protobuf:"varint,1,opt,name=epoch,proto3,oneof" json:"epoch,omitempty"`
	// contains filtered or unexported fields
}

type ActivationsCountResponse struct {
	Count uint32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	// contains filtered or unexported fields
}

type Block struct {

	// Types that are assignable to Versioned:
	//
	//	*Block_V1
	Versioned isBlock_Versioned `protobuf_oneof:"versioned"`
	// contains filtered or unexported fields
}

type BlockV1 struct {
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // block hash
	// contains filtered or unexported fields
}

type Block_V1 struct {
	V1 *BlockV1 `protobuf:"bytes,1,opt,name=v1,proto3,oneof"`
}

type ContentsMultiSigSpawn struct {
	Required uint32   `protobuf:"varint,1,opt,name=required,proto3" json:"required,omitempty"` // number of required signatures
	Pubkey   []string `protobuf:"bytes,2,rep,name=pubkey,proto3" json:"pubkey,omitempty"`
	// contains filtered or unexported fields
}

type ContentsSend struct {
	Destination string `protobuf:"bytes,1,opt,name=destination,proto3" json:"destination,omitempty"` // recipient account
	Amount      uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`          // amount in smidge
	// contains filtered or unexported fields
}

type ContentsSingleSigSpawn struct {
	Pubkey string `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	// contains filtered or unexported fields
}

type Layer struct {

	// Types that are assignable to Versioned:
	//
	//	*Layer_V1
	Versioned isLayer_Versioned `protobuf_oneof:"versioned"`
	// contains filtered or unexported fields
}

type LayerList struct {
	Layers []*Layer `protobuf:"bytes,1,rep,name=layers,proto3" json:"layers,omitempty"`
	// contains filtered or unexported fields
}

type LayerRequest struct {
	StartLayer uint32 `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"`
	EndLayer   uint32 `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3" json:"end_layer,omitempty"`
	Offset     uint64 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"` // adjusts the starting point for data
	Limit      uint64 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`   // specifies max number of items to fetch
	// contains filtered or unexported fields
}

type LayerServiceClient interface {
	List(ctx context.Context, in *LayerRequest, opts ...grpc.CallOption) (*LayerList, error)
}

type LayerServiceServer interface {
	List(context.Context, *LayerRequest) (*LayerList, error)
}

type LayerStreamRequest struct {
	StartLayer uint32 `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"`
	EndLayer   uint32 `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3" json:"end_layer,omitempty"`
	Watch      bool   `protobuf:"varint,3,opt,name=watch,proto3" json:"watch,omitempty"`
	// contains filtered or unexported fields
}

type LayerStreamServiceClient interface {
	Stream(ctx context.Context, in *LayerStreamRequest, opts ...grpc.CallOption) (LayerStreamService_StreamClient, error)
}

type LayerStreamServiceServer interface {
	Stream(*LayerStreamRequest, LayerStreamService_StreamServer) error
}

type LayerStreamService_StreamClient interface {
	Recv() (*Layer, error)
	grpc.ClientStream
}

type LayerStreamService_StreamServer interface {
	Send(*Layer) error
	grpc.ServerStream
}

type LayerV1 struct {
	Number              uint32              `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"` // layer number - not hash - layer content may change
	Status              LayerV1_LayerStatus `protobuf:"varint,2,opt,name=status,proto3,enum=spacemesh.v2alpha1.LayerV1_LayerStatus" json:"status,omitempty"`
	ConsensusHash       string              `protobuf:"bytes,3,opt,name=consensus_hash,json=consensusHash,proto3" json:"consensus_hash,omitempty"`
	StateHash           []byte              `protobuf:"bytes,4,opt,name=state_hash,json=stateHash,proto3" json:"state_hash,omitempty"`                                 // fingerprint of the computed state at the layer
	CumulativeStateHash []byte              `protobuf:"bytes,5,opt,name=cumulative_state_hash,json=cumulativeStateHash,proto3" json:"cumulative_state_hash,omitempty"` // cumulative fingerprint that uniquely identifies state since genesis
	Block               *Block              `protobuf:"bytes,6,opt,name=block,proto3" json:"block,omitempty"`                                                          // layer's block
	// contains filtered or unexported fields
}

type LayerV1_LayerStatus int32

type Layer_V1 struct {
	V1 *LayerV1 `protobuf:"bytes,1,opt,name=v1,proto3,oneof"`
}

type NetworkInfoRequest struct {
	// contains filtered or unexported fields
}

type NetworkInfoResponse struct {
	GenesisTime           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`       // genesis time of the network, represented as a timestamp
	LayerDuration         *durationpb.Duration   `protobuf:"bytes,3,opt,name=layer_duration,json=layerDuration,proto3" json:"layer_duration,omitempty"` // duration of each layer in the network, specified as a duration
	GenesisId             []byte                 `protobuf:"bytes,4,opt,name=genesis_id,json=genesisId,proto3" json:"genesis_id,omitempty"`
	Hrp                   string                 `protobuf:"bytes,5,opt,name=hrp,proto3" json:"hrp,omitempty"`
	EffectiveGenesisLayer uint32                 `` // effective genesis layer, i.e., first layer after genesis initialization period
	/* 127-byte string literal not displayed */
	LayersPerEpoch uint32 `protobuf:"varint,7,opt,name=layers_per_epoch,json=layersPerEpoch,proto3" json:"layers_per_epoch,omitempty"` // number of layers per epoch
	// contains filtered or unexported fields
}

type NetworkServiceClient interface {
	Info(ctx context.Context, in *NetworkInfoRequest, opts ...grpc.CallOption) (*NetworkInfoResponse, error)
}

type NetworkServiceServer interface {
	Info(context.Context, *NetworkInfoRequest) (*NetworkInfoResponse, error)
}

type NodeServiceClient interface {
	Status(ctx context.Context, in *NodeStatusRequest, opts ...grpc.CallOption) (*NodeStatusResponse, error)
}

type NodeServiceServer interface {
	Status(context.Context, *NodeStatusRequest) (*NodeStatusResponse, error)
}

type NodeStatusRequest struct {
	// contains filtered or unexported fields
}

type NodeStatusResponse struct {
	ConnectedPeers uint64                        `protobuf:"varint,1,opt,name=connected_peers,json=connectedPeers,proto3" json:"connected_peers,omitempty"` // number of connected neighbors
	Status         NodeStatusResponse_SyncStatus `protobuf:"varint,2,opt,name=status,proto3,enum=spacemesh.v2alpha1.NodeStatusResponse_SyncStatus" json:"status,omitempty"`
	LatestLayer    uint32                        `protobuf:"varint,3,opt,name=latest_layer,json=latestLayer,proto3" json:"latest_layer,omitempty"`          // latest layer node has seen from blocks
	AppliedLayer   uint32                        `protobuf:"varint,4,opt,name=applied_layer,json=appliedLayer,proto3" json:"applied_layer,omitempty"`       // last layer node has applied to the state
	ProcessedLayer uint32                        `protobuf:"varint,5,opt,name=processed_layer,json=processedLayer,proto3" json:"processed_layer,omitempty"` // last layer whose votes have been processed
	CurrentLayer   uint32                        `protobuf:"varint,6,opt,name=current_layer,json=currentLayer,proto3" json:"current_layer,omitempty"`       // current layer, based on clock time
	// contains filtered or unexported fields
}

type NodeStatusResponse_SyncStatus int32

type Nonce struct {
	Counter uint64 `protobuf:"varint,1,opt,name=counter,proto3" json:"counter,omitempty"`
	// contains filtered or unexported fields
}

type Reward struct {

	// Types that are assignable to Versioned:
	//
	//	*Reward_V1
	Versioned isReward_Versioned `protobuf_oneof:"versioned"`
	// contains filtered or unexported fields
}

type RewardList struct {
	Rewards []*Reward `protobuf:"bytes,1,rep,name=rewards,proto3" json:"rewards,omitempty"`
	// contains filtered or unexported fields
}

type RewardRequest struct {
	StartLayer uint32 `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"`
	EndLayer   uint32 `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3" json:"end_layer,omitempty"`
	// Types that are assignable to FilterBy:
	//
	//	*RewardRequest_Coinbase
	//	*RewardRequest_Smesher
	FilterBy isRewardRequest_FilterBy `protobuf_oneof:"filter_by"`
	Offset   uint64                   `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"` // adjusts the starting point for data
	Limit    uint64                   `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"`   // specifies max number of items to fetch
	// contains filtered or unexported fields
}

type RewardRequest_Coinbase struct {
	Coinbase string `protobuf:"bytes,3,opt,name=coinbase,proto3,oneof"`
}

type RewardRequest_Smesher struct {
	Smesher []byte `protobuf:"bytes,4,opt,name=smesher,proto3,oneof"`
}

type RewardServiceClient interface {
	List(ctx context.Context, in *RewardRequest, opts ...grpc.CallOption) (*RewardList, error)
}

type RewardServiceServer interface {
	List(context.Context, *RewardRequest) (*RewardList, error)
}

type RewardStreamRequest struct {
	StartLayer uint32 `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"`
	EndLayer   uint32 `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3" json:"end_layer,omitempty"`
	// Types that are assignable to FilterBy:
	//
	//	*RewardStreamRequest_Coinbase
	//	*RewardStreamRequest_Smesher
	FilterBy isRewardStreamRequest_FilterBy `protobuf_oneof:"filter_by"`
	Watch    bool                           `protobuf:"varint,5,opt,name=watch,proto3" json:"watch,omitempty"`
	// contains filtered or unexported fields
}

type RewardStreamRequest_Coinbase struct {
	Coinbase string `protobuf:"bytes,3,opt,name=coinbase,proto3,oneof"`
}

type RewardStreamRequest_Smesher struct {
	Smesher []byte `protobuf:"bytes,4,opt,name=smesher,proto3,oneof"`
}

type RewardStreamServiceClient interface {
	Stream(ctx context.Context, in *RewardStreamRequest, opts ...grpc.CallOption) (RewardStreamService_StreamClient, error)
}

type RewardStreamServiceServer interface {
	Stream(*RewardStreamRequest, RewardStreamService_StreamServer) error
}

type RewardStreamService_StreamClient interface {
	Recv() (*Reward, error)
	grpc.ClientStream
}

type RewardStreamService_StreamServer interface {
	Send(*Reward) error
	grpc.ServerStream
}

type RewardV1 struct {
	Layer       uint32 `protobuf:"varint,1,opt,name=layer,proto3" json:"layer,omitempty"`                                // layer award was paid in
	Total       uint64 `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`                                // total reward paid in smidge (sum of tx fee and layer reward)
	LayerReward uint64 `protobuf:"varint,3,opt,name=layer_reward,json=layerReward,proto3" json:"layer_reward,omitempty"` // tx_fee = total - layer_reward
	Coinbase    string `protobuf:"bytes,5,opt,name=coinbase,proto3" json:"coinbase,omitempty"`                           // account awarded this reward
	Smesher     []byte `protobuf:"bytes,6,opt,name=smesher,proto3" json:"smesher,omitempty"`                             // id of smesher who earned this reward
	// contains filtered or unexported fields
}

type Reward_V1 struct {
	V1 *RewardV1 `protobuf:"bytes,1,opt,name=v1,proto3,oneof"`
}

type Transaction struct {

	// Types that are assignable to Versioned:
	//
	//	*Transaction_V1
	Versioned isTransaction_Versioned `protobuf_oneof:"versioned"`
	// contains filtered or unexported fields
}

type TransactionContents struct {

	// Types that are assignable to Contents:
	//
	//	*TransactionContents_Send
	//	*TransactionContents_SingleSigSpawn
	//	*TransactionContents_MultiSigSpawn
	Contents isTransactionContents_Contents `protobuf_oneof:"contents"`
	// contains filtered or unexported fields
}

type TransactionContents_MultiSigSpawn struct {
	MultiSigSpawn *ContentsMultiSigSpawn `protobuf:"bytes,3,opt,name=multi_sig_spawn,json=multiSigSpawn,proto3,oneof"`
}

type TransactionContents_Send struct {
	Send *ContentsSend `protobuf:"bytes,1,opt,name=send,proto3,oneof"`
}

type TransactionContents_SingleSigSpawn struct {
	SingleSigSpawn *ContentsSingleSigSpawn `protobuf:"bytes,2,opt,name=single_sig_spawn,json=singleSigSpawn,proto3,oneof"`
}

type TransactionV1 struct {
	Id        []byte                        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Principal string                        `protobuf:"bytes,2,opt,name=principal,proto3" json:"principal,omitempty"` // principal account address
	Template  string                        `protobuf:"bytes,3,opt,name=template,proto3" json:"template,omitempty"`   // template account address
	Method    uint32                        `protobuf:"varint,4,opt,name=method,proto3" json:"method,omitempty"`      // this is actually limited by uint8, but no type for that.
	Nonce     *Nonce                        `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"`
	MaxGas    uint64                        `protobuf:"varint,6,opt,name=max_gas,json=maxGas,proto3" json:"max_gas,omitempty"`       // max gas units consumed by tx
	GasPrice  uint64                        `protobuf:"varint,7,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"` // fee per unit gas, in smidge
	MaxSpend  uint64                        `protobuf:"varint,8,opt,name=max_spend,json=maxSpend,proto3" json:"max_spend,omitempty"`
	Raw       []byte                        `protobuf:"bytes,9,opt,name=raw,proto3" json:"raw,omitempty"`
	Type      TransactionV1_TransactionType `protobuf:"varint,10,opt,name=type,proto3,enum=spacemesh.v2alpha1.TransactionV1_TransactionType" json:"type,omitempty"`
	Contents  *TransactionContents          `protobuf:"bytes,11,opt,name=contents,proto3" json:"contents,omitempty"` // parsed transaction contents
	// contains filtered or unexported fields
}

type TransactionV1_TransactionType int32

type Transaction_V1 struct {
	V1 *TransactionV1 `protobuf:"bytes,1,opt,name=v1,proto3,oneof"`
}

type UnimplementedActivationServiceServer struct {
}

type UnimplementedActivationStreamServiceServer struct {
}

type UnimplementedLayerServiceServer struct {
}

type UnimplementedLayerStreamServiceServer struct {
}

type UnimplementedNetworkServiceServer struct {
}

type UnimplementedNodeServiceServer struct {
}

type UnimplementedRewardServiceServer struct {
}

type UnimplementedRewardStreamServiceServer struct {
}

type UnsafeActivationServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeActivationStreamServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeLayerServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeLayerStreamServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeNetworkServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeNodeServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeRewardServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeRewardStreamServiceServer interface {
	// contains filtered or unexported methods
}