btccheckpoint.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: babylon/btccheckpoint/v1/btccheckpoint.proto

package types

import (
	fmt "fmt"
	github_com_babylonchain_babylon_types "github.com/babylonchain/babylon/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// BtcStatus is an enum describing the current btc status of the checkpoint
type BtcStatus int32

const (
	// SUBMITTED Epoch has Submitted btc status if there ever was at least one
	// known submission on btc main chain
	Submitted BtcStatus = 0
	// CONFIRMED Epoch has Confirmed btc status if there ever was at least one
	// known submission on btc main chain which was k-deep
	Confirmed BtcStatus = 1
	// CONFIRMED Epoch has Finalized btc status if there is was at exactly one
	// knon submission on btc main chain which is w-deep
	Finalized BtcStatus = 2
)

var BtcStatus_name = map[int32]string{
	0: "EPOCH_STATUS_SUBMITTED",
	1: "EPOCH_STATUS_CONFIRMED",
	2: "EPOCH_STATUS_FINALIZED",
}

var BtcStatus_value = map[string]int32{
	"EPOCH_STATUS_SUBMITTED": 0,
	"EPOCH_STATUS_CONFIRMED": 1,
	"EPOCH_STATUS_FINALIZED": 2,
}

func (x BtcStatus) String() string {
	return proto.EnumName(BtcStatus_name, int32(x))
}

func (BtcStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{0}
}

// Consider we have a Merkle tree with following structure:
//
//	          ROOT
//	         /    \
//	    H1234      H5555
//	   /     \       \
//	 H12     H34      H55
//	/  \    /  \     /
//
// H1  H2  H3  H4  H5
// L1  L2  L3  L4  L5
// To prove L3 was part of ROOT we need:
// - btc_transaction_index = 2 which in binary is 010
// (where 0 means going left, 1 means going right in the tree)
// - merkle_nodes we'd have H4 || H12 || H5555
// By looking at 010 we would know that H4 is a right sibling,
// H12 is left, H5555 is right again.
type BTCSpvProof struct {
	// Valid bitcoin transaction containing OP_RETURN opcode.
	BtcTransaction []byte `protobuf:"bytes,1,opt,name=btc_transaction,json=btcTransaction,proto3" json:"btc_transaction,omitempty"`
	// Index of transaction within the block. Index is needed to determine if
	// currently hashed node is left or right.
	BtcTransactionIndex uint32 `protobuf:"varint,2,opt,name=btc_transaction_index,json=btcTransactionIndex,proto3" json:"btc_transaction_index,omitempty"`
	// List of concatenated intermediate merkle tree nodes, without root node and
	// leaf node against which we calculate the proof. Each node has 32 byte
	// length. Example proof can look like: 32_bytes_of_node1 || 32_bytes_of_node2
	// ||  32_bytes_of_node3 so the length of the proof will always be divisible
	// by 32.
	MerkleNodes []byte `protobuf:"bytes,3,opt,name=merkle_nodes,json=merkleNodes,proto3" json:"merkle_nodes,omitempty"`
	// Valid btc header which confirms btc_transaction.
	// Should have exactly 80 bytes
	ConfirmingBtcHeader *github_com_babylonchain_babylon_types.BTCHeaderBytes `protobuf:"bytes,4,opt,name=confirming_btc_header,json=confirmingBtcHeader,proto3,customtype=github.com/babylonchain/babylon/types.BTCHeaderBytes" json:"confirming_btc_header,omitempty"`
}

func (m *BTCSpvProof) Reset()         { *m = BTCSpvProof{} }
func (m *BTCSpvProof) String() string { return proto.CompactTextString(m) }
func (*BTCSpvProof) ProtoMessage()    {}
func (*BTCSpvProof) Descriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{0}
}
func (m *BTCSpvProof) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BTCSpvProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BTCSpvProof.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BTCSpvProof) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BTCSpvProof.Merge(m, src)
}
func (m *BTCSpvProof) XXX_Size() int {
	return m.Size()
}
func (m *BTCSpvProof) XXX_DiscardUnknown() {
	xxx_messageInfo_BTCSpvProof.DiscardUnknown(m)
}

var xxx_messageInfo_BTCSpvProof proto.InternalMessageInfo

func (m *BTCSpvProof) GetBtcTransaction() []byte {
	if m != nil {
		return m.BtcTransaction
	}
	return nil
}

func (m *BTCSpvProof) GetBtcTransactionIndex() uint32 {
	if m != nil {
		return m.BtcTransactionIndex
	}
	return 0
}

func (m *BTCSpvProof) GetMerkleNodes() []byte {
	if m != nil {
		return m.MerkleNodes
	}
	return nil
}

// Each provided OP_RETURN transaction can be idendtified by hash of block in
// which transaction was included and transaction index in the block
type TransactionKey struct {
	Index uint32                                                    `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Hash  *github_com_babylonchain_babylon_types.BTCHeaderHashBytes `protobuf:"bytes,2,opt,name=hash,proto3,customtype=github.com/babylonchain/babylon/types.BTCHeaderHashBytes" json:"hash,omitempty"`
}

func (m *TransactionKey) Reset()         { *m = TransactionKey{} }
func (m *TransactionKey) String() string { return proto.CompactTextString(m) }
func (*TransactionKey) ProtoMessage()    {}
func (*TransactionKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{1}
}
func (m *TransactionKey) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TransactionKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransactionKey.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TransactionKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionKey.Merge(m, src)
}
func (m *TransactionKey) XXX_Size() int {
	return m.Size()
}
func (m *TransactionKey) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionKey.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionKey proto.InternalMessageInfo

func (m *TransactionKey) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

// Checkpoint can be composed from multiple transactions, so to identify whole
// submission we need list of transaction keys.
// Each submission can generally be identified by this list of (txIdx,
// blockHash) tuples. Note: this could possibly be optimized as if transactions
// were in one block they would have the same block hash and different indexes,
// but each blockhash is only 33 (1  byte for prefix encoding and 32 byte hash),
// so there should be other strong arguments for this optimization
type SubmissionKey struct {
	Key []*TransactionKey `protobuf:"bytes,1,rep,name=key,proto3" json:"key,omitempty"`
}

func (m *SubmissionKey) Reset()         { *m = SubmissionKey{} }
func (m *SubmissionKey) String() string { return proto.CompactTextString(m) }
func (*SubmissionKey) ProtoMessage()    {}
func (*SubmissionKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{2}
}
func (m *SubmissionKey) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubmissionKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubmissionKey.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SubmissionKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubmissionKey.Merge(m, src)
}
func (m *SubmissionKey) XXX_Size() int {
	return m.Size()
}
func (m *SubmissionKey) XXX_DiscardUnknown() {
	xxx_messageInfo_SubmissionKey.DiscardUnknown(m)
}

var xxx_messageInfo_SubmissionKey proto.InternalMessageInfo

func (m *SubmissionKey) GetKey() []*TransactionKey {
	if m != nil {
		return m.Key
	}
	return nil
}

// TransactionInfo is the info of a tx that contains Babylon checkpoint,
// including
// - the position of the tx on BTC blockchain
// - the full tx content
// - the Merkle proof that this tx is on the above position
type TransactionInfo struct {
	// key is the position (txIdx, blockHash) of this tx on BTC blockchain
	// Although it is already a part of SubmissionKey, we store it here again
	// to make TransactionInfo self-contained.
	// For example, storing the key allows TransactionInfo to not relay on
	// the fact that TransactionInfo will be ordered in the same order as
	// TransactionKeys in SubmissionKey.
	Key *TransactionKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// transaction is the full transaction in bytes
	Transaction []byte `protobuf:"bytes,2,opt,name=transaction,proto3" json:"transaction,omitempty"`
	// proof is the Merkle proof that this tx is included in the position in `key`
	// TODO: maybe it could use here better format as we already processed and
	// valideated the proof?
	Proof []byte `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
}

func (m *TransactionInfo) Reset()         { *m = TransactionInfo{} }
func (m *TransactionInfo) String() string { return proto.CompactTextString(m) }
func (*TransactionInfo) ProtoMessage()    {}
func (*TransactionInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{3}
}
func (m *TransactionInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TransactionInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransactionInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TransactionInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionInfo.Merge(m, src)
}
func (m *TransactionInfo) XXX_Size() int {
	return m.Size()
}
func (m *TransactionInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionInfo proto.InternalMessageInfo

func (m *TransactionInfo) GetKey() *TransactionKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *TransactionInfo) GetTransaction() []byte {
	if m != nil {
		return m.Transaction
	}
	return nil
}

func (m *TransactionInfo) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

// TODO: Determine if we should keep any block number or depth info.
// On one hand it may be usefull to determine if block is stable or not, on
// other depth/block number info, without context (i.e info about chain) is
// pretty useless and blockshash in enough to retrieve is from lightclient
type SubmissionData struct {
	// address of the submitter and reporter
	VigilanteAddresses *CheckpointAddresses `protobuf:"bytes,1,opt,name=vigilante_addresses,json=vigilanteAddresses,proto3" json:"vigilante_addresses,omitempty"`
	// txs_info is the two `TransactionInfo`s corresponding to the submission
	// It is used for
	// - recovering address of sender of btc transction to payup the reward.
	// - allowing the ZoneConcierge module to prove the checkpoint is submitted to
	// BTC
	TxsInfo []*TransactionInfo `protobuf:"bytes,2,rep,name=txs_info,json=txsInfo,proto3" json:"txs_info,omitempty"`
	Epoch   uint64             `protobuf:"varint,3,opt,name=epoch,proto3" json:"epoch,omitempty"`
}

func (m *SubmissionData) Reset()         { *m = SubmissionData{} }
func (m *SubmissionData) String() string { return proto.CompactTextString(m) }
func (*SubmissionData) ProtoMessage()    {}
func (*SubmissionData) Descriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{4}
}
func (m *SubmissionData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubmissionData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubmissionData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SubmissionData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubmissionData.Merge(m, src)
}
func (m *SubmissionData) XXX_Size() int {
	return m.Size()
}
func (m *SubmissionData) XXX_DiscardUnknown() {
	xxx_messageInfo_SubmissionData.DiscardUnknown(m)
}

var xxx_messageInfo_SubmissionData proto.InternalMessageInfo

func (m *SubmissionData) GetVigilanteAddresses() *CheckpointAddresses {
	if m != nil {
		return m.VigilanteAddresses
	}
	return nil
}

func (m *SubmissionData) GetTxsInfo() []*TransactionInfo {
	if m != nil {
		return m.TxsInfo
	}
	return nil
}

func (m *SubmissionData) GetEpoch() uint64 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

// Data stored in db and indexed by epoch number
// TODO: Add btc blockheight at epooch end, when adding hadnling of epoching
// callbacks
type EpochData struct {
	// List of all received checkpoints during this epoch, sorted by order of
	// submission.
	Key []*SubmissionKey `protobuf:"bytes,1,rep,name=key,proto3" json:"key,omitempty"`
	// Current btc status of the epoch
	Status BtcStatus `protobuf:"varint,2,opt,name=status,proto3,enum=babylon.btccheckpoint.v1.BtcStatus" json:"status,omitempty"`
}

func (m *EpochData) Reset()         { *m = EpochData{} }
func (m *EpochData) String() string { return proto.CompactTextString(m) }
func (*EpochData) ProtoMessage()    {}
func (*EpochData) Descriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{5}
}
func (m *EpochData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EpochData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EpochData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EpochData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EpochData.Merge(m, src)
}
func (m *EpochData) XXX_Size() int {
	return m.Size()
}
func (m *EpochData) XXX_DiscardUnknown() {
	xxx_messageInfo_EpochData.DiscardUnknown(m)
}

var xxx_messageInfo_EpochData proto.InternalMessageInfo

func (m *EpochData) GetKey() []*SubmissionKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *EpochData) GetStatus() BtcStatus {
	if m != nil {
		return m.Status
	}
	return Submitted
}

// CheckpointAddresses contains the addresses of the submitter and reporter of a
// given checkpoint
type CheckpointAddresses struct {
	// TODO: this could probably be better typed
	// submitter is the address of the checkpoint submitter to BTC, extracted from
	// the checkpoint itself.
	Submitter []byte `protobuf:"bytes,1,opt,name=submitter,proto3" json:"submitter,omitempty"`
	// reporter is the address of the reporter who reported the submissions,
	// calculated from submission message MsgInsertBTCSpvProof itself
	Reporter []byte `protobuf:"bytes,2,opt,name=reporter,proto3" json:"reporter,omitempty"`
}

func (m *CheckpointAddresses) Reset()         { *m = CheckpointAddresses{} }
func (m *CheckpointAddresses) String() string { return proto.CompactTextString(m) }
func (*CheckpointAddresses) ProtoMessage()    {}
func (*CheckpointAddresses) Descriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{6}
}
func (m *CheckpointAddresses) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CheckpointAddresses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CheckpointAddresses.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CheckpointAddresses) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CheckpointAddresses.Merge(m, src)
}
func (m *CheckpointAddresses) XXX_Size() int {
	return m.Size()
}
func (m *CheckpointAddresses) XXX_DiscardUnknown() {
	xxx_messageInfo_CheckpointAddresses.DiscardUnknown(m)
}

var xxx_messageInfo_CheckpointAddresses proto.InternalMessageInfo

func (m *CheckpointAddresses) GetSubmitter() []byte {
	if m != nil {
		return m.Submitter
	}
	return nil
}

func (m *CheckpointAddresses) GetReporter() []byte {
	if m != nil {
		return m.Reporter
	}
	return nil
}

// BTCCheckpointInfo contains all data about best submission of checkpoint for
// given epoch. Best submission is the submission which is deeper in btc ledger
type BTCCheckpointInfo struct {
	// epoch number of this checkpoint
	EpochNumber uint64 `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
	// btc height of the best submission of the epoch
	BestSubmissionBtcBlockHeight uint64 `protobuf:"varint,2,opt,name=best_submission_btc_block_height,json=bestSubmissionBtcBlockHeight,proto3" json:"best_submission_btc_block_height,omitempty"`
	// hash of the btc block which determines checkpoint btc block height i.e.
	// youngest block of best submission
	BestSubmissionBtcBlockHash *github_com_babylonchain_babylon_types.BTCHeaderHashBytes `protobuf:"bytes,3,opt,name=best_submission_btc_block_hash,json=bestSubmissionBtcBlockHash,proto3,customtype=github.com/babylonchain/babylon/types.BTCHeaderHashBytes" json:"best_submission_btc_block_hash,omitempty"`
	// the BTC checkpoint transactions of the best submission
	BestSubmissionTransactions []*TransactionInfo `protobuf:"bytes,4,rep,name=best_submission_transactions,json=bestSubmissionTransactions,proto3" json:"best_submission_transactions,omitempty"`
	// list of vigilantes' addresses of the best submission
	BestSubmissionVigilanteAddressList []*CheckpointAddresses `protobuf:"bytes,5,rep,name=best_submission_vigilante_address_list,json=bestSubmissionVigilanteAddressList,proto3" json:"best_submission_vigilante_address_list,omitempty"`
}

func (m *BTCCheckpointInfo) Reset()         { *m = BTCCheckpointInfo{} }
func (m *BTCCheckpointInfo) String() string { return proto.CompactTextString(m) }
func (*BTCCheckpointInfo) ProtoMessage()    {}
func (*BTCCheckpointInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_e096cac78d49b0a6, []int{7}
}
func (m *BTCCheckpointInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BTCCheckpointInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BTCCheckpointInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BTCCheckpointInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BTCCheckpointInfo.Merge(m, src)
}
func (m *BTCCheckpointInfo) XXX_Size() int {
	return m.Size()
}
func (m *BTCCheckpointInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_BTCCheckpointInfo.DiscardUnknown(m)
}

var xxx_messageInfo_BTCCheckpointInfo proto.InternalMessageInfo

func (m *BTCCheckpointInfo) GetEpochNumber() uint64 {
	if m != nil {
		return m.EpochNumber
	}
	return 0
}

func (m *BTCCheckpointInfo) GetBestSubmissionBtcBlockHeight() uint64 {
	if m != nil {
		return m.BestSubmissionBtcBlockHeight
	}
	return 0
}

func (m *BTCCheckpointInfo) GetBestSubmissionTransactions() []*TransactionInfo {
	if m != nil {
		return m.BestSubmissionTransactions
	}
	return nil
}

func (m *BTCCheckpointInfo) GetBestSubmissionVigilanteAddressList() []*CheckpointAddresses {
	if m != nil {
		return m.BestSubmissionVigilanteAddressList
	}
	return nil
}

func init() {
	proto.RegisterEnum("babylon.btccheckpoint.v1.BtcStatus", BtcStatus_name, BtcStatus_value)
	proto.RegisterType((*BTCSpvProof)(nil), "babylon.btccheckpoint.v1.BTCSpvProof")
	proto.RegisterType((*TransactionKey)(nil), "babylon.btccheckpoint.v1.TransactionKey")
	proto.RegisterType((*SubmissionKey)(nil), "babylon.btccheckpoint.v1.SubmissionKey")
	proto.RegisterType((*TransactionInfo)(nil), "babylon.btccheckpoint.v1.TransactionInfo")
	proto.RegisterType((*SubmissionData)(nil), "babylon.btccheckpoint.v1.SubmissionData")
	proto.RegisterType((*EpochData)(nil), "babylon.btccheckpoint.v1.EpochData")
	proto.RegisterType((*CheckpointAddresses)(nil), "babylon.btccheckpoint.v1.CheckpointAddresses")
	proto.RegisterType((*BTCCheckpointInfo)(nil), "babylon.btccheckpoint.v1.BTCCheckpointInfo")
}

func init() {
	proto.RegisterFile("babylon/btccheckpoint/v1/btccheckpoint.proto", fileDescriptor_e096cac78d49b0a6)
}

var fileDescriptor_e096cac78d49b0a6 = []byte{
	// 809 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x4b, 0x6f, 0xea, 0x46,
	0x14, 0x66, 0x80, 0xdc, 0x5e, 0x06, 0xc2, 0x4d, 0x87, 0xdc, 0xca, 0x42, 0x91, 0x2f, 0xd7, 0x95,
	0x1a, 0x52, 0xb5, 0xa0, 0xa4, 0xad, 0x94, 0x3e, 0x36, 0x31, 0x0f, 0x81, 0x92, 0x40, 0x64, 0x9c,
	0x2e, 0xb2, 0xa8, 0x65, 0x9b, 0x01, 0x8f, 0x00, 0x0f, 0xf2, 0x0c, 0x08, 0xba, 0x6a, 0x55, 0x55,
	0xaa, 0xba, 0xaa, 0xba, 0xef, 0xaa, 0x7f, 0xa6, 0x8b, 0x2e, 0xb2, 0xac, 0xb2, 0x88, 0xaa, 0xe4,
	0x1f, 0x74, 0xdb, 0x4d, 0xe5, 0xb1, 0xc3, 0x2b, 0xa1, 0x2d, 0xd2, 0xdd, 0x71, 0xce, 0x7c, 0xe7,
	0xf1, 0x7d, 0xe7, 0x1c, 0x0c, 0x3f, 0xb0, 0x4c, 0x6b, 0xda, 0xa7, 0x6e, 0xd1, 0xe2, 0xb6, 0xed,
	0x60, 0xbb, 0x37, 0xa4, 0xc4, 0xe5, 0xc5, 0xf1, 0xe1, 0xb2, 0xa3, 0x30, 0xf4, 0x28, 0xa7, 0x48,
	0x0a, 0xd1, 0x85, 0xe5, 0xc7, 0xf1, 0x61, 0x76, 0xb7, 0x4b, 0xbb, 0x54, 0x80, 0x8a, 0xfe, 0xaf,
	0x00, 0xaf, 0xfc, 0x0d, 0x60, 0x52, 0xd5, 0x4b, 0xad, 0xe1, 0xf8, 0xc2, 0xa3, 0xb4, 0x83, 0xf6,
	0xe1, 0x0b, 0x8b, 0xdb, 0x06, 0xf7, 0x4c, 0x97, 0x99, 0x36, 0x27, 0xd4, 0x95, 0x40, 0x0e, 0xe4,
	0x53, 0x5a, 0xda, 0xe2, 0xb6, 0x3e, 0xf7, 0xa2, 0x23, 0xf8, 0x72, 0x05, 0x68, 0x10, 0xb7, 0x8d,
	0x27, 0x52, 0x34, 0x07, 0xf2, 0xdb, 0x5a, 0x66, 0x19, 0x5e, 0xf7, 0x9f, 0xd0, 0x6b, 0x98, 0x1a,
	0x60, 0xaf, 0xd7, 0xc7, 0x86, 0x4b, 0xdb, 0x98, 0x49, 0x31, 0x91, 0x39, 0x19, 0xf8, 0x1a, 0xbe,
	0x0b, 0xf5, 0xe1, 0x4b, 0x9b, 0xba, 0x1d, 0xe2, 0x0d, 0x88, 0xdb, 0x35, 0xfc, 0x0a, 0x0e, 0x36,
	0xdb, 0xd8, 0x93, 0xe2, 0x3e, 0x56, 0x3d, 0xbe, 0xb9, 0x7d, 0xf5, 0x71, 0x97, 0x70, 0x67, 0x64,
	0x15, 0x6c, 0x3a, 0x28, 0x86, 0x6c, 0x6d, 0xc7, 0x24, 0xee, 0x83, 0x51, 0xe4, 0xd3, 0x21, 0x66,
	0x05, 0x55, 0x2f, 0xd5, 0x44, 0xa8, 0x3a, 0xe5, 0x98, 0x69, 0x99, 0x79, 0x5a, 0x95, 0xdb, 0xc1,
	0x8b, 0x32, 0x81, 0xe9, 0x85, 0x26, 0x4f, 0xf1, 0x14, 0xed, 0xc2, 0xad, 0x80, 0x06, 0x10, 0x34,
	0x02, 0x03, 0x5d, 0xc0, 0xb8, 0x63, 0x32, 0x47, 0x70, 0x4b, 0xa9, 0x5f, 0xdc, 0xdc, 0xbe, 0x3a,
	0xde, 0xb0, 0x89, 0x9a, 0xc9, 0x9c, 0xa0, 0x11, 0x91, 0x49, 0x39, 0x85, 0xdb, 0xad, 0x91, 0x35,
	0x20, 0x8c, 0x85, 0x85, 0x3f, 0x83, 0xb1, 0x1e, 0x9e, 0x4a, 0x20, 0x17, 0xcb, 0x27, 0x8f, 0xf2,
	0x85, 0x75, 0x63, 0x2c, 0x2c, 0xf7, 0xab, 0xf9, 0x41, 0xca, 0xf7, 0x00, 0xbe, 0x58, 0x12, 0xbb,
	0x43, 0xe7, 0xf9, 0xc0, 0xc6, 0xf9, 0x50, 0x0e, 0x26, 0x17, 0x17, 0x20, 0x1a, 0x8c, 0x69, 0xc1,
	0xe5, 0xcb, 0x34, 0xf4, 0xf7, 0x25, 0x1c, 0x61, 0x60, 0x28, 0xbf, 0x03, 0x98, 0x9e, 0xb3, 0x2a,
	0x9b, 0xdc, 0x44, 0x5f, 0xc1, 0xcc, 0x98, 0x74, 0x49, 0xdf, 0x74, 0x39, 0x36, 0xcc, 0x76, 0xdb,
	0xc3, 0x8c, 0x61, 0x16, 0xb6, 0xf5, 0xe1, 0xfa, 0xb6, 0x4a, 0x33, 0xeb, 0xe4, 0x21, 0x48, 0x43,
	0xb3, 0x4c, 0x33, 0x1f, 0x2a, 0xc3, 0xe7, 0x7c, 0xc2, 0x0c, 0xe2, 0x76, 0xa8, 0x14, 0x15, 0xda,
	0x1d, 0xfc, 0x2f, 0xae, 0xbe, 0x46, 0xda, 0x5b, 0x7c, 0xc2, 0x84, 0x58, 0xbb, 0x70, 0x0b, 0x0f,
	0xa9, 0xed, 0x08, 0x3a, 0x71, 0x2d, 0x30, 0x94, 0xef, 0x00, 0x4c, 0x54, 0xfc, 0x5f, 0x82, 0xc9,
	0xa7, 0x8b, 0x03, 0xda, 0x5f, 0x5f, 0x64, 0x69, 0xac, 0x81, 0x9e, 0x9f, 0xc3, 0x67, 0x8c, 0x9b,
	0x7c, 0xc4, 0x84, 0x94, 0xe9, 0xa3, 0x77, 0xd7, 0x47, 0xab, 0xdc, 0x6e, 0x09, 0xa8, 0x16, 0x86,
	0x28, 0x4d, 0x98, 0x79, 0x42, 0x0c, 0xb4, 0x07, 0x13, 0xcc, 0xaf, 0xc4, 0x39, 0xf6, 0xc2, 0x13,
	0x9d, 0x3b, 0x50, 0x16, 0x3e, 0xf7, 0xf0, 0x90, 0x7a, 0xfe, 0x63, 0x30, 0xbe, 0x99, 0xad, 0xfc,
	0x15, 0x83, 0x6f, 0xab, 0x7a, 0x69, 0x9e, 0x54, 0x48, 0xf0, 0x1a, 0xa6, 0x04, 0x6b, 0xc3, 0x1d,
	0x0d, 0xac, 0x30, 0x65, 0x5c, 0x4b, 0x0a, 0x5f, 0x43, 0xb8, 0x50, 0x15, 0xe6, 0x2c, 0xcc, 0xb8,
	0xc1, 0x66, 0x0c, 0xc5, 0x81, 0x5a, 0x7d, 0x6a, 0xf7, 0x0c, 0x07, 0x93, 0xae, 0xc3, 0x45, 0xb1,
	0xb8, 0xb6, 0xe7, 0xe3, 0xe6, 0x42, 0xa8, 0xdc, 0x56, 0x7d, 0x50, 0x4d, 0x60, 0xd0, 0x37, 0x00,
	0xca, 0xff, 0x92, 0xc8, 0x3f, 0xb4, 0xd8, 0x1b, 0x38, 0xb4, 0xec, 0x9a, 0x26, 0x4c, 0xe6, 0xa0,
	0x1e, 0xdc, 0x5b, 0xed, 0x60, 0x61, 0xbd, 0x99, 0x14, 0xdf, 0x74, 0x95, 0x56, 0x8a, 0x2d, 0x3c,
	0x33, 0xf4, 0x2d, 0x80, 0xef, 0xad, 0x56, 0x7b, 0x74, 0x14, 0x46, 0x9f, 0x30, 0x2e, 0x6d, 0x89,
	0xba, 0x1b, 0xde, 0x85, 0xb2, 0x5c, 0xfb, 0xcb, 0x95, 0x2b, 0x39, 0x23, 0x8c, 0xbf, 0xff, 0x33,
	0x80, 0x89, 0xd9, 0x6e, 0xa1, 0x03, 0xf8, 0x4e, 0xe5, 0xa2, 0x59, 0xaa, 0x19, 0x2d, 0xfd, 0x44,
	0xbf, 0x6c, 0x19, 0xad, 0x4b, 0xf5, 0xbc, 0xae, 0xeb, 0x95, 0xf2, 0x4e, 0x24, 0xbb, 0xfd, 0xe3,
	0x2f, 0xb9, 0x44, 0x2b, 0xdc, 0xa4, 0xf6, 0x23, 0x68, 0xa9, 0xd9, 0xa8, 0xd6, 0xb5, 0xf3, 0x4a,
	0x79, 0x07, 0x04, 0xd0, 0x52, 0xf0, 0xbf, 0xfa, 0x04, 0xb4, 0x5a, 0x6f, 0x9c, 0x9c, 0xd5, 0xaf,
	0x2a, 0xe5, 0x9d, 0x68, 0x00, 0xad, 0x12, 0xd7, 0xec, 0x93, 0xaf, 0x71, 0x3b, 0x1b, 0xff, 0xe1,
	0x57, 0x39, 0xa2, 0x36, 0x7f, 0xbb, 0x93, 0xc1, 0xf5, 0x9d, 0x0c, 0xfe, 0xbc, 0x93, 0xc1, 0x4f,
	0xf7, 0x72, 0xe4, 0xfa, 0x5e, 0x8e, 0xfc, 0x71, 0x2f, 0x47, 0xae, 0x3e, 0xf9, 0xaf, 0xa9, 0x4f,
	0x56, 0x3e, 0x87, 0x62, 0x0b, 0xac, 0x67, 0xe2, 0xa3, 0xf6, 0xd1, 0x3f, 0x01, 0x00, 0x00, 0xff,
	0xff, 0xa5, 0xcd, 0xc5, 0xce, 0x34, 0x07, 0x00, 0x00,
}

func (m *BTCSpvProof) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BTCSpvProof) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BTCSpvProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConfirmingBtcHeader != nil {
		{
			size := m.ConfirmingBtcHeader.Size()
			i -= size
			if _, err := m.ConfirmingBtcHeader.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.MerkleNodes) > 0 {
		i -= len(m.MerkleNodes)
		copy(dAtA[i:], m.MerkleNodes)
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(len(m.MerkleNodes)))
		i--
		dAtA[i] = 0x1a
	}
	if m.BtcTransactionIndex != 0 {
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(m.BtcTransactionIndex))
		i--
		dAtA[i] = 0x10
	}
	if len(m.BtcTransaction) > 0 {
		i -= len(m.BtcTransaction)
		copy(dAtA[i:], m.BtcTransaction)
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(len(m.BtcTransaction)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TransactionKey) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TransactionKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Hash != nil {
		{
			size := m.Hash.Size()
			i -= size
			if _, err := m.Hash.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Index != 0 {
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SubmissionKey) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SubmissionKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SubmissionKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		for iNdEx := len(m.Key) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Key[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *TransactionInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TransactionInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Transaction) > 0 {
		i -= len(m.Transaction)
		copy(dAtA[i:], m.Transaction)
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(len(m.Transaction)))
		i--
		dAtA[i] = 0x12
	}
	if m.Key != nil {
		{
			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SubmissionData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SubmissionData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SubmissionData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Epoch != 0 {
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x18
	}
	if len(m.TxsInfo) > 0 {
		for iNdEx := len(m.TxsInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TxsInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.VigilanteAddresses != nil {
		{
			size, err := m.VigilanteAddresses.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EpochData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EpochData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EpochData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != 0 {
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		for iNdEx := len(m.Key) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Key[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *CheckpointAddresses) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CheckpointAddresses) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CheckpointAddresses) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reporter) > 0 {
		i -= len(m.Reporter)
		copy(dAtA[i:], m.Reporter)
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(len(m.Reporter)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Submitter) > 0 {
		i -= len(m.Submitter)
		copy(dAtA[i:], m.Submitter)
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(len(m.Submitter)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BTCCheckpointInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BTCCheckpointInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BTCCheckpointInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BestSubmissionVigilanteAddressList) > 0 {
		for iNdEx := len(m.BestSubmissionVigilanteAddressList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BestSubmissionVigilanteAddressList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.BestSubmissionTransactions) > 0 {
		for iNdEx := len(m.BestSubmissionTransactions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BestSubmissionTransactions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.BestSubmissionBtcBlockHash != nil {
		{
			size := m.BestSubmissionBtcBlockHash.Size()
			i -= size
			if _, err := m.BestSubmissionBtcBlockHash.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBtccheckpoint(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BestSubmissionBtcBlockHeight != 0 {
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(m.BestSubmissionBtcBlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.EpochNumber != 0 {
		i = encodeVarintBtccheckpoint(dAtA, i, uint64(m.EpochNumber))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintBtccheckpoint(dAtA []byte, offset int, v uint64) int {
	offset -= sovBtccheckpoint(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *BTCSpvProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BtcTransaction)
	if l > 0 {
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	if m.BtcTransactionIndex != 0 {
		n += 1 + sovBtccheckpoint(uint64(m.BtcTransactionIndex))
	}
	l = len(m.MerkleNodes)
	if l > 0 {
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	if m.ConfirmingBtcHeader != nil {
		l = m.ConfirmingBtcHeader.Size()
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	return n
}

func (m *TransactionKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovBtccheckpoint(uint64(m.Index))
	}
	if m.Hash != nil {
		l = m.Hash.Size()
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	return n
}

func (m *SubmissionKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Key) > 0 {
		for _, e := range m.Key {
			l = e.Size()
			n += 1 + l + sovBtccheckpoint(uint64(l))
		}
	}
	return n
}

func (m *TransactionInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	l = len(m.Transaction)
	if l > 0 {
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	return n
}

func (m *SubmissionData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VigilanteAddresses != nil {
		l = m.VigilanteAddresses.Size()
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	if len(m.TxsInfo) > 0 {
		for _, e := range m.TxsInfo {
			l = e.Size()
			n += 1 + l + sovBtccheckpoint(uint64(l))
		}
	}
	if m.Epoch != 0 {
		n += 1 + sovBtccheckpoint(uint64(m.Epoch))
	}
	return n
}

func (m *EpochData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Key) > 0 {
		for _, e := range m.Key {
			l = e.Size()
			n += 1 + l + sovBtccheckpoint(uint64(l))
		}
	}
	if m.Status != 0 {
		n += 1 + sovBtccheckpoint(uint64(m.Status))
	}
	return n
}

func (m *CheckpointAddresses) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Submitter)
	if l > 0 {
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	l = len(m.Reporter)
	if l > 0 {
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	return n
}

func (m *BTCCheckpointInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EpochNumber != 0 {
		n += 1 + sovBtccheckpoint(uint64(m.EpochNumber))
	}
	if m.BestSubmissionBtcBlockHeight != 0 {
		n += 1 + sovBtccheckpoint(uint64(m.BestSubmissionBtcBlockHeight))
	}
	if m.BestSubmissionBtcBlockHash != nil {
		l = m.BestSubmissionBtcBlockHash.Size()
		n += 1 + l + sovBtccheckpoint(uint64(l))
	}
	if len(m.BestSubmissionTransactions) > 0 {
		for _, e := range m.BestSubmissionTransactions {
			l = e.Size()
			n += 1 + l + sovBtccheckpoint(uint64(l))
		}
	}
	if len(m.BestSubmissionVigilanteAddressList) > 0 {
		for _, e := range m.BestSubmissionVigilanteAddressList {
			l = e.Size()
			n += 1 + l + sovBtccheckpoint(uint64(l))
		}
	}
	return n
}

func sovBtccheckpoint(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBtccheckpoint(x uint64) (n int) {
	return sovBtccheckpoint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *BTCSpvProof) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BTCSpvProof: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BTCSpvProof: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BtcTransaction", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BtcTransaction = append(m.BtcTransaction[:0], dAtA[iNdEx:postIndex]...)
			if m.BtcTransaction == nil {
				m.BtcTransaction = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BtcTransactionIndex", wireType)
			}
			m.BtcTransactionIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BtcTransactionIndex |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MerkleNodes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MerkleNodes = append(m.MerkleNodes[:0], dAtA[iNdEx:postIndex]...)
			if m.MerkleNodes == nil {
				m.MerkleNodes = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfirmingBtcHeader", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_babylonchain_babylon_types.BTCHeaderBytes
			m.ConfirmingBtcHeader = &v
			if err := m.ConfirmingBtcHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBtccheckpoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransactionKey) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TransactionKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_babylonchain_babylon_types.BTCHeaderHashBytes
			m.Hash = &v
			if err := m.Hash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBtccheckpoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubmissionKey) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SubmissionKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubmissionKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key, &TransactionKey{})
			if err := m.Key[len(m.Key)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBtccheckpoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransactionInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TransactionInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Key == nil {
				m.Key = &TransactionKey{}
			}
			if err := m.Key.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Transaction", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Transaction = append(m.Transaction[:0], dAtA[iNdEx:postIndex]...)
			if m.Transaction == nil {
				m.Transaction = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBtccheckpoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubmissionData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SubmissionData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubmissionData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VigilanteAddresses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VigilanteAddresses == nil {
				m.VigilanteAddresses = &CheckpointAddresses{}
			}
			if err := m.VigilanteAddresses.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxsInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxsInfo = append(m.TxsInfo, &TransactionInfo{})
			if err := m.TxsInfo[len(m.TxsInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBtccheckpoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EpochData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EpochData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EpochData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key, &SubmissionKey{})
			if err := m.Key[len(m.Key)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= BtcStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBtccheckpoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CheckpointAddresses) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CheckpointAddresses: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CheckpointAddresses: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Submitter", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Submitter = append(m.Submitter[:0], dAtA[iNdEx:postIndex]...)
			if m.Submitter == nil {
				m.Submitter = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reporter", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reporter = append(m.Reporter[:0], dAtA[iNdEx:postIndex]...)
			if m.Reporter == nil {
				m.Reporter = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBtccheckpoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BTCCheckpointInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BTCCheckpointInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BTCCheckpointInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochNumber", wireType)
			}
			m.EpochNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestSubmissionBtcBlockHeight", wireType)
			}
			m.BestSubmissionBtcBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BestSubmissionBtcBlockHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestSubmissionBtcBlockHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_babylonchain_babylon_types.BTCHeaderHashBytes
			m.BestSubmissionBtcBlockHash = &v
			if err := m.BestSubmissionBtcBlockHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestSubmissionTransactions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BestSubmissionTransactions = append(m.BestSubmissionTransactions, &TransactionInfo{})
			if err := m.BestSubmissionTransactions[len(m.BestSubmissionTransactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestSubmissionVigilanteAddressList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BestSubmissionVigilanteAddressList = append(m.BestSubmissionVigilanteAddressList, &CheckpointAddresses{})
			if err := m.BestSubmissionVigilanteAddressList[len(m.BestSubmissionVigilanteAddressList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBtccheckpoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBtccheckpoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipBtccheckpoint(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowBtccheckpoint
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowBtccheckpoint
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthBtccheckpoint
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupBtccheckpoint
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthBtccheckpoint
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthBtccheckpoint        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBtccheckpoint          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBtccheckpoint = fmt.Errorf("proto: unexpected end of group")
)