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

package fsm

import (
	lib "github.com/canopy-network/canopy/lib"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	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
// *****************************************************************************************************
// _
// _
// _
// MessageSend is a standard transfer transaction, taking tokens from the sender and transferring
// them to the recipient
type MessageSend struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// from_address: is the sender of the funds
	FromAddress []byte `protobuf:"bytes,1,opt,name=from_address,json=fromAddress,proto3" json:"fromAddress"` // @gotags: json:"fromAddress"
	// to_address: is the recipient of the funds
	ToAddress []byte `protobuf:"bytes,2,opt,name=to_address,json=toAddress,proto3" json:"toAddress"` // @gotags: json:"toAddress"
	// amount: is the amount of tokens in micro-denomination (uCNPY)
	Amount        uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageSend) ProtoMessage() {}

func (x *MessageSend) ProtoReflect() protoreflect.Message {
	mi := &file_message_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 MessageSend.ProtoReflect.Descriptor instead.
func (*MessageSend) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{0}
}

func (x *MessageSend) GetFromAddress() []byte {
	if x != nil {
		return x.FromAddress
	}
	return nil
}

func (x *MessageSend) GetToAddress() []byte {
	if x != nil {
		return x.ToAddress
	}
	return nil
}

func (x *MessageSend) GetAmount() uint64 {
	if x != nil {
		return x.Amount
	}
	return 0
}

// MessageStake is the Validator registration message, locking up a certain amount of tokens.
// Staking as a non-delegate is registering for active participation in the committee(s) consensus process(es),
// whereas delegate is passive participation that acts as a contribution to which committees are subsidized by the
// protocol. Either the operator or the sender may originate the stake transaction, but the funds are removed from
// the sender's account
type MessageStake struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// public_key: the public cryptographic identity of the Validator operator that is unique to a users
	// secret private key
	PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"publicKey"` // @gotags: json:"publicKey"
	// amount: is the amount of tokens to be removed from the sender account and locked as a surety bond against bad
	// behavior
	Amount uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// committees: is the list of committees the validator is restaking their tokens towards
	Committees []uint64 `protobuf:"varint,3,rep,packed,name=committees,proto3" json:"committees,omitempty"`
	// net_address: is the tcp peer-to-peer address of the peer
	NetAddress string `protobuf:"bytes,4,opt,name=net_address,json=netAddress,proto3" json:"netAddress"` // @gotags: json:"netAddress"
	// output_address: is the short version of the public key where reward and unstaking funds will be distributed to
	OutputAddress []byte `protobuf:"bytes,5,opt,name=output_address,json=outputAddress,proto3" json:"outputAddress"` // @gotags: json:"outputAddress"
	// delegate: signals whether the Validator is a delegate or not
	Delegate bool `protobuf:"varint,6,opt,name=delegate,proto3" json:"delegate,omitempty"`
	// compound: signals whether the Validator is auto-compounding or not
	Compound bool `protobuf:"varint,7,opt,name=compound,proto3" json:"compound,omitempty"`
	// signer: auto-populated by the state machine to assign the authorized signer who executed the transaction
	Signer        []byte `protobuf:"bytes,8,opt,name=signer,proto3" json:"signer,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageStake) ProtoMessage() {}

func (x *MessageStake) ProtoReflect() protoreflect.Message {
	mi := &file_message_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 MessageStake.ProtoReflect.Descriptor instead.
func (*MessageStake) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{1}
}

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

func (x *MessageStake) GetAmount() uint64 {
	if x != nil {
		return x.Amount
	}
	return 0
}

func (x *MessageStake) GetCommittees() []uint64 {
	if x != nil {
		return x.Committees
	}
	return nil
}

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

func (x *MessageStake) GetOutputAddress() []byte {
	if x != nil {
		return x.OutputAddress
	}
	return nil
}

func (x *MessageStake) GetDelegate() bool {
	if x != nil {
		return x.Delegate
	}
	return false
}

func (x *MessageStake) GetCompound() bool {
	if x != nil {
		return x.Compound
	}
	return false
}

func (x *MessageStake) GetSigner() []byte {
	if x != nil {
		return x.Signer
	}
	return nil
}

// MessageStake is the Validator modification message, it allows an increase locking up a certain amount of tokens,
// a change to the committees, the p2p address, the output address, and auto-compounding status
// To leave fields un-edited, simply use the previous value
type MessageEditStake struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// address: the short version of the public key, acting as a unique identify linked to the Validator structure
	Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// amount: the updated amount of tokens being staked. This must be greater than or equal to the previous staked amount
	// The user's account balance is reduced by the difference between the old and new staked amounts
	// (old.Staked_Tokens - message.amount)
	Amount uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// committees: the update to the committees the validator is restaking their tokens for
	Committees []uint64 `protobuf:"varint,3,rep,packed,name=committees,proto3" json:"committees,omitempty"`
	// net_address: the update to the tcp peer-to-peer address of the peer
	NetAddress string `protobuf:"bytes,4,opt,name=net_address,json=netAddress,proto3" json:"netAddress"` // @gotags: json:"netAddress"
	// output_address: the update to the reward address, only the output address may edit this
	OutputAddress []byte `protobuf:"bytes,5,opt,name=output_address,json=outputAddress,proto3" json:"outputAddress"` // @gotags: json:"outputAddress"
	// compound: the update to the auto-compounding status
	Compound bool `protobuf:"varint,6,opt,name=compound,proto3" json:"compound,omitempty"`
	// signer: this field is needed so that the protocol may save the signer once they're identified by their public key
	// this is necessary because only the output address may edit the output field.
	Signer        []byte `protobuf:"bytes,7,opt,name=signer,proto3" json:"signer,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageEditStake) ProtoMessage() {}

func (x *MessageEditStake) ProtoReflect() protoreflect.Message {
	mi := &file_message_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 MessageEditStake.ProtoReflect.Descriptor instead.
func (*MessageEditStake) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{2}
}

func (x *MessageEditStake) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *MessageEditStake) GetAmount() uint64 {
	if x != nil {
		return x.Amount
	}
	return 0
}

func (x *MessageEditStake) GetCommittees() []uint64 {
	if x != nil {
		return x.Committees
	}
	return nil
}

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

func (x *MessageEditStake) GetOutputAddress() []byte {
	if x != nil {
		return x.OutputAddress
	}
	return nil
}

func (x *MessageEditStake) GetCompound() bool {
	if x != nil {
		return x.Compound
	}
	return false
}

func (x *MessageEditStake) GetSigner() []byte {
	if x != nil {
		return x.Signer
	}
	return nil
}

// MessageUnstake is the Validator leave message, it begins the process of a Validator exiting the network
// The block when the funds will be returned may be found in the Validator structure after submitting this transaction
type MessageUnstake struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// address: the short version of the public key, acting as a unique identify linked to the Validator structure
	Address       []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageUnstake) ProtoMessage() {}

func (x *MessageUnstake) ProtoReflect() protoreflect.Message {
	mi := &file_message_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 MessageUnstake.ProtoReflect.Descriptor instead.
func (*MessageUnstake) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{3}
}

func (x *MessageUnstake) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

// MessagePause is the Validator break message, it temporarily removes the Validator from active duty
// This allows operators a path to gracefully maintain their Validators without fully exiting
type MessagePause struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// address: the short version of the public key, acting as a unique identify linked to the Validator structure
	Address       []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessagePause) ProtoMessage() {}

func (x *MessagePause) ProtoReflect() protoreflect.Message {
	mi := &file_message_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 MessagePause.ProtoReflect.Descriptor instead.
func (*MessagePause) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{4}
}

func (x *MessagePause) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

// MessageUnpause is the Validator return message, it re-enlists the Validator to active duty
type MessageUnpause struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// address: the short version of the public key, acting as a unique identify linked to the Validator structure
	Address       []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageUnpause) ProtoMessage() {}

func (x *MessageUnpause) ProtoReflect() protoreflect.Message {
	mi := &file_message_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 MessageUnpause.ProtoReflect.Descriptor instead.
func (*MessageUnpause) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{5}
}

func (x *MessageUnpause) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

// MessageChangeParameter is a governance proposal message used to modify a governance parameter
// This type of message must be manually pre-approved by +2/3rds of the Validators via their APPROVE_LIST
// In short, a 'proposer' generates the message JSON, communicates the JSON to Validators, Validators vote
// by populating their APPROVE_LIST which configures how they'll vote during the consensus process when a
// block includes this transaction in it.
type MessageChangeParameter struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// parameter_space: is the organization path where the parameter is found (val, cons, fee, gov)
	ParameterSpace string `protobuf:"bytes,1,opt,name=parameter_space,json=parameterSpace,proto3" json:"parameterSpace"` // @gotags: json:"parameterSpace"
	// parameter_key: is the name of the parameter
	ParameterKey string `protobuf:"bytes,2,opt,name=parameter_key,json=parameterKey,proto3" json:"parameterKey"` // @gotags: json:"parameterKey"
	// parameter_value: is the uint64 or string value of the parameter
	ParameterValue *anypb.Any `protobuf:"bytes,3,opt,name=parameter_value,json=parameterValue,proto3" json:"parameterValue"` // @gotags: json:"parameterValue"
	// start_height: is the beginning height where the parameter must be sent
	// this field locks in a block-range when it's converted to JSON and allows Validators a deadline to vote
	StartHeight uint64 `protobuf:"varint,4,opt,name=start_height,json=startHeight,proto3" json:"startHeight"` // @gotags: json:"startHeight"
	// end_height: is the ending height where the parameter must be sent
	// this field locks in a block-range when it's converted to JSON and allows Validators a deadline to vote
	EndHeight uint64 `protobuf:"varint,5,opt,name=end_height,json=endHeight,proto3" json:"endHeight"` // @gotags: json:"endHeight"
	// signer: is the address of the sender / creator of the proposal
	// this field locks in an author of the transaction when it's converted to JSON
	Signer []byte `protobuf:"bytes,6,opt,name=signer,proto3" json:"signer,omitempty"`
	// proposal_hash: internal use only, tracks the hash of the proposal to check against the proposals.json file
	ProposalHash  string `protobuf:"bytes,7,opt,name=proposal_hash,json=proposalHash,proto3" json:"proposalHash"` // @gotags: json:"proposalHash"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageChangeParameter) ProtoMessage() {}

func (x *MessageChangeParameter) ProtoReflect() protoreflect.Message {
	mi := &file_message_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 MessageChangeParameter.ProtoReflect.Descriptor instead.
func (*MessageChangeParameter) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{6}
}

func (x *MessageChangeParameter) GetParameterSpace() string {
	if x != nil {
		return x.ParameterSpace
	}
	return ""
}

func (x *MessageChangeParameter) GetParameterKey() string {
	if x != nil {
		return x.ParameterKey
	}
	return ""
}

func (x *MessageChangeParameter) GetParameterValue() *anypb.Any {
	if x != nil {
		return x.ParameterValue
	}
	return nil
}

func (x *MessageChangeParameter) GetStartHeight() uint64 {
	if x != nil {
		return x.StartHeight
	}
	return 0
}

func (x *MessageChangeParameter) GetEndHeight() uint64 {
	if x != nil {
		return x.EndHeight
	}
	return 0
}

func (x *MessageChangeParameter) GetSigner() []byte {
	if x != nil {
		return x.Signer
	}
	return nil
}

func (x *MessageChangeParameter) GetProposalHash() string {
	if x != nil {
		return x.ProposalHash
	}
	return ""
}

// MessageDAOTransfer is a governance proposal message used to send funds from the DAO pool to an account
// This type of message must be manually pre-approved by +2/3rds of the Validators via their APPROVE_LIST
// In short, a 'proposer' generates the message JSON, communicates the JSON to Validators, Validators vote
// by populating their APPROVE_LIST which configures how they'll vote during the consensus process when a
// block includes this transaction in it.
type MessageDAOTransfer struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// address: is the recipient address and sender of this message
	Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// amount: is the amount of
	Amount uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// start_height: is the beginning height where the parameter must be sent
	// this field locks in a block-range when it's converted to JSON and allows Validators a deadline to vote
	StartHeight uint64 `protobuf:"varint,4,opt,name=start_height,json=startHeight,proto3" json:"startHeight"` // @gotags: json:"startHeight"
	// end_height: is the ending height where the parameter must be sent
	// this field locks in a block-range when it's converted to JSON and allows Validators a deadline to vote
	EndHeight uint64 `protobuf:"varint,5,opt,name=end_height,json=endHeight,proto3" json:"startHeight"` // @gotags: json:"startHeight"
	// proposal_hash: internal use only, tracks the hash of the proposal to check against the proposals.json file
	ProposalHash  string `protobuf:"bytes,6,opt,name=proposal_hash,json=proposalHash,proto3" json:"proposalHash"` // @gotags: json:"proposalHash"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MessageDAOTransfer) Reset() {
	*x = MessageDAOTransfer{}
	mi := &file_message_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MessageDAOTransfer) ProtoMessage() {}

func (x *MessageDAOTransfer) ProtoReflect() protoreflect.Message {
	mi := &file_message_proto_msgTypes[7]
	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 MessageDAOTransfer.ProtoReflect.Descriptor instead.
func (*MessageDAOTransfer) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{7}
}

func (x *MessageDAOTransfer) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *MessageDAOTransfer) GetAmount() uint64 {
	if x != nil {
		return x.Amount
	}
	return 0
}

func (x *MessageDAOTransfer) GetStartHeight() uint64 {
	if x != nil {
		return x.StartHeight
	}
	return 0
}

func (x *MessageDAOTransfer) GetEndHeight() uint64 {
	if x != nil {
		return x.EndHeight
	}
	return 0
}

func (x *MessageDAOTransfer) GetProposalHash() string {
	if x != nil {
		return x.ProposalHash
	}
	return ""
}

// MessageCertificateResults is a summary from the Leader of a recently completed BFT process in the form of a Quorum
// Certificate signed by a super-majority of the committee members at a given height.
// This message defines committee treasury pool recipients, slash recipients, sell orders actions, and checkpoints
type MessageCertificateResults struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// qc: a super-majority signed quorum certificate from a recently completed BFT process (COMMIT_PROCESS phase)
	Qc            *lib.QuorumCertificate `protobuf:"bytes,1,opt,name=qc,proto3" json:"qc,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MessageCertificateResults) Reset() {
	*x = MessageCertificateResults{}
	mi := &file_message_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MessageCertificateResults) ProtoMessage() {}

func (x *MessageCertificateResults) ProtoReflect() protoreflect.Message {
	mi := &file_message_proto_msgTypes[8]
	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 MessageCertificateResults.ProtoReflect.Descriptor instead.
func (*MessageCertificateResults) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{8}
}

func (x *MessageCertificateResults) GetQc() *lib.QuorumCertificate {
	if x != nil {
		return x.Qc
	}
	return nil
}

// MessageSubsidy is an account to committee treasury pool transfer transaction
// At economic maturity without inflation, this is how the network continues to offer its Validation services
type MessageSubsidy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// address: is the sender of the funds
	Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// chain_id: is the id of the committee the funds are being sent to
	ChainId uint64 `protobuf:"varint,2,opt,name=chain_id,json=chainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	// amount: is the amount of funds that are taken from the sender and transferred to the recipient pool
	Amount uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// opcode: a generic code field to allow fund designation instructions
	Opcode        []byte `protobuf:"bytes,4,opt,name=opcode,proto3" json:"opcode,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MessageSubsidy) Reset() {
	*x = MessageSubsidy{}
	mi := &file_message_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MessageSubsidy) ProtoMessage() {}

func (x *MessageSubsidy) ProtoReflect() protoreflect.Message {
	mi := &file_message_proto_msgTypes[9]
	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 MessageSubsidy.ProtoReflect.Descriptor instead.
func (*MessageSubsidy) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{9}
}

func (x *MessageSubsidy) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

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

func (x *MessageSubsidy) GetAmount() uint64 {
	if x != nil {
		return x.Amount
	}
	return 0
}

func (x *MessageSubsidy) GetOpcode() []byte {
	if x != nil {
		return x.Opcode
	}
	return nil
}

// MessageCreateOrder creates a new token swap 'sell order', removing tokens from the sender
// account and transferring them to an escrow pool while awaiting a buyer
type MessageCreateOrder struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// chain_id: the id of the committee that is responsible for the 'counter asset' the uCNPY will swapped for
	ChainId uint64 `protobuf:"varint,1,opt,name=ChainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	// data: a generic data field which can allow a committee to execute specific functionality for the swap
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data"` // @gotags: json:"data"
	// amount_for_sale: the amount of uCNPY listed for sale, transferred to escrow
	AmountForSale uint64 `protobuf:"varint,3,opt,name=AmountForSale,proto3" json:"amountForSale"` // @gotags: json:"amountForSale"
	// requested_amount: the amount of the 'counter asset' the buyer must send in order to complete a swap
	RequestedAmount uint64 `protobuf:"varint,4,opt,name=RequestedAmount,proto3" json:"requestAmount"` // @gotags: json:"requestAmount"
	// sellers_receive_address: the address of the seller where the 'counter asset' will be received
	SellerReceiveAddress []byte `protobuf:"bytes,5,opt,name=SellerReceiveAddress,proto3" json:"sellerReceiveAddress"` // @gotags: json:"sellerReceiveAddress"
	// sellers_send_address: the Canopy address the seller is selling and signing from
	SellersSendAddress []byte `protobuf:"bytes,6,opt,name=SellersSendAddress,proto3" json:"sellersSendAddress"` // @gotags: json:"sellersSendAddress"
	// OrderId: auto-populated by the state machine to assign the unique bytes to the order
	OrderId       []byte `protobuf:"bytes,7,opt,name=OrderId,proto3" json:"OrderId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MessageCreateOrder) Reset() {
	*x = MessageCreateOrder{}
	mi := &file_message_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MessageCreateOrder) ProtoMessage() {}

func (x *MessageCreateOrder) ProtoReflect() protoreflect.Message {
	mi := &file_message_proto_msgTypes[10]
	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 MessageCreateOrder.ProtoReflect.Descriptor instead.
func (*MessageCreateOrder) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{10}
}

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

func (x *MessageCreateOrder) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *MessageCreateOrder) GetAmountForSale() uint64 {
	if x != nil {
		return x.AmountForSale
	}
	return 0
}

func (x *MessageCreateOrder) GetRequestedAmount() uint64 {
	if x != nil {
		return x.RequestedAmount
	}
	return 0
}

func (x *MessageCreateOrder) GetSellerReceiveAddress() []byte {
	if x != nil {
		return x.SellerReceiveAddress
	}
	return nil
}

func (x *MessageCreateOrder) GetSellersSendAddress() []byte {
	if x != nil {
		return x.SellersSendAddress
	}
	return nil
}

func (x *MessageCreateOrder) GetOrderId() []byte {
	if x != nil {
		return x.OrderId
	}
	return nil
}

// MessageEditOrder modifies an un-claimed token swap 'sell order', token amount may be increased or decreased as well
// as the recipient address
// If an order is already 'claimed' or 'bought', the order may not be modified
type MessageEditOrder struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// order_id: is the number id that is unique to this committee to identify the order
	// not modifiable, used for order identification only
	OrderId []byte `protobuf:"bytes,1,opt,name=OrderId,proto3" json:"orderID"` // @gotags: json:"orderID"
	// chain_id: the id of the committee that is responsible for the 'counter asset' the uCNPY will swapped for
	// not modifiable, used for order identification only
	ChainId uint64 `protobuf:"varint,2,opt,name=ChainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	// data: a generic data field which can allow a committee to execute specific functionality for the swap
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data"` // @gotags: json:"data"
	// amount_for_sale: the updated amount of uCNPY listed for sale, a reduction will return escrowed tokens to the seller's
	// send address
	AmountForSale uint64 `protobuf:"varint,4,opt,name=AmountForSale,proto3" json:"amountForSale"` // @gotags: json:"amountForSale"
	// requested_amount: the updated amount of the 'counter asset' the buyer must send in order to complete a swap
	RequestedAmount uint64 `protobuf:"varint,5,opt,name=RequestedAmount,proto3" json:"requestedAmount"` // @gotags: json:"requestedAmount"
	// sellers_receive_address: the address of the seller where the 'counter asset' will be received
	SellerReceiveAddress []byte `protobuf:"bytes,6,opt,name=SellerReceiveAddress,proto3" json:"sellerReceiveAddress"` // @gotags: json:"sellerReceiveAddress"
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *MessageEditOrder) Reset() {
	*x = MessageEditOrder{}
	mi := &file_message_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MessageEditOrder) ProtoMessage() {}

func (x *MessageEditOrder) ProtoReflect() protoreflect.Message {
	mi := &file_message_proto_msgTypes[11]
	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 MessageEditOrder.ProtoReflect.Descriptor instead.
func (*MessageEditOrder) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{11}
}

func (x *MessageEditOrder) GetOrderId() []byte {
	if x != nil {
		return x.OrderId
	}
	return nil
}

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

func (x *MessageEditOrder) GetData() []byte {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *MessageEditOrder) GetAmountForSale() uint64 {
	if x != nil {
		return x.AmountForSale
	}
	return 0
}

func (x *MessageEditOrder) GetRequestedAmount() uint64 {
	if x != nil {
		return x.RequestedAmount
	}
	return 0
}

func (x *MessageEditOrder) GetSellerReceiveAddress() []byte {
	if x != nil {
		return x.SellerReceiveAddress
	}
	return nil
}

// MessageDeleteOrder: deletes an un-claimed token swap 'sell order'
// If an order is already 'claimed' or 'bought', the order may not be deleted
type MessageDeleteOrder struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// order_id: is the number id that is unique to this committee to identify the order
	OrderId []byte `protobuf:"bytes,1,opt,name=OrderId,proto3" json:"orderID"` // @gotags: json:"orderID"
	// chain_id: the id of the committee that is responsible for the 'counter asset' the uCNPY will swapped for
	ChainId       uint64 `protobuf:"varint,2,opt,name=ChainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MessageDeleteOrder) Reset() {
	*x = MessageDeleteOrder{}
	mi := &file_message_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MessageDeleteOrder) ProtoMessage() {}

func (x *MessageDeleteOrder) ProtoReflect() protoreflect.Message {
	mi := &file_message_proto_msgTypes[12]
	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 MessageDeleteOrder.ProtoReflect.Descriptor instead.
func (*MessageDeleteOrder) Descriptor() ([]byte, []int) {
	return file_message_proto_rawDescGZIP(), []int{12}
}

func (x *MessageDeleteOrder) GetOrderId() []byte {
	if x != nil {
		return x.OrderId
	}
	return nil
}

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

var File_message_proto protoreflect.FileDescriptor

const file_message_proto_rawDesc = "" +
	"\n" +
	"\rmessage.proto\x12\x05types\x1a\x19google/protobuf/any.proto\x1a\x11certificate.proto\"g\n" +
	"\vMessageSend\x12!\n" +
	"\ffrom_address\x18\x01 \x01(\fR\vfromAddress\x12\x1d\n" +
	"\n" +
	"to_address\x18\x02 \x01(\fR\ttoAddress\x12\x16\n" +
	"\x06amount\x18\x03 \x01(\x04R\x06amount\"\xfd\x01\n" +
	"\fMessageStake\x12\x1d\n" +
	"\n" +
	"public_key\x18\x01 \x01(\fR\tpublicKey\x12\x16\n" +
	"\x06amount\x18\x02 \x01(\x04R\x06amount\x12\x1e\n" +
	"\n" +
	"committees\x18\x03 \x03(\x04R\n" +
	"committees\x12\x1f\n" +
	"\vnet_address\x18\x04 \x01(\tR\n" +
	"netAddress\x12%\n" +
	"\x0eoutput_address\x18\x05 \x01(\fR\routputAddress\x12\x1a\n" +
	"\bdelegate\x18\x06 \x01(\bR\bdelegate\x12\x1a\n" +
	"\bcompound\x18\a \x01(\bR\bcompound\x12\x16\n" +
	"\x06signer\x18\b \x01(\fR\x06signer\"\xe0\x01\n" +
	"\x10MessageEditStake\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\fR\aaddress\x12\x16\n" +
	"\x06amount\x18\x02 \x01(\x04R\x06amount\x12\x1e\n" +
	"\n" +
	"committees\x18\x03 \x03(\x04R\n" +
	"committees\x12\x1f\n" +
	"\vnet_address\x18\x04 \x01(\tR\n" +
	"netAddress\x12%\n" +
	"\x0eoutput_address\x18\x05 \x01(\fR\routputAddress\x12\x1a\n" +
	"\bcompound\x18\x06 \x01(\bR\bcompound\x12\x16\n" +
	"\x06signer\x18\a \x01(\fR\x06signer\"*\n" +
	"\x0eMessageUnstake\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\fR\aaddress\"(\n" +
	"\fMessagePause\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\fR\aaddress\"*\n" +
	"\x0eMessageUnpause\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\fR\aaddress\"\xa4\x02\n" +
	"\x16MessageChangeParameter\x12'\n" +
	"\x0fparameter_space\x18\x01 \x01(\tR\x0eparameterSpace\x12#\n" +
	"\rparameter_key\x18\x02 \x01(\tR\fparameterKey\x12=\n" +
	"\x0fparameter_value\x18\x03 \x01(\v2\x14.google.protobuf.AnyR\x0eparameterValue\x12!\n" +
	"\fstart_height\x18\x04 \x01(\x04R\vstartHeight\x12\x1d\n" +
	"\n" +
	"end_height\x18\x05 \x01(\x04R\tendHeight\x12\x16\n" +
	"\x06signer\x18\x06 \x01(\fR\x06signer\x12#\n" +
	"\rproposal_hash\x18\a \x01(\tR\fproposalHash\"\xad\x01\n" +
	"\x12MessageDAOTransfer\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\fR\aaddress\x12\x16\n" +
	"\x06amount\x18\x02 \x01(\x04R\x06amount\x12!\n" +
	"\fstart_height\x18\x04 \x01(\x04R\vstartHeight\x12\x1d\n" +
	"\n" +
	"end_height\x18\x05 \x01(\x04R\tendHeight\x12#\n" +
	"\rproposal_hash\x18\x06 \x01(\tR\fproposalHash\"E\n" +
	"\x19MessageCertificateResults\x12(\n" +
	"\x02qc\x18\x01 \x01(\v2\x18.types.QuorumCertificateR\x02qc\"u\n" +
	"\x0eMessageSubsidy\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\fR\aaddress\x12\x19\n" +
	"\bchain_id\x18\x02 \x01(\x04R\achainId\x12\x16\n" +
	"\x06amount\x18\x03 \x01(\x04R\x06amount\x12\x16\n" +
	"\x06opcode\x18\x04 \x01(\fR\x06opcode\"\x90\x02\n" +
	"\x12MessageCreateOrder\x12\x18\n" +
	"\aChainId\x18\x01 \x01(\x04R\aChainId\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\x12$\n" +
	"\rAmountForSale\x18\x03 \x01(\x04R\rAmountForSale\x12(\n" +
	"\x0fRequestedAmount\x18\x04 \x01(\x04R\x0fRequestedAmount\x122\n" +
	"\x14SellerReceiveAddress\x18\x05 \x01(\fR\x14SellerReceiveAddress\x12.\n" +
	"\x12SellersSendAddress\x18\x06 \x01(\fR\x12SellersSendAddress\x12\x18\n" +
	"\aOrderId\x18\a \x01(\fR\aOrderId\"\xde\x01\n" +
	"\x10MessageEditOrder\x12\x18\n" +
	"\aOrderId\x18\x01 \x01(\fR\aOrderId\x12\x18\n" +
	"\aChainId\x18\x02 \x01(\x04R\aChainId\x12\x12\n" +
	"\x04data\x18\x03 \x01(\fR\x04data\x12$\n" +
	"\rAmountForSale\x18\x04 \x01(\x04R\rAmountForSale\x12(\n" +
	"\x0fRequestedAmount\x18\x05 \x01(\x04R\x0fRequestedAmount\x122\n" +
	"\x14SellerReceiveAddress\x18\x06 \x01(\fR\x14SellerReceiveAddress\"H\n" +
	"\x12MessageDeleteOrder\x12\x18\n" +
	"\aOrderId\x18\x01 \x01(\fR\aOrderId\x12\x18\n" +
	"\aChainId\x18\x02 \x01(\x04R\aChainIdB&Z$github.com/canopy-network/canopy/fsmb\x06proto3"

var (
	file_message_proto_rawDescOnce sync.Once
	file_message_proto_rawDescData []byte
)

func file_message_proto_rawDescGZIP() []byte {
	file_message_proto_rawDescOnce.Do(func() {
		file_message_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_message_proto_rawDesc), len(file_message_proto_rawDesc)))
	})
	return file_message_proto_rawDescData
}

var file_message_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
var file_message_proto_goTypes = []any{
	(*MessageSend)(nil),               // 0: types.MessageSend
	(*MessageStake)(nil),              // 1: types.MessageStake
	(*MessageEditStake)(nil),          // 2: types.MessageEditStake
	(*MessageUnstake)(nil),            // 3: types.MessageUnstake
	(*MessagePause)(nil),              // 4: types.MessagePause
	(*MessageUnpause)(nil),            // 5: types.MessageUnpause
	(*MessageChangeParameter)(nil),    // 6: types.MessageChangeParameter
	(*MessageDAOTransfer)(nil),        // 7: types.MessageDAOTransfer
	(*MessageCertificateResults)(nil), // 8: types.MessageCertificateResults
	(*MessageSubsidy)(nil),            // 9: types.MessageSubsidy
	(*MessageCreateOrder)(nil),        // 10: types.MessageCreateOrder
	(*MessageEditOrder)(nil),          // 11: types.MessageEditOrder
	(*MessageDeleteOrder)(nil),        // 12: types.MessageDeleteOrder
	(*anypb.Any)(nil),                 // 13: google.protobuf.Any
	(*lib.QuorumCertificate)(nil),     // 14: types.QuorumCertificate
}
var file_message_proto_depIdxs = []int32{
	13, // 0: types.MessageChangeParameter.parameter_value:type_name -> google.protobuf.Any
	14, // 1: types.MessageCertificateResults.qc:type_name -> types.QuorumCertificate
	2,  // [2:2] is the sub-list for method output_type
	2,  // [2:2] is the sub-list for method input_type
	2,  // [2:2] is the sub-list for extension type_name
	2,  // [2:2] is the sub-list for extension extendee
	0,  // [0:2] is the sub-list for field type_name
}

func init() { file_message_proto_init() }
func file_message_proto_init() {
	if File_message_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_message_proto_rawDesc), len(file_message_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   13,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_message_proto_goTypes,
		DependencyIndexes: file_message_proto_depIdxs,
		MessageInfos:      file_message_proto_msgTypes,
	}.Build()
	File_message_proto = out.File
	file_message_proto_goTypes = nil
	file_message_proto_depIdxs = nil
}
