nockchain-grpc/nockchain/blockchain.pb.go

// nockchain/common/v2/blockchain.proto

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.9
// 	protoc        v3.20.3
// source: blockchain.proto

package nockchain

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

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type Balance struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Notes         []*BalanceEntry        `protobuf:"bytes,1,rep,name=notes,proto3" json:"notes,omitempty"`
	Height        *BlockHeight           `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	BlockId       *Hash                  `protobuf:"bytes,3,opt,name=block_id,json=blockId,proto3,oneof" json:"block_id,omitempty"`
	Page          *PageResponse          `protobuf:"bytes,4,opt,name=page,proto3" json:"page,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Balance) ProtoMessage() {}

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

func (x *Balance) GetNotes() []*BalanceEntry {
	if x != nil {
		return x.Notes
	}
	return nil
}

func (x *Balance) GetHeight() *BlockHeight {
	if x != nil {
		return x.Height
	}
	return nil
}

func (x *Balance) GetBlockId() *Hash {
	if x != nil {
		return x.BlockId
	}
	return nil
}

func (x *Balance) GetPage() *PageResponse {
	if x != nil {
		return x.Page
	}
	return nil
}

type BalanceEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          *Name                  `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Note          *Note                  `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BalanceEntry) ProtoMessage() {}

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

func (x *BalanceEntry) GetName() *Name {
	if x != nil {
		return x.Name
	}
	return nil
}

func (x *BalanceEntry) GetNote() *Note {
	if x != nil {
		return x.Note
	}
	return nil
}

type RawTransaction struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       *NoteVersion           `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Id            *Hash                  `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Spends        []*SpendEntry          `protobuf:"bytes,3,rep,name=spends,proto3" json:"spends,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RawTransaction) ProtoMessage() {}

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

func (x *RawTransaction) GetVersion() *NoteVersion {
	if x != nil {
		return x.Version
	}
	return nil
}

func (x *RawTransaction) GetId() *Hash {
	if x != nil {
		return x.Id
	}
	return nil
}

func (x *RawTransaction) GetSpends() []*SpendEntry {
	if x != nil {
		return x.Spends
	}
	return nil
}

type SpendEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          *Name                  `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Spend         *Spend                 `protobuf:"bytes,2,opt,name=spend,proto3" json:"spend,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SpendEntry) ProtoMessage() {}

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

func (x *SpendEntry) GetName() *Name {
	if x != nil {
		return x.Name
	}
	return nil
}

func (x *SpendEntry) GetSpend() *Spend {
	if x != nil {
		return x.Spend
	}
	return nil
}

type Spend struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to SpendKind:
	//
	//	*Spend_Legacy
	//	*Spend_Witness
	SpendKind     isSpend_SpendKind `protobuf_oneof:"spend_kind"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Spend) ProtoMessage() {}

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

func (x *Spend) GetSpendKind() isSpend_SpendKind {
	if x != nil {
		return x.SpendKind
	}
	return nil
}

func (x *Spend) GetLegacy() *LegacySpend {
	if x != nil {
		if x, ok := x.SpendKind.(*Spend_Legacy); ok {
			return x.Legacy
		}
	}
	return nil
}

func (x *Spend) GetWitness() *WitnessSpend {
	if x != nil {
		if x, ok := x.SpendKind.(*Spend_Witness); ok {
			return x.Witness
		}
	}
	return nil
}

type isSpend_SpendKind interface {
	isSpend_SpendKind()
}

type Spend_Legacy struct {
	Legacy *LegacySpend `protobuf:"bytes,1,opt,name=legacy,proto3,oneof"`
}

type Spend_Witness struct {
	Witness *WitnessSpend `protobuf:"bytes,2,opt,name=witness,proto3,oneof"`
}

func (*Spend_Legacy) isSpend_SpendKind() {}

func (*Spend_Witness) isSpend_SpendKind() {}

type LegacySpend struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Signature     *Signature             `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	Seeds         []*Seed                `protobuf:"bytes,2,rep,name=seeds,proto3" json:"seeds,omitempty"`
	MinerFeeNicks *Nicks                 `protobuf:"bytes,3,opt,name=miner_fee_nicks,json=minerFeeNicks,proto3" json:"miner_fee_nicks,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LegacySpend) ProtoMessage() {}

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

func (x *LegacySpend) GetSignature() *Signature {
	if x != nil {
		return x.Signature
	}
	return nil
}

func (x *LegacySpend) GetSeeds() []*Seed {
	if x != nil {
		return x.Seeds
	}
	return nil
}

func (x *LegacySpend) GetMinerFeeNicks() *Nicks {
	if x != nil {
		return x.MinerFeeNicks
	}
	return nil
}

type WitnessSpend struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Witness       *Witness               `protobuf:"bytes,1,opt,name=witness,proto3" json:"witness,omitempty"`
	Seeds         []*Seed                `protobuf:"bytes,2,rep,name=seeds,proto3" json:"seeds,omitempty"`
	Fee           *Nicks                 `protobuf:"bytes,3,opt,name=fee,proto3" json:"fee,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*WitnessSpend) ProtoMessage() {}

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

func (x *WitnessSpend) GetWitness() *Witness {
	if x != nil {
		return x.Witness
	}
	return nil
}

func (x *WitnessSpend) GetSeeds() []*Seed {
	if x != nil {
		return x.Seeds
	}
	return nil
}

func (x *WitnessSpend) GetFee() *Nicks {
	if x != nil {
		return x.Fee
	}
	return nil
}

type Seed struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Absent when the seed originates from a coinbase output.
	OutputSource  *Source   `protobuf:"bytes,1,opt,name=output_source,json=outputSource,proto3" json:"output_source,omitempty"`
	LockRoot      *Hash     `protobuf:"bytes,2,opt,name=lock_root,json=lockRoot,proto3" json:"lock_root,omitempty"`
	NoteData      *NoteData `protobuf:"bytes,3,opt,name=note_data,json=noteData,proto3" json:"note_data,omitempty"`
	Gift          *Nicks    `protobuf:"bytes,4,opt,name=gift,proto3" json:"gift,omitempty"`
	ParentHash    *Hash     `protobuf:"bytes,5,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Seed) ProtoMessage() {}

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

func (x *Seed) GetOutputSource() *Source {
	if x != nil {
		return x.OutputSource
	}
	return nil
}

func (x *Seed) GetLockRoot() *Hash {
	if x != nil {
		return x.LockRoot
	}
	return nil
}

func (x *Seed) GetNoteData() *NoteData {
	if x != nil {
		return x.NoteData
	}
	return nil
}

func (x *Seed) GetGift() *Nicks {
	if x != nil {
		return x.Gift
	}
	return nil
}

func (x *Seed) GetParentHash() *Hash {
	if x != nil {
		return x.ParentHash
	}
	return nil
}

type Witness struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	LockMerkleProof *LockMerkleProof       `protobuf:"bytes,1,opt,name=lock_merkle_proof,json=lockMerkleProof,proto3" json:"lock_merkle_proof,omitempty"`
	PkhSignature    *PkhSignature          `protobuf:"bytes,2,opt,name=pkh_signature,json=pkhSignature,proto3" json:"pkh_signature,omitempty"`
	Hax             []*HaxPreimage         `protobuf:"bytes,3,rep,name=hax,proto3" json:"hax,omitempty"` //uint64 tim = 4; // reserved field, currently 0
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*Witness) ProtoMessage() {}

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

func (x *Witness) GetLockMerkleProof() *LockMerkleProof {
	if x != nil {
		return x.LockMerkleProof
	}
	return nil
}

func (x *Witness) GetPkhSignature() *PkhSignature {
	if x != nil {
		return x.PkhSignature
	}
	return nil
}

func (x *Witness) GetHax() []*HaxPreimage {
	if x != nil {
		return x.Hax
	}
	return nil
}

type HaxPreimage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hash          *Hash                  `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Value         []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` // jammed noun bytes
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HaxPreimage) ProtoMessage() {}

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

func (x *HaxPreimage) GetHash() *Hash {
	if x != nil {
		return x.Hash
	}
	return nil
}

func (x *HaxPreimage) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

type PkhSignature struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entries       []*PkhSignatureEntry   `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PkhSignature) ProtoMessage() {}

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

func (x *PkhSignature) GetEntries() []*PkhSignatureEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

type PkhSignatureEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hash          *Hash                  `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Pubkey        *SchnorrPubkey         `protobuf:"bytes,2,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	Signature     *SchnorrSignature      `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PkhSignatureEntry) ProtoMessage() {}

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

func (x *PkhSignatureEntry) GetHash() *Hash {
	if x != nil {
		return x.Hash
	}
	return nil
}

func (x *PkhSignatureEntry) GetPubkey() *SchnorrPubkey {
	if x != nil {
		return x.Pubkey
	}
	return nil
}

func (x *PkhSignatureEntry) GetSignature() *SchnorrSignature {
	if x != nil {
		return x.Signature
	}
	return nil
}

type LockMerkleProof struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	SpendCondition *SpendCondition        `protobuf:"bytes,1,opt,name=spend_condition,json=spendCondition,proto3" json:"spend_condition,omitempty"`
	Axis           uint64                 `protobuf:"varint,2,opt,name=axis,proto3" json:"axis,omitempty"`
	Proof          *MerkleProof           `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*LockMerkleProof) ProtoMessage() {}

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

func (x *LockMerkleProof) GetSpendCondition() *SpendCondition {
	if x != nil {
		return x.SpendCondition
	}
	return nil
}

func (x *LockMerkleProof) GetAxis() uint64 {
	if x != nil {
		return x.Axis
	}
	return 0
}

func (x *LockMerkleProof) GetProof() *MerkleProof {
	if x != nil {
		return x.Proof
	}
	return nil
}

type SpendCondition struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Primitives    []*LockPrimitive       `protobuf:"bytes,1,rep,name=primitives,proto3" json:"primitives,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SpendCondition) Reset() {
	*x = SpendCondition{}
	mi := &file_blockchain_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SpendCondition) ProtoMessage() {}

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

func (x *SpendCondition) GetPrimitives() []*LockPrimitive {
	if x != nil {
		return x.Primitives
	}
	return nil
}

type LockPrimitive struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Primitive:
	//
	//	*LockPrimitive_Pkh
	//	*LockPrimitive_Tim
	//	*LockPrimitive_Hax
	//	*LockPrimitive_Burn
	Primitive     isLockPrimitive_Primitive `protobuf_oneof:"primitive"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LockPrimitive) Reset() {
	*x = LockPrimitive{}
	mi := &file_blockchain_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*LockPrimitive) ProtoMessage() {}

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

func (x *LockPrimitive) GetPrimitive() isLockPrimitive_Primitive {
	if x != nil {
		return x.Primitive
	}
	return nil
}

func (x *LockPrimitive) GetPkh() *PkhLock {
	if x != nil {
		if x, ok := x.Primitive.(*LockPrimitive_Pkh); ok {
			return x.Pkh
		}
	}
	return nil
}

func (x *LockPrimitive) GetTim() *LockTim {
	if x != nil {
		if x, ok := x.Primitive.(*LockPrimitive_Tim); ok {
			return x.Tim
		}
	}
	return nil
}

func (x *LockPrimitive) GetHax() *HaxLock {
	if x != nil {
		if x, ok := x.Primitive.(*LockPrimitive_Hax); ok {
			return x.Hax
		}
	}
	return nil
}

func (x *LockPrimitive) GetBurn() *BurnLock {
	if x != nil {
		if x, ok := x.Primitive.(*LockPrimitive_Burn); ok {
			return x.Burn
		}
	}
	return nil
}

type isLockPrimitive_Primitive interface {
	isLockPrimitive_Primitive()
}

type LockPrimitive_Pkh struct {
	Pkh *PkhLock `protobuf:"bytes,1,opt,name=pkh,proto3,oneof"`
}

type LockPrimitive_Tim struct {
	Tim *LockTim `protobuf:"bytes,2,opt,name=tim,proto3,oneof"`
}

type LockPrimitive_Hax struct {
	Hax *HaxLock `protobuf:"bytes,3,opt,name=hax,proto3,oneof"`
}

type LockPrimitive_Burn struct {
	Burn *BurnLock `protobuf:"bytes,4,opt,name=burn,proto3,oneof"`
}

func (*LockPrimitive_Pkh) isLockPrimitive_Primitive() {}

func (*LockPrimitive_Tim) isLockPrimitive_Primitive() {}

func (*LockPrimitive_Hax) isLockPrimitive_Primitive() {}

func (*LockPrimitive_Burn) isLockPrimitive_Primitive() {}

type PkhLock struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	M             uint64                 `protobuf:"varint,1,opt,name=m,proto3" json:"m,omitempty"`
	Hashes        []*Hash                `protobuf:"bytes,2,rep,name=hashes,proto3" json:"hashes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PkhLock) Reset() {
	*x = PkhLock{}
	mi := &file_blockchain_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PkhLock) ProtoMessage() {}

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

func (x *PkhLock) GetM() uint64 {
	if x != nil {
		return x.M
	}
	return 0
}

func (x *PkhLock) GetHashes() []*Hash {
	if x != nil {
		return x.Hashes
	}
	return nil
}

type LockTim struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Rel           *TimeLockRangeRelative `protobuf:"bytes,1,opt,name=rel,proto3" json:"rel,omitempty"`
	Abs           *TimeLockRangeAbsolute `protobuf:"bytes,2,opt,name=abs,proto3" json:"abs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LockTim) Reset() {
	*x = LockTim{}
	mi := &file_blockchain_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*LockTim) ProtoMessage() {}

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

func (x *LockTim) GetRel() *TimeLockRangeRelative {
	if x != nil {
		return x.Rel
	}
	return nil
}

func (x *LockTim) GetAbs() *TimeLockRangeAbsolute {
	if x != nil {
		return x.Abs
	}
	return nil
}

type HaxLock struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hashes        []*Hash                `protobuf:"bytes,1,rep,name=hashes,proto3" json:"hashes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HaxLock) Reset() {
	*x = HaxLock{}
	mi := &file_blockchain_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*HaxLock) ProtoMessage() {}

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

func (x *HaxLock) GetHashes() []*Hash {
	if x != nil {
		return x.Hashes
	}
	return nil
}

type BurnLock struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BurnLock) Reset() {
	*x = BurnLock{}
	mi := &file_blockchain_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BurnLock) ProtoMessage() {}

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

type MerkleProof struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Root          *Hash                  `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
	Path          []*Hash                `protobuf:"bytes,2,rep,name=path,proto3" json:"path,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MerkleProof) Reset() {
	*x = MerkleProof{}
	mi := &file_blockchain_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MerkleProof) ProtoMessage() {}

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

func (x *MerkleProof) GetRoot() *Hash {
	if x != nil {
		return x.Root
	}
	return nil
}

func (x *MerkleProof) GetPath() []*Hash {
	if x != nil {
		return x.Path
	}
	return nil
}

type OutputSource struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Source        *Source                `protobuf:"bytes,1,opt,name=source,proto3,oneof" json:"source,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *OutputSource) Reset() {
	*x = OutputSource{}
	mi := &file_blockchain_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*OutputSource) ProtoMessage() {}

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

func (x *OutputSource) GetSource() *Source {
	if x != nil {
		return x.Source
	}
	return nil
}

type Source struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hash          *Hash                  `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Coinbase      bool                   `protobuf:"varint,2,opt,name=coinbase,proto3" json:"coinbase,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Source) Reset() {
	*x = Source{}
	mi := &file_blockchain_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Source) ProtoMessage() {}

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

func (x *Source) GetHash() *Hash {
	if x != nil {
		return x.Hash
	}
	return nil
}

func (x *Source) GetCoinbase() bool {
	if x != nil {
		return x.Coinbase
	}
	return false
}

type TimeLockIntent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Value:
	//
	//	*TimeLockIntent_Absolute
	//	*TimeLockIntent_Relative
	//	*TimeLockIntent_AbsoluteAndRelative
	Value         isTimeLockIntent_Value `protobuf_oneof:"value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimeLockIntent) Reset() {
	*x = TimeLockIntent{}
	mi := &file_blockchain_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TimeLockIntent) ProtoMessage() {}

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

func (x *TimeLockIntent) GetValue() isTimeLockIntent_Value {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *TimeLockIntent) GetAbsolute() *TimeLockRangeAbsolute {
	if x != nil {
		if x, ok := x.Value.(*TimeLockIntent_Absolute); ok {
			return x.Absolute
		}
	}
	return nil
}

func (x *TimeLockIntent) GetRelative() *TimeLockRangeRelative {
	if x != nil {
		if x, ok := x.Value.(*TimeLockIntent_Relative); ok {
			return x.Relative
		}
	}
	return nil
}

func (x *TimeLockIntent) GetAbsoluteAndRelative() *TimeLockRangeAbsoluteAndRelative {
	if x != nil {
		if x, ok := x.Value.(*TimeLockIntent_AbsoluteAndRelative); ok {
			return x.AbsoluteAndRelative
		}
	}
	return nil
}

type isTimeLockIntent_Value interface {
	isTimeLockIntent_Value()
}

type TimeLockIntent_Absolute struct {
	Absolute *TimeLockRangeAbsolute `protobuf:"bytes,1,opt,name=absolute,proto3,oneof"`
}

type TimeLockIntent_Relative struct {
	Relative *TimeLockRangeRelative `protobuf:"bytes,2,opt,name=relative,proto3,oneof"`
}

type TimeLockIntent_AbsoluteAndRelative struct {
	AbsoluteAndRelative *TimeLockRangeAbsoluteAndRelative `protobuf:"bytes,3,opt,name=absolute_and_relative,json=absoluteAndRelative,proto3,oneof"`
}

func (*TimeLockIntent_Absolute) isTimeLockIntent_Value() {}

func (*TimeLockIntent_Relative) isTimeLockIntent_Value() {}

func (*TimeLockIntent_AbsoluteAndRelative) isTimeLockIntent_Value() {}

type TimeLockRangeAbsoluteAndRelative struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Absolute      *TimeLockRangeAbsolute `protobuf:"bytes,1,opt,name=absolute,proto3,oneof" json:"absolute,omitempty"`
	Relative      *TimeLockRangeRelative `protobuf:"bytes,2,opt,name=relative,proto3,oneof" json:"relative,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimeLockRangeAbsoluteAndRelative) Reset() {
	*x = TimeLockRangeAbsoluteAndRelative{}
	mi := &file_blockchain_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TimeLockRangeAbsoluteAndRelative) ProtoMessage() {}

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

func (x *TimeLockRangeAbsoluteAndRelative) GetAbsolute() *TimeLockRangeAbsolute {
	if x != nil {
		return x.Absolute
	}
	return nil
}

func (x *TimeLockRangeAbsoluteAndRelative) GetRelative() *TimeLockRangeRelative {
	if x != nil {
		return x.Relative
	}
	return nil
}

// min and max are absolute origin page numbers
type TimeLockRangeAbsolute struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Min           *BlockHeight           `protobuf:"bytes,1,opt,name=min,proto3,oneof" json:"min,omitempty"`
	Max           *BlockHeight           `protobuf:"bytes,2,opt,name=max,proto3,oneof" json:"max,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimeLockRangeAbsolute) Reset() {
	*x = TimeLockRangeAbsolute{}
	mi := &file_blockchain_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TimeLockRangeAbsolute) ProtoMessage() {}

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

func (x *TimeLockRangeAbsolute) GetMin() *BlockHeight {
	if x != nil {
		return x.Min
	}
	return nil
}

func (x *TimeLockRangeAbsolute) GetMax() *BlockHeight {
	if x != nil {
		return x.Max
	}
	return nil
}

// min and max are relative to the note's creation page
type TimeLockRangeRelative struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Min           *BlockHeightDelta      `protobuf:"bytes,1,opt,name=min,proto3,oneof" json:"min,omitempty"`
	Max           *BlockHeightDelta      `protobuf:"bytes,2,opt,name=max,proto3,oneof" json:"max,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimeLockRangeRelative) Reset() {
	*x = TimeLockRangeRelative{}
	mi := &file_blockchain_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TimeLockRangeRelative) ProtoMessage() {}

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

func (x *TimeLockRangeRelative) GetMin() *BlockHeightDelta {
	if x != nil {
		return x.Min
	}
	return nil
}

func (x *TimeLockRangeRelative) GetMax() *BlockHeightDelta {
	if x != nil {
		return x.Max
	}
	return nil
}

type Lock struct {
	state        protoimpl.MessageState `protogen:"open.v1"`
	KeysRequired uint32                 `protobuf:"varint,1,opt,name=keys_required,json=keysRequired,proto3" json:"keys_required,omitempty"` // threshold of keys required to spend the note
	// DEPRECATED: repeated string schnorr_pubkeys_b58 = 2;
	SchnorrPubkeys []*SchnorrPubkey `protobuf:"bytes,2,rep,name=schnorr_pubkeys,json=schnorrPubkeys,proto3" json:"schnorr_pubkeys,omitempty"` // schnorr pubkeys (curve: cheetah)
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *Lock) Reset() {
	*x = Lock{}
	mi := &file_blockchain_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Lock) ProtoMessage() {}

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

func (x *Lock) GetKeysRequired() uint32 {
	if x != nil {
		return x.KeysRequired
	}
	return 0
}

func (x *Lock) GetSchnorrPubkeys() []*SchnorrPubkey {
	if x != nil {
		return x.SchnorrPubkeys
	}
	return nil
}

type Name struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// First is the hash of whether the note has a timelock and the lock
	First *Hash `protobuf:"bytes,1,opt,name=first,proto3" json:"first,omitempty"`
	// Last is the hash of the actual timelock and the source
	Last          *Hash `protobuf:"bytes,2,opt,name=last,proto3" json:"last,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Name) Reset() {
	*x = Name{}
	mi := &file_blockchain_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Name) ProtoMessage() {}

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

func (x *Name) GetFirst() *Hash {
	if x != nil {
		return x.First
	}
	return nil
}

func (x *Name) GetLast() *Hash {
	if x != nil {
		return x.Last
	}
	return nil
}

type Note struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to NoteVersion:
	//
	//	*Note_Legacy
	//	*Note_V1
	NoteVersion   isNote_NoteVersion `protobuf_oneof:"note_version"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Note) Reset() {
	*x = Note{}
	mi := &file_blockchain_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Note) ProtoMessage() {}

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

func (x *Note) GetNoteVersion() isNote_NoteVersion {
	if x != nil {
		return x.NoteVersion
	}
	return nil
}

func (x *Note) GetLegacy() *NoteV0 {
	if x != nil {
		if x, ok := x.NoteVersion.(*Note_Legacy); ok {
			return x.Legacy
		}
	}
	return nil
}

func (x *Note) GetV1() *NoteV1 {
	if x != nil {
		if x, ok := x.NoteVersion.(*Note_V1); ok {
			return x.V1
		}
	}
	return nil
}

type isNote_NoteVersion interface {
	isNote_NoteVersion()
}

type Note_Legacy struct {
	Legacy *NoteV0 `protobuf:"bytes,1,opt,name=legacy,proto3,oneof"`
}

type Note_V1 struct {
	V1 *NoteV1 `protobuf:"bytes,2,opt,name=v1,proto3,oneof"`
}

func (*Note_Legacy) isNote_NoteVersion() {}

func (*Note_V1) isNote_NoteVersion() {}

type NoteV0 struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	OriginPage    *BlockHeight           `protobuf:"bytes,1,opt,name=origin_page,json=originPage,proto3" json:"origin_page,omitempty"` // page-number when added to balance
	Timelock      *TimeLockIntent        `protobuf:"bytes,2,opt,name=timelock,proto3,oneof" json:"timelock,omitempty"`                 // enforced timelock
	Name          *Name                  `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`                               // nname (human/name label)
	Lock          *Lock                  `protobuf:"bytes,4,opt,name=lock,proto3" json:"lock,omitempty"`                               // spending condition
	Source        *Source                `protobuf:"bytes,5,opt,name=source,proto3" json:"source,omitempty"`                           // provenance commitment
	Assets        *Nicks                 `protobuf:"bytes,6,opt,name=assets,proto3" json:"assets,omitempty"`                           // coin amount (nicks)
	Version       *NoteVersion           `protobuf:"bytes,7,opt,name=version,proto3" json:"version,omitempty"`                         // note version (currently 0)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NoteV0) Reset() {
	*x = NoteV0{}
	mi := &file_blockchain_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*NoteV0) ProtoMessage() {}

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

func (x *NoteV0) GetOriginPage() *BlockHeight {
	if x != nil {
		return x.OriginPage
	}
	return nil
}

func (x *NoteV0) GetTimelock() *TimeLockIntent {
	if x != nil {
		return x.Timelock
	}
	return nil
}

func (x *NoteV0) GetName() *Name {
	if x != nil {
		return x.Name
	}
	return nil
}

func (x *NoteV0) GetLock() *Lock {
	if x != nil {
		return x.Lock
	}
	return nil
}

func (x *NoteV0) GetSource() *Source {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *NoteV0) GetAssets() *Nicks {
	if x != nil {
		return x.Assets
	}
	return nil
}

func (x *NoteV0) GetVersion() *NoteVersion {
	if x != nil {
		return x.Version
	}
	return nil
}

type NoteV1 struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       *NoteVersion           `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	OriginPage    *BlockHeight           `protobuf:"bytes,2,opt,name=origin_page,json=originPage,proto3" json:"origin_page,omitempty"`
	Name          *Name                  `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	NoteData      *NoteData              `protobuf:"bytes,4,opt,name=note_data,json=noteData,proto3" json:"note_data,omitempty"`
	Assets        *Nicks                 `protobuf:"bytes,5,opt,name=assets,proto3" json:"assets,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NoteV1) Reset() {
	*x = NoteV1{}
	mi := &file_blockchain_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*NoteV1) ProtoMessage() {}

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

func (x *NoteV1) GetVersion() *NoteVersion {
	if x != nil {
		return x.Version
	}
	return nil
}

func (x *NoteV1) GetOriginPage() *BlockHeight {
	if x != nil {
		return x.OriginPage
	}
	return nil
}

func (x *NoteV1) GetName() *Name {
	if x != nil {
		return x.Name
	}
	return nil
}

func (x *NoteV1) GetNoteData() *NoteData {
	if x != nil {
		return x.NoteData
	}
	return nil
}

func (x *NoteV1) GetAssets() *Nicks {
	if x != nil {
		return x.Assets
	}
	return nil
}

type NoteData struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entries       []*NoteDataEntry       `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NoteData) Reset() {
	*x = NoteData{}
	mi := &file_blockchain_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*NoteData) ProtoMessage() {}

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

func (x *NoteData) GetEntries() []*NoteDataEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

type NoteDataEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Blob          []byte                 `protobuf:"bytes,2,opt,name=blob,proto3" json:"blob,omitempty"` // jammed noun bytes
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *NoteDataEntry) Reset() {
	*x = NoteDataEntry{}
	mi := &file_blockchain_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*NoteDataEntry) ProtoMessage() {}

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

func (x *NoteDataEntry) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *NoteDataEntry) GetBlob() []byte {
	if x != nil {
		return x.Blob
	}
	return nil
}

type Signature struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entries       []*SignatureEntry      `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Signature) Reset() {
	*x = Signature{}
	mi := &file_blockchain_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Signature) ProtoMessage() {}

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

func (x *Signature) GetEntries() []*SignatureEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

type SignatureEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SchnorrPubkey *SchnorrPubkey         `protobuf:"bytes,1,opt,name=schnorr_pubkey,json=schnorrPubkey,proto3" json:"schnorr_pubkey,omitempty"` // serialized pubkey corresponding to the signer
	Signature     *SchnorrSignature      `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SignatureEntry) Reset() {
	*x = SignatureEntry{}
	mi := &file_blockchain_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SignatureEntry) ProtoMessage() {}

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

func (x *SignatureEntry) GetSchnorrPubkey() *SchnorrPubkey {
	if x != nil {
		return x.SchnorrPubkey
	}
	return nil
}

func (x *SignatureEntry) GetSignature() *SchnorrSignature {
	if x != nil {
		return x.Signature
	}
	return nil
}

type SchnorrSignature struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Chal          *EightBelt             `protobuf:"bytes,1,opt,name=chal,proto3" json:"chal,omitempty"`
	Sig           *EightBelt             `protobuf:"bytes,2,opt,name=sig,proto3" json:"sig,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SchnorrSignature) Reset() {
	*x = SchnorrSignature{}
	mi := &file_blockchain_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SchnorrSignature) ProtoMessage() {}

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

func (x *SchnorrSignature) GetChal() *EightBelt {
	if x != nil {
		return x.Chal
	}
	return nil
}

func (x *SchnorrSignature) GetSig() *EightBelt {
	if x != nil {
		return x.Sig
	}
	return nil
}

var File_blockchain_proto protoreflect.FileDescriptor

const file_blockchain_proto_rawDesc = "" +
	"\n" +
	"\x10blockchain.proto\x12\x13nockchain.public.v2\x1a\x10primitives.proto\x1a\x10pagination.proto\"\xfb\x01\n" +
	"\aBalance\x127\n" +
	"\x05notes\x18\x01 \x03(\v2!.nockchain.public.v2.BalanceEntryR\x05notes\x128\n" +
	"\x06height\x18\x02 \x01(\v2 .nockchain.public.v2.BlockHeightR\x06height\x129\n" +
	"\bblock_id\x18\x03 \x01(\v2\x19.nockchain.public.v2.HashH\x00R\ablockId\x88\x01\x01\x125\n" +
	"\x04page\x18\x04 \x01(\v2!.nockchain.public.v2.PageResponseR\x04pageB\v\n" +
	"\t_block_id\"l\n" +
	"\fBalanceEntry\x12-\n" +
	"\x04name\x18\x01 \x01(\v2\x19.nockchain.public.v2.NameR\x04name\x12-\n" +
	"\x04note\x18\x02 \x01(\v2\x19.nockchain.public.v2.NoteR\x04note\"\xb0\x01\n" +
	"\x0eRawTransaction\x12:\n" +
	"\aversion\x18\x01 \x01(\v2 .nockchain.public.v2.NoteVersionR\aversion\x12)\n" +
	"\x02id\x18\x02 \x01(\v2\x19.nockchain.public.v2.HashR\x02id\x127\n" +
	"\x06spends\x18\x03 \x03(\v2\x1f.nockchain.public.v2.SpendEntryR\x06spends\"m\n" +
	"\n" +
	"SpendEntry\x12-\n" +
	"\x04name\x18\x01 \x01(\v2\x19.nockchain.public.v2.NameR\x04name\x120\n" +
	"\x05spend\x18\x02 \x01(\v2\x1a.nockchain.public.v2.SpendR\x05spend\"\x90\x01\n" +
	"\x05Spend\x12:\n" +
	"\x06legacy\x18\x01 \x01(\v2 .nockchain.public.v2.LegacySpendH\x00R\x06legacy\x12=\n" +
	"\awitness\x18\x02 \x01(\v2!.nockchain.public.v2.WitnessSpendH\x00R\awitnessB\f\n" +
	"\n" +
	"spend_kind\"\xc0\x01\n" +
	"\vLegacySpend\x12<\n" +
	"\tsignature\x18\x01 \x01(\v2\x1e.nockchain.public.v2.SignatureR\tsignature\x12/\n" +
	"\x05seeds\x18\x02 \x03(\v2\x19.nockchain.public.v2.SeedR\x05seeds\x12B\n" +
	"\x0fminer_fee_nicks\x18\x03 \x01(\v2\x1a.nockchain.public.v2.NicksR\rminerFeeNicks\"\xa5\x01\n" +
	"\fWitnessSpend\x126\n" +
	"\awitness\x18\x01 \x01(\v2\x1c.nockchain.public.v2.WitnessR\awitness\x12/\n" +
	"\x05seeds\x18\x02 \x03(\v2\x19.nockchain.public.v2.SeedR\x05seeds\x12,\n" +
	"\x03fee\x18\x03 \x01(\v2\x1a.nockchain.public.v2.NicksR\x03fee\"\xa8\x02\n" +
	"\x04Seed\x12@\n" +
	"\routput_source\x18\x01 \x01(\v2\x1b.nockchain.public.v2.SourceR\foutputSource\x126\n" +
	"\tlock_root\x18\x02 \x01(\v2\x19.nockchain.public.v2.HashR\blockRoot\x12:\n" +
	"\tnote_data\x18\x03 \x01(\v2\x1d.nockchain.public.v2.NoteDataR\bnoteData\x12.\n" +
	"\x04gift\x18\x04 \x01(\v2\x1a.nockchain.public.v2.NicksR\x04gift\x12:\n" +
	"\vparent_hash\x18\x05 \x01(\v2\x19.nockchain.public.v2.HashR\n" +
	"parentHash\"\xd7\x01\n" +
	"\aWitness\x12P\n" +
	"\x11lock_merkle_proof\x18\x01 \x01(\v2$.nockchain.public.v2.LockMerkleProofR\x0flockMerkleProof\x12F\n" +
	"\rpkh_signature\x18\x02 \x01(\v2!.nockchain.public.v2.PkhSignatureR\fpkhSignature\x122\n" +
	"\x03hax\x18\x03 \x03(\v2 .nockchain.public.v2.HaxPreimageR\x03hax\"R\n" +
	"\vHaxPreimage\x12-\n" +
	"\x04hash\x18\x01 \x01(\v2\x19.nockchain.public.v2.HashR\x04hash\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value\"P\n" +
	"\fPkhSignature\x12@\n" +
	"\aentries\x18\x01 \x03(\v2&.nockchain.public.v2.PkhSignatureEntryR\aentries\"\xc3\x01\n" +
	"\x11PkhSignatureEntry\x12-\n" +
	"\x04hash\x18\x01 \x01(\v2\x19.nockchain.public.v2.HashR\x04hash\x12:\n" +
	"\x06pubkey\x18\x02 \x01(\v2\".nockchain.public.v2.SchnorrPubkeyR\x06pubkey\x12C\n" +
	"\tsignature\x18\x03 \x01(\v2%.nockchain.public.v2.SchnorrSignatureR\tsignature\"\xab\x01\n" +
	"\x0fLockMerkleProof\x12L\n" +
	"\x0fspend_condition\x18\x01 \x01(\v2#.nockchain.public.v2.SpendConditionR\x0espendCondition\x12\x12\n" +
	"\x04axis\x18\x02 \x01(\x04R\x04axis\x126\n" +
	"\x05proof\x18\x03 \x01(\v2 .nockchain.public.v2.MerkleProofR\x05proof\"T\n" +
	"\x0eSpendCondition\x12B\n" +
	"\n" +
	"primitives\x18\x01 \x03(\v2\".nockchain.public.v2.LockPrimitiveR\n" +
	"primitives\"\xe7\x01\n" +
	"\rLockPrimitive\x120\n" +
	"\x03pkh\x18\x01 \x01(\v2\x1c.nockchain.public.v2.PkhLockH\x00R\x03pkh\x120\n" +
	"\x03tim\x18\x02 \x01(\v2\x1c.nockchain.public.v2.LockTimH\x00R\x03tim\x120\n" +
	"\x03hax\x18\x03 \x01(\v2\x1c.nockchain.public.v2.HaxLockH\x00R\x03hax\x123\n" +
	"\x04burn\x18\x04 \x01(\v2\x1d.nockchain.public.v2.BurnLockH\x00R\x04burnB\v\n" +
	"\tprimitive\"J\n" +
	"\aPkhLock\x12\f\n" +
	"\x01m\x18\x01 \x01(\x04R\x01m\x121\n" +
	"\x06hashes\x18\x02 \x03(\v2\x19.nockchain.public.v2.HashR\x06hashes\"\x85\x01\n" +
	"\aLockTim\x12<\n" +
	"\x03rel\x18\x01 \x01(\v2*.nockchain.public.v2.TimeLockRangeRelativeR\x03rel\x12<\n" +
	"\x03abs\x18\x02 \x01(\v2*.nockchain.public.v2.TimeLockRangeAbsoluteR\x03abs\"<\n" +
	"\aHaxLock\x121\n" +
	"\x06hashes\x18\x01 \x03(\v2\x19.nockchain.public.v2.HashR\x06hashes\"\n" +
	"\n" +
	"\bBurnLock\"k\n" +
	"\vMerkleProof\x12-\n" +
	"\x04root\x18\x01 \x01(\v2\x19.nockchain.public.v2.HashR\x04root\x12-\n" +
	"\x04path\x18\x02 \x03(\v2\x19.nockchain.public.v2.HashR\x04path\"S\n" +
	"\fOutputSource\x128\n" +
	"\x06source\x18\x01 \x01(\v2\x1b.nockchain.public.v2.SourceH\x00R\x06source\x88\x01\x01B\t\n" +
	"\a_source\"S\n" +
	"\x06Source\x12-\n" +
	"\x04hash\x18\x01 \x01(\v2\x19.nockchain.public.v2.HashR\x04hash\x12\x1a\n" +
	"\bcoinbase\x18\x02 \x01(\bR\bcoinbase\"\x9a\x02\n" +
	"\x0eTimeLockIntent\x12H\n" +
	"\babsolute\x18\x01 \x01(\v2*.nockchain.public.v2.TimeLockRangeAbsoluteH\x00R\babsolute\x12H\n" +
	"\brelative\x18\x02 \x01(\v2*.nockchain.public.v2.TimeLockRangeRelativeH\x00R\brelative\x12k\n" +
	"\x15absolute_and_relative\x18\x03 \x01(\v25.nockchain.public.v2.TimeLockRangeAbsoluteAndRelativeH\x00R\x13absoluteAndRelativeB\a\n" +
	"\x05value\"\xd6\x01\n" +
	" TimeLockRangeAbsoluteAndRelative\x12K\n" +
	"\babsolute\x18\x01 \x01(\v2*.nockchain.public.v2.TimeLockRangeAbsoluteH\x00R\babsolute\x88\x01\x01\x12K\n" +
	"\brelative\x18\x02 \x01(\v2*.nockchain.public.v2.TimeLockRangeRelativeH\x01R\brelative\x88\x01\x01B\v\n" +
	"\t_absoluteB\v\n" +
	"\t_relative\"\x99\x01\n" +
	"\x15TimeLockRangeAbsolute\x127\n" +
	"\x03min\x18\x01 \x01(\v2 .nockchain.public.v2.BlockHeightH\x00R\x03min\x88\x01\x01\x127\n" +
	"\x03max\x18\x02 \x01(\v2 .nockchain.public.v2.BlockHeightH\x01R\x03max\x88\x01\x01B\x06\n" +
	"\x04_minB\x06\n" +
	"\x04_max\"\xa3\x01\n" +
	"\x15TimeLockRangeRelative\x12<\n" +
	"\x03min\x18\x01 \x01(\v2%.nockchain.public.v2.BlockHeightDeltaH\x00R\x03min\x88\x01\x01\x12<\n" +
	"\x03max\x18\x02 \x01(\v2%.nockchain.public.v2.BlockHeightDeltaH\x01R\x03max\x88\x01\x01B\x06\n" +
	"\x04_minB\x06\n" +
	"\x04_max\"x\n" +
	"\x04Lock\x12#\n" +
	"\rkeys_required\x18\x01 \x01(\rR\fkeysRequired\x12K\n" +
	"\x0fschnorr_pubkeys\x18\x02 \x03(\v2\".nockchain.public.v2.SchnorrPubkeyR\x0eschnorrPubkeys\"f\n" +
	"\x04Name\x12/\n" +
	"\x05first\x18\x01 \x01(\v2\x19.nockchain.public.v2.HashR\x05first\x12-\n" +
	"\x04last\x18\x02 \x01(\v2\x19.nockchain.public.v2.HashR\x04last\"|\n" +
	"\x04Note\x125\n" +
	"\x06legacy\x18\x01 \x01(\v2\x1b.nockchain.public.v2.NoteV0H\x00R\x06legacy\x12-\n" +
	"\x02v1\x18\x02 \x01(\v2\x1b.nockchain.public.v2.NoteV1H\x00R\x02v1B\x0e\n" +
	"\fnote_version\"\xa1\x03\n" +
	"\x06NoteV0\x12A\n" +
	"\vorigin_page\x18\x01 \x01(\v2 .nockchain.public.v2.BlockHeightR\n" +
	"originPage\x12D\n" +
	"\btimelock\x18\x02 \x01(\v2#.nockchain.public.v2.TimeLockIntentH\x00R\btimelock\x88\x01\x01\x12-\n" +
	"\x04name\x18\x03 \x01(\v2\x19.nockchain.public.v2.NameR\x04name\x12-\n" +
	"\x04lock\x18\x04 \x01(\v2\x19.nockchain.public.v2.LockR\x04lock\x123\n" +
	"\x06source\x18\x05 \x01(\v2\x1b.nockchain.public.v2.SourceR\x06source\x122\n" +
	"\x06assets\x18\x06 \x01(\v2\x1a.nockchain.public.v2.NicksR\x06assets\x12:\n" +
	"\aversion\x18\a \x01(\v2 .nockchain.public.v2.NoteVersionR\aversionB\v\n" +
	"\t_timelock\"\xa6\x02\n" +
	"\x06NoteV1\x12:\n" +
	"\aversion\x18\x01 \x01(\v2 .nockchain.public.v2.NoteVersionR\aversion\x12A\n" +
	"\vorigin_page\x18\x02 \x01(\v2 .nockchain.public.v2.BlockHeightR\n" +
	"originPage\x12-\n" +
	"\x04name\x18\x03 \x01(\v2\x19.nockchain.public.v2.NameR\x04name\x12:\n" +
	"\tnote_data\x18\x04 \x01(\v2\x1d.nockchain.public.v2.NoteDataR\bnoteData\x122\n" +
	"\x06assets\x18\x05 \x01(\v2\x1a.nockchain.public.v2.NicksR\x06assets\"H\n" +
	"\bNoteData\x12<\n" +
	"\aentries\x18\x01 \x03(\v2\".nockchain.public.v2.NoteDataEntryR\aentries\"5\n" +
	"\rNoteDataEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x12\n" +
	"\x04blob\x18\x02 \x01(\fR\x04blob\"J\n" +
	"\tSignature\x12=\n" +
	"\aentries\x18\x01 \x03(\v2#.nockchain.public.v2.SignatureEntryR\aentries\"\xa0\x01\n" +
	"\x0eSignatureEntry\x12I\n" +
	"\x0eschnorr_pubkey\x18\x01 \x01(\v2\".nockchain.public.v2.SchnorrPubkeyR\rschnorrPubkey\x12C\n" +
	"\tsignature\x18\x02 \x01(\v2%.nockchain.public.v2.SchnorrSignatureR\tsignature\"x\n" +
	"\x10SchnorrSignature\x122\n" +
	"\x04chal\x18\x01 \x01(\v2\x1e.nockchain.public.v2.EightBeltR\x04chal\x120\n" +
	"\x03sig\x18\x02 \x01(\v2\x1e.nockchain.public.v2.EightBeltR\x03sigB\x0eZ\f./;nockchainb\x06proto3"

var (
	file_blockchain_proto_rawDescOnce sync.Once
	file_blockchain_proto_rawDescData []byte
)

func file_blockchain_proto_rawDescGZIP() []byte {
	file_blockchain_proto_rawDescOnce.Do(func() {
		file_blockchain_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_blockchain_proto_rawDesc), len(file_blockchain_proto_rawDesc)))
	})
	return file_blockchain_proto_rawDescData
}

var file_blockchain_proto_msgTypes = make([]protoimpl.MessageInfo, 36)
var file_blockchain_proto_goTypes = []any{
	(*Balance)(nil),                          // 0: nockchain.public.v2.Balance
	(*BalanceEntry)(nil),                     // 1: nockchain.public.v2.BalanceEntry
	(*RawTransaction)(nil),                   // 2: nockchain.public.v2.RawTransaction
	(*SpendEntry)(nil),                       // 3: nockchain.public.v2.SpendEntry
	(*Spend)(nil),                            // 4: nockchain.public.v2.Spend
	(*LegacySpend)(nil),                      // 5: nockchain.public.v2.LegacySpend
	(*WitnessSpend)(nil),                     // 6: nockchain.public.v2.WitnessSpend
	(*Seed)(nil),                             // 7: nockchain.public.v2.Seed
	(*Witness)(nil),                          // 8: nockchain.public.v2.Witness
	(*HaxPreimage)(nil),                      // 9: nockchain.public.v2.HaxPreimage
	(*PkhSignature)(nil),                     // 10: nockchain.public.v2.PkhSignature
	(*PkhSignatureEntry)(nil),                // 11: nockchain.public.v2.PkhSignatureEntry
	(*LockMerkleProof)(nil),                  // 12: nockchain.public.v2.LockMerkleProof
	(*SpendCondition)(nil),                   // 13: nockchain.public.v2.SpendCondition
	(*LockPrimitive)(nil),                    // 14: nockchain.public.v2.LockPrimitive
	(*PkhLock)(nil),                          // 15: nockchain.public.v2.PkhLock
	(*LockTim)(nil),                          // 16: nockchain.public.v2.LockTim
	(*HaxLock)(nil),                          // 17: nockchain.public.v2.HaxLock
	(*BurnLock)(nil),                         // 18: nockchain.public.v2.BurnLock
	(*MerkleProof)(nil),                      // 19: nockchain.public.v2.MerkleProof
	(*OutputSource)(nil),                     // 20: nockchain.public.v2.OutputSource
	(*Source)(nil),                           // 21: nockchain.public.v2.Source
	(*TimeLockIntent)(nil),                   // 22: nockchain.public.v2.TimeLockIntent
	(*TimeLockRangeAbsoluteAndRelative)(nil), // 23: nockchain.public.v2.TimeLockRangeAbsoluteAndRelative
	(*TimeLockRangeAbsolute)(nil),            // 24: nockchain.public.v2.TimeLockRangeAbsolute
	(*TimeLockRangeRelative)(nil),            // 25: nockchain.public.v2.TimeLockRangeRelative
	(*Lock)(nil),                             // 26: nockchain.public.v2.Lock
	(*Name)(nil),                             // 27: nockchain.public.v2.Name
	(*Note)(nil),                             // 28: nockchain.public.v2.Note
	(*NoteV0)(nil),                           // 29: nockchain.public.v2.NoteV0
	(*NoteV1)(nil),                           // 30: nockchain.public.v2.NoteV1
	(*NoteData)(nil),                         // 31: nockchain.public.v2.NoteData
	(*NoteDataEntry)(nil),                    // 32: nockchain.public.v2.NoteDataEntry
	(*Signature)(nil),                        // 33: nockchain.public.v2.Signature
	(*SignatureEntry)(nil),                   // 34: nockchain.public.v2.SignatureEntry
	(*SchnorrSignature)(nil),                 // 35: nockchain.public.v2.SchnorrSignature
	(*BlockHeight)(nil),                      // 36: nockchain.public.v2.BlockHeight
	(*Hash)(nil),                             // 37: nockchain.public.v2.Hash
	(*PageResponse)(nil),                     // 38: nockchain.public.v2.PageResponse
	(*NoteVersion)(nil),                      // 39: nockchain.public.v2.NoteVersion
	(*Nicks)(nil),                            // 40: nockchain.public.v2.Nicks
	(*SchnorrPubkey)(nil),                    // 41: nockchain.public.v2.SchnorrPubkey
	(*BlockHeightDelta)(nil),                 // 42: nockchain.public.v2.BlockHeightDelta
	(*EightBelt)(nil),                        // 43: nockchain.public.v2.EightBelt
}
var file_blockchain_proto_depIdxs = []int32{
	1,  // 0: nockchain.public.v2.Balance.notes:type_name -> nockchain.public.v2.BalanceEntry
	36, // 1: nockchain.public.v2.Balance.height:type_name -> nockchain.public.v2.BlockHeight
	37, // 2: nockchain.public.v2.Balance.block_id:type_name -> nockchain.public.v2.Hash
	38, // 3: nockchain.public.v2.Balance.page:type_name -> nockchain.public.v2.PageResponse
	27, // 4: nockchain.public.v2.BalanceEntry.name:type_name -> nockchain.public.v2.Name
	28, // 5: nockchain.public.v2.BalanceEntry.note:type_name -> nockchain.public.v2.Note
	39, // 6: nockchain.public.v2.RawTransaction.version:type_name -> nockchain.public.v2.NoteVersion
	37, // 7: nockchain.public.v2.RawTransaction.id:type_name -> nockchain.public.v2.Hash
	3,  // 8: nockchain.public.v2.RawTransaction.spends:type_name -> nockchain.public.v2.SpendEntry
	27, // 9: nockchain.public.v2.SpendEntry.name:type_name -> nockchain.public.v2.Name
	4,  // 10: nockchain.public.v2.SpendEntry.spend:type_name -> nockchain.public.v2.Spend
	5,  // 11: nockchain.public.v2.Spend.legacy:type_name -> nockchain.public.v2.LegacySpend
	6,  // 12: nockchain.public.v2.Spend.witness:type_name -> nockchain.public.v2.WitnessSpend
	33, // 13: nockchain.public.v2.LegacySpend.signature:type_name -> nockchain.public.v2.Signature
	7,  // 14: nockchain.public.v2.LegacySpend.seeds:type_name -> nockchain.public.v2.Seed
	40, // 15: nockchain.public.v2.LegacySpend.miner_fee_nicks:type_name -> nockchain.public.v2.Nicks
	8,  // 16: nockchain.public.v2.WitnessSpend.witness:type_name -> nockchain.public.v2.Witness
	7,  // 17: nockchain.public.v2.WitnessSpend.seeds:type_name -> nockchain.public.v2.Seed
	40, // 18: nockchain.public.v2.WitnessSpend.fee:type_name -> nockchain.public.v2.Nicks
	21, // 19: nockchain.public.v2.Seed.output_source:type_name -> nockchain.public.v2.Source
	37, // 20: nockchain.public.v2.Seed.lock_root:type_name -> nockchain.public.v2.Hash
	31, // 21: nockchain.public.v2.Seed.note_data:type_name -> nockchain.public.v2.NoteData
	40, // 22: nockchain.public.v2.Seed.gift:type_name -> nockchain.public.v2.Nicks
	37, // 23: nockchain.public.v2.Seed.parent_hash:type_name -> nockchain.public.v2.Hash
	12, // 24: nockchain.public.v2.Witness.lock_merkle_proof:type_name -> nockchain.public.v2.LockMerkleProof
	10, // 25: nockchain.public.v2.Witness.pkh_signature:type_name -> nockchain.public.v2.PkhSignature
	9,  // 26: nockchain.public.v2.Witness.hax:type_name -> nockchain.public.v2.HaxPreimage
	37, // 27: nockchain.public.v2.HaxPreimage.hash:type_name -> nockchain.public.v2.Hash
	11, // 28: nockchain.public.v2.PkhSignature.entries:type_name -> nockchain.public.v2.PkhSignatureEntry
	37, // 29: nockchain.public.v2.PkhSignatureEntry.hash:type_name -> nockchain.public.v2.Hash
	41, // 30: nockchain.public.v2.PkhSignatureEntry.pubkey:type_name -> nockchain.public.v2.SchnorrPubkey
	35, // 31: nockchain.public.v2.PkhSignatureEntry.signature:type_name -> nockchain.public.v2.SchnorrSignature
	13, // 32: nockchain.public.v2.LockMerkleProof.spend_condition:type_name -> nockchain.public.v2.SpendCondition
	19, // 33: nockchain.public.v2.LockMerkleProof.proof:type_name -> nockchain.public.v2.MerkleProof
	14, // 34: nockchain.public.v2.SpendCondition.primitives:type_name -> nockchain.public.v2.LockPrimitive
	15, // 35: nockchain.public.v2.LockPrimitive.pkh:type_name -> nockchain.public.v2.PkhLock
	16, // 36: nockchain.public.v2.LockPrimitive.tim:type_name -> nockchain.public.v2.LockTim
	17, // 37: nockchain.public.v2.LockPrimitive.hax:type_name -> nockchain.public.v2.HaxLock
	18, // 38: nockchain.public.v2.LockPrimitive.burn:type_name -> nockchain.public.v2.BurnLock
	37, // 39: nockchain.public.v2.PkhLock.hashes:type_name -> nockchain.public.v2.Hash
	25, // 40: nockchain.public.v2.LockTim.rel:type_name -> nockchain.public.v2.TimeLockRangeRelative
	24, // 41: nockchain.public.v2.LockTim.abs:type_name -> nockchain.public.v2.TimeLockRangeAbsolute
	37, // 42: nockchain.public.v2.HaxLock.hashes:type_name -> nockchain.public.v2.Hash
	37, // 43: nockchain.public.v2.MerkleProof.root:type_name -> nockchain.public.v2.Hash
	37, // 44: nockchain.public.v2.MerkleProof.path:type_name -> nockchain.public.v2.Hash
	21, // 45: nockchain.public.v2.OutputSource.source:type_name -> nockchain.public.v2.Source
	37, // 46: nockchain.public.v2.Source.hash:type_name -> nockchain.public.v2.Hash
	24, // 47: nockchain.public.v2.TimeLockIntent.absolute:type_name -> nockchain.public.v2.TimeLockRangeAbsolute
	25, // 48: nockchain.public.v2.TimeLockIntent.relative:type_name -> nockchain.public.v2.TimeLockRangeRelative
	23, // 49: nockchain.public.v2.TimeLockIntent.absolute_and_relative:type_name -> nockchain.public.v2.TimeLockRangeAbsoluteAndRelative
	24, // 50: nockchain.public.v2.TimeLockRangeAbsoluteAndRelative.absolute:type_name -> nockchain.public.v2.TimeLockRangeAbsolute
	25, // 51: nockchain.public.v2.TimeLockRangeAbsoluteAndRelative.relative:type_name -> nockchain.public.v2.TimeLockRangeRelative
	36, // 52: nockchain.public.v2.TimeLockRangeAbsolute.min:type_name -> nockchain.public.v2.BlockHeight
	36, // 53: nockchain.public.v2.TimeLockRangeAbsolute.max:type_name -> nockchain.public.v2.BlockHeight
	42, // 54: nockchain.public.v2.TimeLockRangeRelative.min:type_name -> nockchain.public.v2.BlockHeightDelta
	42, // 55: nockchain.public.v2.TimeLockRangeRelative.max:type_name -> nockchain.public.v2.BlockHeightDelta
	41, // 56: nockchain.public.v2.Lock.schnorr_pubkeys:type_name -> nockchain.public.v2.SchnorrPubkey
	37, // 57: nockchain.public.v2.Name.first:type_name -> nockchain.public.v2.Hash
	37, // 58: nockchain.public.v2.Name.last:type_name -> nockchain.public.v2.Hash
	29, // 59: nockchain.public.v2.Note.legacy:type_name -> nockchain.public.v2.NoteV0
	30, // 60: nockchain.public.v2.Note.v1:type_name -> nockchain.public.v2.NoteV1
	36, // 61: nockchain.public.v2.NoteV0.origin_page:type_name -> nockchain.public.v2.BlockHeight
	22, // 62: nockchain.public.v2.NoteV0.timelock:type_name -> nockchain.public.v2.TimeLockIntent
	27, // 63: nockchain.public.v2.NoteV0.name:type_name -> nockchain.public.v2.Name
	26, // 64: nockchain.public.v2.NoteV0.lock:type_name -> nockchain.public.v2.Lock
	21, // 65: nockchain.public.v2.NoteV0.source:type_name -> nockchain.public.v2.Source
	40, // 66: nockchain.public.v2.NoteV0.assets:type_name -> nockchain.public.v2.Nicks
	39, // 67: nockchain.public.v2.NoteV0.version:type_name -> nockchain.public.v2.NoteVersion
	39, // 68: nockchain.public.v2.NoteV1.version:type_name -> nockchain.public.v2.NoteVersion
	36, // 69: nockchain.public.v2.NoteV1.origin_page:type_name -> nockchain.public.v2.BlockHeight
	27, // 70: nockchain.public.v2.NoteV1.name:type_name -> nockchain.public.v2.Name
	31, // 71: nockchain.public.v2.NoteV1.note_data:type_name -> nockchain.public.v2.NoteData
	40, // 72: nockchain.public.v2.NoteV1.assets:type_name -> nockchain.public.v2.Nicks
	32, // 73: nockchain.public.v2.NoteData.entries:type_name -> nockchain.public.v2.NoteDataEntry
	34, // 74: nockchain.public.v2.Signature.entries:type_name -> nockchain.public.v2.SignatureEntry
	41, // 75: nockchain.public.v2.SignatureEntry.schnorr_pubkey:type_name -> nockchain.public.v2.SchnorrPubkey
	35, // 76: nockchain.public.v2.SignatureEntry.signature:type_name -> nockchain.public.v2.SchnorrSignature
	43, // 77: nockchain.public.v2.SchnorrSignature.chal:type_name -> nockchain.public.v2.EightBelt
	43, // 78: nockchain.public.v2.SchnorrSignature.sig:type_name -> nockchain.public.v2.EightBelt
	79, // [79:79] is the sub-list for method output_type
	79, // [79:79] is the sub-list for method input_type
	79, // [79:79] is the sub-list for extension type_name
	79, // [79:79] is the sub-list for extension extendee
	0,  // [0:79] is the sub-list for field type_name
}

func init() { file_blockchain_proto_init() }
func file_blockchain_proto_init() {
	if File_blockchain_proto != nil {
		return
	}
	file_primitives_proto_init()
	file_pagination_proto_init()
	file_blockchain_proto_msgTypes[0].OneofWrappers = []any{}
	file_blockchain_proto_msgTypes[4].OneofWrappers = []any{
		(*Spend_Legacy)(nil),
		(*Spend_Witness)(nil),
	}
	file_blockchain_proto_msgTypes[14].OneofWrappers = []any{
		(*LockPrimitive_Pkh)(nil),
		(*LockPrimitive_Tim)(nil),
		(*LockPrimitive_Hax)(nil),
		(*LockPrimitive_Burn)(nil),
	}
	file_blockchain_proto_msgTypes[20].OneofWrappers = []any{}
	file_blockchain_proto_msgTypes[22].OneofWrappers = []any{
		(*TimeLockIntent_Absolute)(nil),
		(*TimeLockIntent_Relative)(nil),
		(*TimeLockIntent_AbsoluteAndRelative)(nil),
	}
	file_blockchain_proto_msgTypes[23].OneofWrappers = []any{}
	file_blockchain_proto_msgTypes[24].OneofWrappers = []any{}
	file_blockchain_proto_msgTypes[25].OneofWrappers = []any{}
	file_blockchain_proto_msgTypes[28].OneofWrappers = []any{
		(*Note_Legacy)(nil),
		(*Note_V1)(nil),
	}
	file_blockchain_proto_msgTypes[29].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_blockchain_proto_rawDesc), len(file_blockchain_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   36,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_blockchain_proto_goTypes,
		DependencyIndexes: file_blockchain_proto_depIdxs,
		MessageInfos:      file_blockchain_proto_msgTypes,
	}.Build()
	File_blockchain_proto = out.File
	file_blockchain_proto_goTypes = nil
	file_blockchain_proto_depIdxs = nil
}