// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v5.29.3
// source: consensus.proto

package lib

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

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)
)

// *****************************************************************************************************
// This file is auto-generated from source files in `/lib/.proto/*` using Protocol Buffers (protobuf)
//
// Protobuf is a language-neutral, platform-neutral serialization format. It allows users
// to define objects in a way that’s both efficient to store and fast to transmit over the network.
// These definitions are compiled into code that *enables different systems and programming languages
// to communicate in a byte-perfect manner*
//
// To update these structures, make changes to the source .proto files, then recompile
// to regenerate this file.
// These auto-generated files are easily recognized by checking for a `.pb.go` ending
// *****************************************************************************************************
// _
// _
// _
// Phase is the smallest unit in the consensus process. Each round consists of multiple phases, and these phases are
// executed sequentially to achieve consensus on the next block.
type Phase int32

const (
	// unknown: is an unidentified phase that is likely an error
	Phase_UNKNOWN Phase = 0
	// election:
	// Each replica runs a Verifiable Random Function (VRF); if selected as a candidate,
	// the replica sends its VRF output to the other replicas.
	Phase_ELECTION Phase = 1
	// election_vote:
	// Each replica sends ELECTION votes (signature) for the leader based on the lowest VRF value
	// if no candidates exist, the process falls back to a stake-weighted-pseudorandom selection.
	Phase_ELECTION_VOTE Phase = 2
	// propose:
	// The leader collects ELECTION_VOTEs from +2/3 of the replicas, each including the lock, evidence, and signature
	// from the sender. If a valid lock exists for the current height and meets the SAFE NODE PREDICATE, the leader uses
	// that block as the proposal block. If no valid lock is found, the leader creates a new block to extend the
	// blockchain. The leader then sends the new proposal (block, results, evidence) attaching the +2/3 signatures from
	// ELECTION_VOTE to justify themselves as the Leader.
	Phase_PROPOSE Phase = 3
	// propose_vote:
	// Each replica validates the PROPOSE msg by verifying the aggregate signature, applying the proposal block against
	// their state machine, and checking the header and results against what they produced. If valid, the replica sends
	// a vote (signature) to the leader. Each vote vouches that the leader's proposal as valid
	Phase_PROPOSE_VOTE Phase = 4
	// precommit:
	// The leader collects PROPOSE_VOTEs from +2/3 of the replicas, each including a signature from the sender.
	// The leader sends a PRECOMMIT message attaching +2/3 signatures from the PROPOSE_VOTE messages, justifying
	// that +2/3 of the quorum believes the proposal is valid.
	Phase_PRECOMMIT Phase = 5
	// precommit_vote:
	// Each replica validates the PRECOMMIT msg by verifying the aggregate signature. If valid, the replica sends a vote
	// to the leader. Each vote vouches that the replica has seen evidence that +2/3 of the quorum believe the proposal
	// is valid.
	Phase_PRECOMMIT_VOTE Phase = 6
	// commit:
	// The leader collects PRECOMMIT_VOTEs from +2/3 from the replicas, each including a signature from the sender.
	// The leader sends a COMMIT message attaching +2/3 signatures from the PRECOMMIT_VOTE messages, justifying that
	// +2/3 of the quorum agree that a super-majority think the proposal is valid.
	Phase_COMMIT Phase = 7
	// commit_process:
	// Each replica validates the COMMIT msg by verifying the aggregate signature. If valid, the replica commits the
	// block to finality, and resets the bft for the next height.
	Phase_COMMIT_PROCESS Phase = 8
	// round_interrupt:
	// A failure in the bft cycle caused a premature exit in the round. This results in a new round and an extended sleep
	// time between phases to help alleviate any 'non-voter' issues. During this phase, each replica sends its View to
	// all other replicas to alleviate round synchronous issues.
	Phase_ROUND_INTERRUPT Phase = 9
	// pacemaker:
	// This phase follows ROUND_INTERRUPT, each replica calculates the highest round a super-majority has seen and jumps
	// to it to assist in 'round out of sync' issues.
	Phase_PACEMAKER Phase = 10
)

// Enum value maps for Phase.
var (
	Phase_name = map[int32]string{
		0:  "UNKNOWN",
		1:  "ELECTION",
		2:  "ELECTION_VOTE",
		3:  "PROPOSE",
		4:  "PROPOSE_VOTE",
		5:  "PRECOMMIT",
		6:  "PRECOMMIT_VOTE",
		7:  "COMMIT",
		8:  "COMMIT_PROCESS",
		9:  "ROUND_INTERRUPT",
		10: "PACEMAKER",
	}
	Phase_value = map[string]int32{
		"UNKNOWN":         0,
		"ELECTION":        1,
		"ELECTION_VOTE":   2,
		"PROPOSE":         3,
		"PROPOSE_VOTE":    4,
		"PRECOMMIT":       5,
		"PRECOMMIT_VOTE":  6,
		"COMMIT":          7,
		"COMMIT_PROCESS":  8,
		"ROUND_INTERRUPT": 9,
		"PACEMAKER":       10,
	}
)

func (x Phase) Enum() *Phase {
	p := new(Phase)
	*p = x
	return p
}

func (x Phase) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Phase) Descriptor() protoreflect.EnumDescriptor {
	return file_consensus_proto_enumTypes[0].Descriptor()
}

func (Phase) Type() protoreflect.EnumType {
	return &file_consensus_proto_enumTypes[0]
}

func (x Phase) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Phase.Descriptor instead.
func (Phase) EnumDescriptor() ([]byte, []int) {
	return file_consensus_proto_rawDescGZIP(), []int{0}
}

// A View is a specific point in the consensus process; think of it like a snapshot of the consensus process at a
// certain point in time.
// A View comprises of:
//
// 1) Network ID and chain id: These identifiers uniquely define the BFT instance,
// distinguishing different networks and the committees within them
//
// 2) Height and Canopy Height: For each BFT instance, the height increases with every new block produced,
// and the canopy height when a canopy block is produced.
//
// 3) Round: Each height comprises of 1 or more rounds. A round increments when no block is produced but resets
// to zero at a new height.
//
// 3) Phase: Each round consists of a fixed number of phases. Phases progress within the round and either end
// with the successful production of a block or quit prematurely due to an error.
type View struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// the unique identifier of the blockchain network
	NetworkId uint64 `protobuf:"varint,1,opt,name=network_id,json=networkId,proto3" json:"networkID"` // @gotags: json:"networkID"
	// the unique identifier of the committee within the blockchain network
	ChainId uint64 `protobuf:"varint,2,opt,name=chain_id,json=chainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	// the height or number of committed blocks in the blockchain
	Height uint64 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	// the root blockchain height also the height that the committee validator set may be verified
	RootHeight uint64 `protobuf:"varint,4,opt,name=root_height,json=rootHeight,proto3" json:"rootHeight"` // @gotags: json:"rootHeight"
	// each height consists of one or more `rounds` which is a step within the consensus protocol where
	// a new Proposer is selected to lead the validators to agree on the next block if they fail, the
	// round is incremented, more time is granted for consensus timeouts, and the cycle starts over
	Round uint64 `protobuf:"varint,5,opt,name=round,proto3" json:"round,omitempty"`
	// represents the smallest unit in the consensus process. Each round consists of multiple phases, and these phases are
	// executed sequentially to achieve consensus on the next block.
	// ELECTION->ELECTION-VOTE->PROPOSE->PROPOSE-VOTE->PRECOMMIT->PRECOMMIT-VOTE->COMMIT->COMMIT-PROCESS
	Phase         Phase `protobuf:"varint,6,opt,name=phase,proto3,enum=types.Phase" json:"phase,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *View) Reset() {
	*x = View{}
	mi := &file_consensus_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *View) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*View) ProtoMessage() {}

func (x *View) ProtoReflect() protoreflect.Message {
	mi := &file_consensus_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use View.ProtoReflect.Descriptor instead.
func (*View) Descriptor() ([]byte, []int) {
	return file_consensus_proto_rawDescGZIP(), []int{0}
}

func (x *View) GetNetworkId() uint64 {
	if x != nil {
		return x.NetworkId
	}
	return 0
}

func (x *View) GetChainId() uint64 {
	if x != nil {
		return x.ChainId
	}
	return 0
}

func (x *View) GetHeight() uint64 {
	if x != nil {
		return x.Height
	}
	return 0
}

func (x *View) GetRootHeight() uint64 {
	if x != nil {
		return x.RootHeight
	}
	return 0
}

func (x *View) GetRound() uint64 {
	if x != nil {
		return x.Round
	}
	return 0
}

func (x *View) GetPhase() Phase {
	if x != nil {
		return x.Phase
	}
	return Phase_UNKNOWN
}

// An Aggregate Signature is a single, compact signature created by combining multiple individual signatures from
// different participants. It allows verification that each participant signed the same message, which saves space
// and improves efficiency in blockchain and consensus protocols by reducing the need to store or verify multiple
// separate signatures.
type AggregateSignature struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// signature: is the compacted signature bytes of the aggregate quorum
	Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	// bitmap: used to efficiently track which signatures from the list of participants are included in the
	// aggregate signature (as only +2/3rds are needed to make it valid. Bit 1 is included Bit 0 is not
	Bitmap        []byte `protobuf:"bytes,2,opt,name=bitmap,proto3" json:"bitmap,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AggregateSignature) Reset() {
	*x = AggregateSignature{}
	mi := &file_consensus_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AggregateSignature) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AggregateSignature) ProtoMessage() {}

func (x *AggregateSignature) ProtoReflect() protoreflect.Message {
	mi := &file_consensus_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AggregateSignature.ProtoReflect.Descriptor instead.
func (*AggregateSignature) Descriptor() ([]byte, []int) {
	return file_consensus_proto_rawDescGZIP(), []int{1}
}

func (x *AggregateSignature) GetSignature() []byte {
	if x != nil {
		return x.Signature
	}
	return nil
}

func (x *AggregateSignature) GetBitmap() []byte {
	if x != nil {
		return x.Bitmap
	}
	return nil
}

// Proposers is a list of addresses that represent the previous proposers
type Proposers struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// addresses: is the list of addresses (short version of public keys)
	Addresses     [][]byte `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Proposers) Reset() {
	*x = Proposers{}
	mi := &file_consensus_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Proposers) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Proposers) ProtoMessage() {}

func (x *Proposers) ProtoReflect() protoreflect.Message {
	mi := &file_consensus_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Proposers.ProtoReflect.Descriptor instead.
func (*Proposers) Descriptor() ([]byte, []int) {
	return file_consensus_proto_rawDescGZIP(), []int{2}
}

func (x *Proposers) GetAddresses() [][]byte {
	if x != nil {
		return x.Addresses
	}
	return nil
}

// ConsensusValidator is the bft abstraction of the Validator structure that only contains information relevant to
// the bft process
type ConsensusValidator struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// public_key: the operator's aggregable public key that is used to validate signatures from the operator
	PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"publicKey"` // @gotags: json:"publicKey"
	// voting_power: the weight of this node's vote, typically 1 to 1 matched to staked tokens
	VotingPower uint64 `protobuf:"varint,2,opt,name=voting_power,json=votingPower,proto3" json:"votingPower"` // @gotags: json:"votingPower"
	// net_address: the p2p tcp address of the validator node
	NetAddress    string `protobuf:"bytes,3,opt,name=net_address,json=netAddress,proto3" json:"netAddress"` // @gotags: json:"netAddress"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConsensusValidator) Reset() {
	*x = ConsensusValidator{}
	mi := &file_consensus_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConsensusValidator) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConsensusValidator) ProtoMessage() {}

func (x *ConsensusValidator) ProtoReflect() protoreflect.Message {
	mi := &file_consensus_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ConsensusValidator.ProtoReflect.Descriptor instead.
func (*ConsensusValidator) Descriptor() ([]byte, []int) {
	return file_consensus_proto_rawDescGZIP(), []int{3}
}

func (x *ConsensusValidator) GetPublicKey() []byte {
	if x != nil {
		return x.PublicKey
	}
	return nil
}

func (x *ConsensusValidator) GetVotingPower() uint64 {
	if x != nil {
		return x.VotingPower
	}
	return 0
}

func (x *ConsensusValidator) GetNetAddress() string {
	if x != nil {
		return x.NetAddress
	}
	return ""
}

// ConsensusValidators is a list of Consensus Validator objects used in the bft process often representing a BFT
// committee
type ConsensusValidators struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// validator_set: is the actual list of Validators and their respective
	ValidatorSet  []*ConsensusValidator `protobuf:"bytes,1,rep,name=ValidatorSet,proto3" json:"validatorSet"` // @gotags: json:"validatorSet"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConsensusValidators) Reset() {
	*x = ConsensusValidators{}
	mi := &file_consensus_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConsensusValidators) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConsensusValidators) ProtoMessage() {}

func (x *ConsensusValidators) ProtoReflect() protoreflect.Message {
	mi := &file_consensus_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ConsensusValidators.ProtoReflect.Descriptor instead.
func (*ConsensusValidators) Descriptor() ([]byte, []int) {
	return file_consensus_proto_rawDescGZIP(), []int{4}
}

func (x *ConsensusValidators) GetValidatorSet() []*ConsensusValidator {
	if x != nil {
		return x.ValidatorSet
	}
	return nil
}

// LotteryWinner is a structure that holds the subject of a pseudorandom selection and their % cut of the reward
// This is used for delegation + sub-delegation + sub-validator earnings
type LotteryWinner struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// winner: the 20 byte address of the selected actor
	Winner []byte `protobuf:"bytes,1,opt,name=winner,proto3" json:"winner"` // @gotags: json:"winner"
	// cut: the percent cut of the rewards
	Cut           uint64 `protobuf:"varint,2,opt,name=cut,proto3" json:"cut,omitempty"` // @gotags json:"cut"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LotteryWinner) Reset() {
	*x = LotteryWinner{}
	mi := &file_consensus_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *LotteryWinner) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*LotteryWinner) ProtoMessage() {}

func (x *LotteryWinner) ProtoReflect() protoreflect.Message {
	mi := &file_consensus_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use LotteryWinner.ProtoReflect.Descriptor instead.
func (*LotteryWinner) Descriptor() ([]byte, []int) {
	return file_consensus_proto_rawDescGZIP(), []int{5}
}

func (x *LotteryWinner) GetWinner() []byte {
	if x != nil {
		return x.Winner
	}
	return nil
}

func (x *LotteryWinner) GetCut() uint64 {
	if x != nil {
		return x.Cut
	}
	return 0
}

// RootChainInfo maintains root-chain data needed for consensus
type RootChainInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// root_chain_id: the chain id of the root chain
	RootChainId uint64 `protobuf:"varint,1,opt,name=root_chain_id,json=rootChainId,proto3" json:"rootChainId"` // @gotags: json:"rootChainId"
	// height: the block height of the root chain
	Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height"` // @gotags: json:"height"
	// validator_set: the current validator set
	ValidatorSet *ConsensusValidators `protobuf:"bytes,3,opt,name=validator_set,json=validatorSet,proto3" json:"validatorSet"` // @gotags: json:"validatorSet"
	// last_validator_set: the validator set of the previous height
	LastValidatorSet *ConsensusValidators `protobuf:"bytes,4,opt,name=last_validator_set,json=lastValidatorSet,proto3" json:"lastValidatorSet"` // @gotags: json:"lastValidatorSet"
	// lottery_winner: the selected delegate/pseudo-validator who receives rewards
	LotteryWinner *LotteryWinner `protobuf:"bytes,5,opt,name=lottery_winner,json=lotteryWinner,proto3" json:"lotteryWinner"` // @gotags: json:"lotteryWinner"
	// orders: the swap order book from the 'root chain' for the 'nested chain'
	Orders *OrderBook `protobuf:"bytes,6,opt,name=orders,proto3" json:"orders"` // @gotags: json:"orders"
	// timestamp: a timestamp of when the notification should cause a reset
	Timestamp     uint64 `protobuf:"varint,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RootChainInfo) Reset() {
	*x = RootChainInfo{}
	mi := &file_consensus_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RootChainInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RootChainInfo) ProtoMessage() {}

func (x *RootChainInfo) ProtoReflect() protoreflect.Message {
	mi := &file_consensus_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RootChainInfo.ProtoReflect.Descriptor instead.
func (*RootChainInfo) Descriptor() ([]byte, []int) {
	return file_consensus_proto_rawDescGZIP(), []int{6}
}

func (x *RootChainInfo) GetRootChainId() uint64 {
	if x != nil {
		return x.RootChainId
	}
	return 0
}

func (x *RootChainInfo) GetHeight() uint64 {
	if x != nil {
		return x.Height
	}
	return 0
}

func (x *RootChainInfo) GetValidatorSet() *ConsensusValidators {
	if x != nil {
		return x.ValidatorSet
	}
	return nil
}

func (x *RootChainInfo) GetLastValidatorSet() *ConsensusValidators {
	if x != nil {
		return x.LastValidatorSet
	}
	return nil
}

func (x *RootChainInfo) GetLotteryWinner() *LotteryWinner {
	if x != nil {
		return x.LotteryWinner
	}
	return nil
}

func (x *RootChainInfo) GetOrders() *OrderBook {
	if x != nil {
		return x.Orders
	}
	return nil
}

func (x *RootChainInfo) GetTimestamp() uint64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

var File_consensus_proto protoreflect.FileDescriptor

const file_consensus_proto_rawDesc = "" +
	"\n" +
	"\x0fconsensus.proto\x12\x05types\x1a\n" +
	"swap.proto\"\xb3\x01\n" +
	"\x04View\x12\x1d\n" +
	"\n" +
	"network_id\x18\x01 \x01(\x04R\tnetworkId\x12\x19\n" +
	"\bchain_id\x18\x02 \x01(\x04R\achainId\x12\x16\n" +
	"\x06height\x18\x03 \x01(\x04R\x06height\x12\x1f\n" +
	"\vroot_height\x18\x04 \x01(\x04R\n" +
	"rootHeight\x12\x14\n" +
	"\x05round\x18\x05 \x01(\x04R\x05round\x12\"\n" +
	"\x05phase\x18\x06 \x01(\x0e2\f.types.PhaseR\x05phase\"J\n" +
	"\x12AggregateSignature\x12\x1c\n" +
	"\tsignature\x18\x01 \x01(\fR\tsignature\x12\x16\n" +
	"\x06bitmap\x18\x02 \x01(\fR\x06bitmap\")\n" +
	"\tProposers\x12\x1c\n" +
	"\taddresses\x18\x01 \x03(\fR\taddresses\"w\n" +
	"\x12ConsensusValidator\x12\x1d\n" +
	"\n" +
	"public_key\x18\x01 \x01(\fR\tpublicKey\x12!\n" +
	"\fvoting_power\x18\x02 \x01(\x04R\vvotingPower\x12\x1f\n" +
	"\vnet_address\x18\x03 \x01(\tR\n" +
	"netAddress\"T\n" +
	"\x13ConsensusValidators\x12=\n" +
	"\fValidatorSet\x18\x01 \x03(\v2\x19.types.ConsensusValidatorR\fValidatorSet\"9\n" +
	"\rLotteryWinner\x12\x16\n" +
	"\x06winner\x18\x01 \x01(\fR\x06winner\x12\x10\n" +
	"\x03cut\x18\x02 \x01(\x04R\x03cut\"\xdb\x02\n" +
	"\rRootChainInfo\x12\"\n" +
	"\rroot_chain_id\x18\x01 \x01(\x04R\vrootChainId\x12\x16\n" +
	"\x06height\x18\x02 \x01(\x04R\x06height\x12?\n" +
	"\rvalidator_set\x18\x03 \x01(\v2\x1a.types.ConsensusValidatorsR\fvalidatorSet\x12H\n" +
	"\x12last_validator_set\x18\x04 \x01(\v2\x1a.types.ConsensusValidatorsR\x10lastValidatorSet\x12;\n" +
	"\x0elottery_winner\x18\x05 \x01(\v2\x14.types.LotteryWinnerR\rlotteryWinner\x12(\n" +
	"\x06orders\x18\x06 \x01(\v2\x10.types.OrderBookR\x06orders\x12\x1c\n" +
	"\ttimestamp\x18\a \x01(\x04R\ttimestamp*\xbb\x01\n" +
	"\x05Phase\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\f\n" +
	"\bELECTION\x10\x01\x12\x11\n" +
	"\rELECTION_VOTE\x10\x02\x12\v\n" +
	"\aPROPOSE\x10\x03\x12\x10\n" +
	"\fPROPOSE_VOTE\x10\x04\x12\r\n" +
	"\tPRECOMMIT\x10\x05\x12\x12\n" +
	"\x0ePRECOMMIT_VOTE\x10\x06\x12\n" +
	"\n" +
	"\x06COMMIT\x10\a\x12\x12\n" +
	"\x0eCOMMIT_PROCESS\x10\b\x12\x13\n" +
	"\x0fROUND_INTERRUPT\x10\t\x12\r\n" +
	"\tPACEMAKER\x10\n" +
	"B&Z$github.com/canopy-network/canopy/libb\x06proto3"

var (
	file_consensus_proto_rawDescOnce sync.Once
	file_consensus_proto_rawDescData []byte
)

func file_consensus_proto_rawDescGZIP() []byte {
	file_consensus_proto_rawDescOnce.Do(func() {
		file_consensus_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_consensus_proto_rawDesc), len(file_consensus_proto_rawDesc)))
	})
	return file_consensus_proto_rawDescData
}

var file_consensus_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_consensus_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_consensus_proto_goTypes = []any{
	(Phase)(0),                  // 0: types.Phase
	(*View)(nil),                // 1: types.View
	(*AggregateSignature)(nil),  // 2: types.AggregateSignature
	(*Proposers)(nil),           // 3: types.Proposers
	(*ConsensusValidator)(nil),  // 4: types.ConsensusValidator
	(*ConsensusValidators)(nil), // 5: types.ConsensusValidators
	(*LotteryWinner)(nil),       // 6: types.LotteryWinner
	(*RootChainInfo)(nil),       // 7: types.RootChainInfo
	(*OrderBook)(nil),           // 8: types.OrderBook
}
var file_consensus_proto_depIdxs = []int32{
	0, // 0: types.View.phase:type_name -> types.Phase
	4, // 1: types.ConsensusValidators.ValidatorSet:type_name -> types.ConsensusValidator
	5, // 2: types.RootChainInfo.validator_set:type_name -> types.ConsensusValidators
	5, // 3: types.RootChainInfo.last_validator_set:type_name -> types.ConsensusValidators
	6, // 4: types.RootChainInfo.lottery_winner:type_name -> types.LotteryWinner
	8, // 5: types.RootChainInfo.orders:type_name -> types.OrderBook
	6, // [6:6] is the sub-list for method output_type
	6, // [6:6] is the sub-list for method input_type
	6, // [6:6] is the sub-list for extension type_name
	6, // [6:6] is the sub-list for extension extendee
	0, // [0:6] is the sub-list for field type_name
}

func init() { file_consensus_proto_init() }
func file_consensus_proto_init() {
	if File_consensus_proto != nil {
		return
	}
	file_swap_proto_init()
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_consensus_proto_rawDesc), len(file_consensus_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   7,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_consensus_proto_goTypes,
		DependencyIndexes: file_consensus_proto_depIdxs,
		EnumInfos:         file_consensus_proto_enumTypes,
		MessageInfos:      file_consensus_proto_msgTypes,
	}.Build()
	File_consensus_proto = out.File
	file_consensus_proto_goTypes = nil
	file_consensus_proto_depIdxs = nil
}
