chain_events.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: vega/chain_events.proto

package vega

import (
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

// A deposit for a Vega built-in asset
type BuiltinAssetDeposit struct {
	// A Vega network internal asset identifier
	VegaAssetId string `protobuf:"bytes,1,opt,name=vega_asset_id,json=vegaAssetId,proto3" json:"vega_asset_id,omitempty"`
	// A Vega party identifier (pub-key)
	PartyId string `protobuf:"bytes,2,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// The amount to be deposited
	Amount               string   `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BuiltinAssetDeposit) Reset()         { *m = BuiltinAssetDeposit{} }
func (m *BuiltinAssetDeposit) String() string { return proto.CompactTextString(m) }
func (*BuiltinAssetDeposit) ProtoMessage()    {}
func (*BuiltinAssetDeposit) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{0}
}

func (m *BuiltinAssetDeposit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BuiltinAssetDeposit.Unmarshal(m, b)
}
func (m *BuiltinAssetDeposit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BuiltinAssetDeposit.Marshal(b, m, deterministic)
}
func (m *BuiltinAssetDeposit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BuiltinAssetDeposit.Merge(m, src)
}
func (m *BuiltinAssetDeposit) XXX_Size() int {
	return xxx_messageInfo_BuiltinAssetDeposit.Size(m)
}
func (m *BuiltinAssetDeposit) XXX_DiscardUnknown() {
	xxx_messageInfo_BuiltinAssetDeposit.DiscardUnknown(m)
}

var xxx_messageInfo_BuiltinAssetDeposit proto.InternalMessageInfo

func (m *BuiltinAssetDeposit) GetVegaAssetId() string {
	if m != nil {
		return m.VegaAssetId
	}
	return ""
}

func (m *BuiltinAssetDeposit) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *BuiltinAssetDeposit) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

// A withdrawal for a Vega built-in asset
type BuiltinAssetWithdrawal struct {
	// A Vega network internal asset identifier
	VegaAssetId string `protobuf:"bytes,1,opt,name=vega_asset_id,json=vegaAssetId,proto3" json:"vega_asset_id,omitempty"`
	// A Vega network party identifier (pub-key)
	PartyId string `protobuf:"bytes,2,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// The amount to be withdrawn
	Amount               string   `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BuiltinAssetWithdrawal) Reset()         { *m = BuiltinAssetWithdrawal{} }
func (m *BuiltinAssetWithdrawal) String() string { return proto.CompactTextString(m) }
func (*BuiltinAssetWithdrawal) ProtoMessage()    {}
func (*BuiltinAssetWithdrawal) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{1}
}

func (m *BuiltinAssetWithdrawal) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BuiltinAssetWithdrawal.Unmarshal(m, b)
}
func (m *BuiltinAssetWithdrawal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BuiltinAssetWithdrawal.Marshal(b, m, deterministic)
}
func (m *BuiltinAssetWithdrawal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BuiltinAssetWithdrawal.Merge(m, src)
}
func (m *BuiltinAssetWithdrawal) XXX_Size() int {
	return xxx_messageInfo_BuiltinAssetWithdrawal.Size(m)
}
func (m *BuiltinAssetWithdrawal) XXX_DiscardUnknown() {
	xxx_messageInfo_BuiltinAssetWithdrawal.DiscardUnknown(m)
}

var xxx_messageInfo_BuiltinAssetWithdrawal proto.InternalMessageInfo

func (m *BuiltinAssetWithdrawal) GetVegaAssetId() string {
	if m != nil {
		return m.VegaAssetId
	}
	return ""
}

func (m *BuiltinAssetWithdrawal) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *BuiltinAssetWithdrawal) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

// An event related to a Vega built-in asset
type BuiltinAssetEvent struct {
	// Types that are valid to be assigned to Action:
	//	*BuiltinAssetEvent_Deposit
	//	*BuiltinAssetEvent_Withdrawal
	Action               isBuiltinAssetEvent_Action `protobuf_oneof:"action"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *BuiltinAssetEvent) Reset()         { *m = BuiltinAssetEvent{} }
func (m *BuiltinAssetEvent) String() string { return proto.CompactTextString(m) }
func (*BuiltinAssetEvent) ProtoMessage()    {}
func (*BuiltinAssetEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{2}
}

func (m *BuiltinAssetEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BuiltinAssetEvent.Unmarshal(m, b)
}
func (m *BuiltinAssetEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BuiltinAssetEvent.Marshal(b, m, deterministic)
}
func (m *BuiltinAssetEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BuiltinAssetEvent.Merge(m, src)
}
func (m *BuiltinAssetEvent) XXX_Size() int {
	return xxx_messageInfo_BuiltinAssetEvent.Size(m)
}
func (m *BuiltinAssetEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_BuiltinAssetEvent.DiscardUnknown(m)
}

var xxx_messageInfo_BuiltinAssetEvent proto.InternalMessageInfo

type isBuiltinAssetEvent_Action interface {
	isBuiltinAssetEvent_Action()
}

type BuiltinAssetEvent_Deposit struct {
	Deposit *BuiltinAssetDeposit `protobuf:"bytes,1001,opt,name=deposit,proto3,oneof"`
}

type BuiltinAssetEvent_Withdrawal struct {
	Withdrawal *BuiltinAssetWithdrawal `protobuf:"bytes,1002,opt,name=withdrawal,proto3,oneof"`
}

func (*BuiltinAssetEvent_Deposit) isBuiltinAssetEvent_Action() {}

func (*BuiltinAssetEvent_Withdrawal) isBuiltinAssetEvent_Action() {}

func (m *BuiltinAssetEvent) GetAction() isBuiltinAssetEvent_Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *BuiltinAssetEvent) GetDeposit() *BuiltinAssetDeposit {
	if x, ok := m.GetAction().(*BuiltinAssetEvent_Deposit); ok {
		return x.Deposit
	}
	return nil
}

func (m *BuiltinAssetEvent) GetWithdrawal() *BuiltinAssetWithdrawal {
	if x, ok := m.GetAction().(*BuiltinAssetEvent_Withdrawal); ok {
		return x.Withdrawal
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BuiltinAssetEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BuiltinAssetEvent_Deposit)(nil),
		(*BuiltinAssetEvent_Withdrawal)(nil),
	}
}

// An asset allow-listing for an ERC20 token
type ERC20AssetList struct {
	// The Vega network internal identifier of the asset
	VegaAssetId          string   `protobuf:"bytes,1,opt,name=vega_asset_id,json=vegaAssetId,proto3" json:"vega_asset_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ERC20AssetList) Reset()         { *m = ERC20AssetList{} }
func (m *ERC20AssetList) String() string { return proto.CompactTextString(m) }
func (*ERC20AssetList) ProtoMessage()    {}
func (*ERC20AssetList) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{3}
}

func (m *ERC20AssetList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ERC20AssetList.Unmarshal(m, b)
}
func (m *ERC20AssetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ERC20AssetList.Marshal(b, m, deterministic)
}
func (m *ERC20AssetList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ERC20AssetList.Merge(m, src)
}
func (m *ERC20AssetList) XXX_Size() int {
	return xxx_messageInfo_ERC20AssetList.Size(m)
}
func (m *ERC20AssetList) XXX_DiscardUnknown() {
	xxx_messageInfo_ERC20AssetList.DiscardUnknown(m)
}

var xxx_messageInfo_ERC20AssetList proto.InternalMessageInfo

func (m *ERC20AssetList) GetVegaAssetId() string {
	if m != nil {
		return m.VegaAssetId
	}
	return ""
}

// An asset deny-listing for an ERC20 token
type ERC20AssetDelist struct {
	// The Vega network internal identifier of the asset
	VegaAssetId          string   `protobuf:"bytes,1,opt,name=vega_asset_id,json=vegaAssetId,proto3" json:"vega_asset_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ERC20AssetDelist) Reset()         { *m = ERC20AssetDelist{} }
func (m *ERC20AssetDelist) String() string { return proto.CompactTextString(m) }
func (*ERC20AssetDelist) ProtoMessage()    {}
func (*ERC20AssetDelist) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{4}
}

func (m *ERC20AssetDelist) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ERC20AssetDelist.Unmarshal(m, b)
}
func (m *ERC20AssetDelist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ERC20AssetDelist.Marshal(b, m, deterministic)
}
func (m *ERC20AssetDelist) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ERC20AssetDelist.Merge(m, src)
}
func (m *ERC20AssetDelist) XXX_Size() int {
	return xxx_messageInfo_ERC20AssetDelist.Size(m)
}
func (m *ERC20AssetDelist) XXX_DiscardUnknown() {
	xxx_messageInfo_ERC20AssetDelist.DiscardUnknown(m)
}

var xxx_messageInfo_ERC20AssetDelist proto.InternalMessageInfo

func (m *ERC20AssetDelist) GetVegaAssetId() string {
	if m != nil {
		return m.VegaAssetId
	}
	return ""
}

// An asset deposit for an ERC20 token
type ERC20Deposit struct {
	// The vega network internal identifier of the asset
	VegaAssetId string `protobuf:"bytes,1,opt,name=vega_asset_id,json=vegaAssetId,proto3" json:"vega_asset_id,omitempty"`
	// The Ethereum wallet that initiated the deposit
	SourceEthereumAddress string `protobuf:"bytes,2,opt,name=source_ethereum_address,json=sourceEthereumAddress,proto3" json:"source_ethereum_address,omitempty"`
	// The Vega party identifier (pub-key) which is the target of the deposit
	TargetPartyId string `protobuf:"bytes,3,opt,name=target_party_id,json=targetPartyId,proto3" json:"target_party_id,omitempty"`
	// The amount to be deposited
	Amount               string   `protobuf:"bytes,4,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ERC20Deposit) Reset()         { *m = ERC20Deposit{} }
func (m *ERC20Deposit) String() string { return proto.CompactTextString(m) }
func (*ERC20Deposit) ProtoMessage()    {}
func (*ERC20Deposit) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{5}
}

func (m *ERC20Deposit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ERC20Deposit.Unmarshal(m, b)
}
func (m *ERC20Deposit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ERC20Deposit.Marshal(b, m, deterministic)
}
func (m *ERC20Deposit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ERC20Deposit.Merge(m, src)
}
func (m *ERC20Deposit) XXX_Size() int {
	return xxx_messageInfo_ERC20Deposit.Size(m)
}
func (m *ERC20Deposit) XXX_DiscardUnknown() {
	xxx_messageInfo_ERC20Deposit.DiscardUnknown(m)
}

var xxx_messageInfo_ERC20Deposit proto.InternalMessageInfo

func (m *ERC20Deposit) GetVegaAssetId() string {
	if m != nil {
		return m.VegaAssetId
	}
	return ""
}

func (m *ERC20Deposit) GetSourceEthereumAddress() string {
	if m != nil {
		return m.SourceEthereumAddress
	}
	return ""
}

func (m *ERC20Deposit) GetTargetPartyId() string {
	if m != nil {
		return m.TargetPartyId
	}
	return ""
}

func (m *ERC20Deposit) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

// An asset withdrawal for an ERC20 token
type ERC20Withdrawal struct {
	// The Vega network internal identifier of the asset
	VegaAssetId string `protobuf:"bytes,1,opt,name=vega_asset_id,json=vegaAssetId,proto3" json:"vega_asset_id,omitempty"`
	// The target Ethereum wallet address
	TargetEthereumAddress string `protobuf:"bytes,2,opt,name=target_ethereum_address,json=targetEthereumAddress,proto3" json:"target_ethereum_address,omitempty"`
	// The reference nonce used for the transaction
	ReferenceNonce       string   `protobuf:"bytes,3,opt,name=reference_nonce,json=referenceNonce,proto3" json:"reference_nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ERC20Withdrawal) Reset()         { *m = ERC20Withdrawal{} }
func (m *ERC20Withdrawal) String() string { return proto.CompactTextString(m) }
func (*ERC20Withdrawal) ProtoMessage()    {}
func (*ERC20Withdrawal) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{6}
}

func (m *ERC20Withdrawal) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ERC20Withdrawal.Unmarshal(m, b)
}
func (m *ERC20Withdrawal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ERC20Withdrawal.Marshal(b, m, deterministic)
}
func (m *ERC20Withdrawal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ERC20Withdrawal.Merge(m, src)
}
func (m *ERC20Withdrawal) XXX_Size() int {
	return xxx_messageInfo_ERC20Withdrawal.Size(m)
}
func (m *ERC20Withdrawal) XXX_DiscardUnknown() {
	xxx_messageInfo_ERC20Withdrawal.DiscardUnknown(m)
}

var xxx_messageInfo_ERC20Withdrawal proto.InternalMessageInfo

func (m *ERC20Withdrawal) GetVegaAssetId() string {
	if m != nil {
		return m.VegaAssetId
	}
	return ""
}

func (m *ERC20Withdrawal) GetTargetEthereumAddress() string {
	if m != nil {
		return m.TargetEthereumAddress
	}
	return ""
}

func (m *ERC20Withdrawal) GetReferenceNonce() string {
	if m != nil {
		return m.ReferenceNonce
	}
	return ""
}

// An event related to an ERC20 token
type ERC20Event struct {
	// Index of the transaction
	Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// The block in which the transaction was added
	Block uint64 `protobuf:"varint,2,opt,name=block,proto3" json:"block,omitempty"`
	// The action
	//
	// Types that are valid to be assigned to Action:
	//	*ERC20Event_AssetList
	//	*ERC20Event_AssetDelist
	//	*ERC20Event_Deposit
	//	*ERC20Event_Withdrawal
	Action               isERC20Event_Action `protobuf_oneof:"action"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *ERC20Event) Reset()         { *m = ERC20Event{} }
func (m *ERC20Event) String() string { return proto.CompactTextString(m) }
func (*ERC20Event) ProtoMessage()    {}
func (*ERC20Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{7}
}

func (m *ERC20Event) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ERC20Event.Unmarshal(m, b)
}
func (m *ERC20Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ERC20Event.Marshal(b, m, deterministic)
}
func (m *ERC20Event) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ERC20Event.Merge(m, src)
}
func (m *ERC20Event) XXX_Size() int {
	return xxx_messageInfo_ERC20Event.Size(m)
}
func (m *ERC20Event) XXX_DiscardUnknown() {
	xxx_messageInfo_ERC20Event.DiscardUnknown(m)
}

var xxx_messageInfo_ERC20Event proto.InternalMessageInfo

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

func (m *ERC20Event) GetBlock() uint64 {
	if m != nil {
		return m.Block
	}
	return 0
}

type isERC20Event_Action interface {
	isERC20Event_Action()
}

type ERC20Event_AssetList struct {
	AssetList *ERC20AssetList `protobuf:"bytes,1001,opt,name=asset_list,json=assetList,proto3,oneof"`
}

type ERC20Event_AssetDelist struct {
	AssetDelist *ERC20AssetDelist `protobuf:"bytes,1002,opt,name=asset_delist,json=assetDelist,proto3,oneof"`
}

type ERC20Event_Deposit struct {
	Deposit *ERC20Deposit `protobuf:"bytes,1003,opt,name=deposit,proto3,oneof"`
}

type ERC20Event_Withdrawal struct {
	Withdrawal *ERC20Withdrawal `protobuf:"bytes,1004,opt,name=withdrawal,proto3,oneof"`
}

func (*ERC20Event_AssetList) isERC20Event_Action() {}

func (*ERC20Event_AssetDelist) isERC20Event_Action() {}

func (*ERC20Event_Deposit) isERC20Event_Action() {}

func (*ERC20Event_Withdrawal) isERC20Event_Action() {}

func (m *ERC20Event) GetAction() isERC20Event_Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *ERC20Event) GetAssetList() *ERC20AssetList {
	if x, ok := m.GetAction().(*ERC20Event_AssetList); ok {
		return x.AssetList
	}
	return nil
}

func (m *ERC20Event) GetAssetDelist() *ERC20AssetDelist {
	if x, ok := m.GetAction().(*ERC20Event_AssetDelist); ok {
		return x.AssetDelist
	}
	return nil
}

func (m *ERC20Event) GetDeposit() *ERC20Deposit {
	if x, ok := m.GetAction().(*ERC20Event_Deposit); ok {
		return x.Deposit
	}
	return nil
}

func (m *ERC20Event) GetWithdrawal() *ERC20Withdrawal {
	if x, ok := m.GetAction().(*ERC20Event_Withdrawal); ok {
		return x.Withdrawal
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ERC20Event) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ERC20Event_AssetList)(nil),
		(*ERC20Event_AssetDelist)(nil),
		(*ERC20Event_Deposit)(nil),
		(*ERC20Event_Withdrawal)(nil),
	}
}

// A Bitcoin deposit into Vega
type BTCDeposit struct {
	// The Vega network internal identifier of the asset
	VegaAssetId string `protobuf:"bytes,1,opt,name=vega_asset_id,json=vegaAssetId,proto3" json:"vega_asset_id,omitempty"`
	// The BTC wallet initiating the deposit
	SourceBtcAddress string `protobuf:"bytes,2,opt,name=source_btc_address,json=sourceBtcAddress,proto3" json:"source_btc_address,omitempty"`
	// The Vega party identifier (pub-key) which is the target of the deposit
	TargetPartyId        string   `protobuf:"bytes,3,opt,name=target_party_id,json=targetPartyId,proto3" json:"target_party_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BTCDeposit) Reset()         { *m = BTCDeposit{} }
func (m *BTCDeposit) String() string { return proto.CompactTextString(m) }
func (*BTCDeposit) ProtoMessage()    {}
func (*BTCDeposit) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{8}
}

func (m *BTCDeposit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BTCDeposit.Unmarshal(m, b)
}
func (m *BTCDeposit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BTCDeposit.Marshal(b, m, deterministic)
}
func (m *BTCDeposit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BTCDeposit.Merge(m, src)
}
func (m *BTCDeposit) XXX_Size() int {
	return xxx_messageInfo_BTCDeposit.Size(m)
}
func (m *BTCDeposit) XXX_DiscardUnknown() {
	xxx_messageInfo_BTCDeposit.DiscardUnknown(m)
}

var xxx_messageInfo_BTCDeposit proto.InternalMessageInfo

func (m *BTCDeposit) GetVegaAssetId() string {
	if m != nil {
		return m.VegaAssetId
	}
	return ""
}

func (m *BTCDeposit) GetSourceBtcAddress() string {
	if m != nil {
		return m.SourceBtcAddress
	}
	return ""
}

func (m *BTCDeposit) GetTargetPartyId() string {
	if m != nil {
		return m.TargetPartyId
	}
	return ""
}

// A Bitcoin withdrawal from Vega
type BTCWithdrawal struct {
	// The vega network internal identifier of the asset
	VegaAssetId string `protobuf:"bytes,1,opt,name=vega_asset_id,json=vegaAssetId,proto3" json:"vega_asset_id,omitempty"`
	// The party identifier (pub-key) initiating the withdrawal
	SourcePartyId string `protobuf:"bytes,2,opt,name=source_party_id,json=sourcePartyId,proto3" json:"source_party_id,omitempty"`
	// Target Bitcoin wallet address
	TargetBtcAddress string `protobuf:"bytes,3,opt,name=target_btc_address,json=targetBtcAddress,proto3" json:"target_btc_address,omitempty"`
	// The nonce reference of the transaction
	ReferenceNonce       string   `protobuf:"bytes,4,opt,name=reference_nonce,json=referenceNonce,proto3" json:"reference_nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BTCWithdrawal) Reset()         { *m = BTCWithdrawal{} }
func (m *BTCWithdrawal) String() string { return proto.CompactTextString(m) }
func (*BTCWithdrawal) ProtoMessage()    {}
func (*BTCWithdrawal) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{9}
}

func (m *BTCWithdrawal) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BTCWithdrawal.Unmarshal(m, b)
}
func (m *BTCWithdrawal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BTCWithdrawal.Marshal(b, m, deterministic)
}
func (m *BTCWithdrawal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BTCWithdrawal.Merge(m, src)
}
func (m *BTCWithdrawal) XXX_Size() int {
	return xxx_messageInfo_BTCWithdrawal.Size(m)
}
func (m *BTCWithdrawal) XXX_DiscardUnknown() {
	xxx_messageInfo_BTCWithdrawal.DiscardUnknown(m)
}

var xxx_messageInfo_BTCWithdrawal proto.InternalMessageInfo

func (m *BTCWithdrawal) GetVegaAssetId() string {
	if m != nil {
		return m.VegaAssetId
	}
	return ""
}

func (m *BTCWithdrawal) GetSourcePartyId() string {
	if m != nil {
		return m.SourcePartyId
	}
	return ""
}

func (m *BTCWithdrawal) GetTargetBtcAddress() string {
	if m != nil {
		return m.TargetBtcAddress
	}
	return ""
}

func (m *BTCWithdrawal) GetReferenceNonce() string {
	if m != nil {
		return m.ReferenceNonce
	}
	return ""
}

// An event from the Bitcoin network
type BTCEvent struct {
	// The index of the transaction
	Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// The block in which the transaction happened
	Block uint64 `protobuf:"varint,2,opt,name=block,proto3" json:"block,omitempty"`
	// The action
	//
	// Types that are valid to be assigned to Action:
	//	*BTCEvent_Deposit
	//	*BTCEvent_Withdrawal
	Action               isBTCEvent_Action `protobuf_oneof:"action"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *BTCEvent) Reset()         { *m = BTCEvent{} }
func (m *BTCEvent) String() string { return proto.CompactTextString(m) }
func (*BTCEvent) ProtoMessage()    {}
func (*BTCEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{10}
}

func (m *BTCEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BTCEvent.Unmarshal(m, b)
}
func (m *BTCEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BTCEvent.Marshal(b, m, deterministic)
}
func (m *BTCEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BTCEvent.Merge(m, src)
}
func (m *BTCEvent) XXX_Size() int {
	return xxx_messageInfo_BTCEvent.Size(m)
}
func (m *BTCEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_BTCEvent.DiscardUnknown(m)
}

var xxx_messageInfo_BTCEvent proto.InternalMessageInfo

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

func (m *BTCEvent) GetBlock() uint64 {
	if m != nil {
		return m.Block
	}
	return 0
}

type isBTCEvent_Action interface {
	isBTCEvent_Action()
}

type BTCEvent_Deposit struct {
	Deposit *BTCDeposit `protobuf:"bytes,1001,opt,name=deposit,proto3,oneof"`
}

type BTCEvent_Withdrawal struct {
	Withdrawal *BTCWithdrawal `protobuf:"bytes,1002,opt,name=withdrawal,proto3,oneof"`
}

func (*BTCEvent_Deposit) isBTCEvent_Action() {}

func (*BTCEvent_Withdrawal) isBTCEvent_Action() {}

func (m *BTCEvent) GetAction() isBTCEvent_Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *BTCEvent) GetDeposit() *BTCDeposit {
	if x, ok := m.GetAction().(*BTCEvent_Deposit); ok {
		return x.Deposit
	}
	return nil
}

func (m *BTCEvent) GetWithdrawal() *BTCWithdrawal {
	if x, ok := m.GetAction().(*BTCEvent_Withdrawal); ok {
		return x.Withdrawal
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BTCEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BTCEvent_Deposit)(nil),
		(*BTCEvent_Withdrawal)(nil),
	}
}

// Used as a wrapper for an Ethereum address (wallet/contract)
type EthereumAddress struct {
	// An Ethereum address
	Address              string   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EthereumAddress) Reset()         { *m = EthereumAddress{} }
func (m *EthereumAddress) String() string { return proto.CompactTextString(m) }
func (*EthereumAddress) ProtoMessage()    {}
func (*EthereumAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{11}
}

func (m *EthereumAddress) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EthereumAddress.Unmarshal(m, b)
}
func (m *EthereumAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EthereumAddress.Marshal(b, m, deterministic)
}
func (m *EthereumAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EthereumAddress.Merge(m, src)
}
func (m *EthereumAddress) XXX_Size() int {
	return xxx_messageInfo_EthereumAddress.Size(m)
}
func (m *EthereumAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_EthereumAddress.DiscardUnknown(m)
}

var xxx_messageInfo_EthereumAddress proto.InternalMessageInfo

func (m *EthereumAddress) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

// Used as a wrapper for a Bitcoin address (wallet)
type BitcoinAddress struct {
	// A Bitcoin address
	Address              string   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BitcoinAddress) Reset()         { *m = BitcoinAddress{} }
func (m *BitcoinAddress) String() string { return proto.CompactTextString(m) }
func (*BitcoinAddress) ProtoMessage()    {}
func (*BitcoinAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{12}
}

func (m *BitcoinAddress) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BitcoinAddress.Unmarshal(m, b)
}
func (m *BitcoinAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BitcoinAddress.Marshal(b, m, deterministic)
}
func (m *BitcoinAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BitcoinAddress.Merge(m, src)
}
func (m *BitcoinAddress) XXX_Size() int {
	return xxx_messageInfo_BitcoinAddress.Size(m)
}
func (m *BitcoinAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_BitcoinAddress.DiscardUnknown(m)
}

var xxx_messageInfo_BitcoinAddress proto.InternalMessageInfo

func (m *BitcoinAddress) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

// Used as a wrapper type on any possible network address supported by Vega
type Identifier struct {
	// The identifier
	//
	// Types that are valid to be assigned to Identifier:
	//	*Identifier_EthereumAddress
	//	*Identifier_BitcoinAddress
	Identifier           isIdentifier_Identifier `protobuf_oneof:"identifier"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *Identifier) Reset()         { *m = Identifier{} }
func (m *Identifier) String() string { return proto.CompactTextString(m) }
func (*Identifier) ProtoMessage()    {}
func (*Identifier) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{13}
}

func (m *Identifier) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Identifier.Unmarshal(m, b)
}
func (m *Identifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Identifier.Marshal(b, m, deterministic)
}
func (m *Identifier) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Identifier.Merge(m, src)
}
func (m *Identifier) XXX_Size() int {
	return xxx_messageInfo_Identifier.Size(m)
}
func (m *Identifier) XXX_DiscardUnknown() {
	xxx_messageInfo_Identifier.DiscardUnknown(m)
}

var xxx_messageInfo_Identifier proto.InternalMessageInfo

type isIdentifier_Identifier interface {
	isIdentifier_Identifier()
}

type Identifier_EthereumAddress struct {
	EthereumAddress *EthereumAddress `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3,oneof"`
}

type Identifier_BitcoinAddress struct {
	BitcoinAddress *BitcoinAddress `protobuf:"bytes,2,opt,name=bitcoin_address,json=bitcoinAddress,proto3,oneof"`
}

func (*Identifier_EthereumAddress) isIdentifier_Identifier() {}

func (*Identifier_BitcoinAddress) isIdentifier_Identifier() {}

func (m *Identifier) GetIdentifier() isIdentifier_Identifier {
	if m != nil {
		return m.Identifier
	}
	return nil
}

func (m *Identifier) GetEthereumAddress() *EthereumAddress {
	if x, ok := m.GetIdentifier().(*Identifier_EthereumAddress); ok {
		return x.EthereumAddress
	}
	return nil
}

func (m *Identifier) GetBitcoinAddress() *BitcoinAddress {
	if x, ok := m.GetIdentifier().(*Identifier_BitcoinAddress); ok {
		return x.BitcoinAddress
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Identifier) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Identifier_EthereumAddress)(nil),
		(*Identifier_BitcoinAddress)(nil),
	}
}

// A message to notify when a new validator is being added to the Vega network
type AddValidator struct {
	// The identifier of the validator
	Id                   *Identifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *AddValidator) Reset()         { *m = AddValidator{} }
func (m *AddValidator) String() string { return proto.CompactTextString(m) }
func (*AddValidator) ProtoMessage()    {}
func (*AddValidator) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{14}
}

func (m *AddValidator) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AddValidator.Unmarshal(m, b)
}
func (m *AddValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AddValidator.Marshal(b, m, deterministic)
}
func (m *AddValidator) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddValidator.Merge(m, src)
}
func (m *AddValidator) XXX_Size() int {
	return xxx_messageInfo_AddValidator.Size(m)
}
func (m *AddValidator) XXX_DiscardUnknown() {
	xxx_messageInfo_AddValidator.DiscardUnknown(m)
}

var xxx_messageInfo_AddValidator proto.InternalMessageInfo

func (m *AddValidator) GetId() *Identifier {
	if m != nil {
		return m.Id
	}
	return nil
}

// A message to notify when a validator is being removed from the Vega network
type RemoveValidator struct {
	// The identifier of the validator
	Id                   *Identifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *RemoveValidator) Reset()         { *m = RemoveValidator{} }
func (m *RemoveValidator) String() string { return proto.CompactTextString(m) }
func (*RemoveValidator) ProtoMessage()    {}
func (*RemoveValidator) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{15}
}

func (m *RemoveValidator) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RemoveValidator.Unmarshal(m, b)
}
func (m *RemoveValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RemoveValidator.Marshal(b, m, deterministic)
}
func (m *RemoveValidator) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveValidator.Merge(m, src)
}
func (m *RemoveValidator) XXX_Size() int {
	return xxx_messageInfo_RemoveValidator.Size(m)
}
func (m *RemoveValidator) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveValidator.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveValidator proto.InternalMessageInfo

func (m *RemoveValidator) GetId() *Identifier {
	if m != nil {
		return m.Id
	}
	return nil
}

// An event related to validator management with foreign networks
type ValidatorEvent struct {
	// The source identifier of the event
	SourceId string `protobuf:"bytes,1,opt,name=source_id,json=sourceId,proto3" json:"source_id,omitempty"`
	// The action
	//
	// Types that are valid to be assigned to Action:
	//	*ValidatorEvent_Add
	//	*ValidatorEvent_Rm
	Action               isValidatorEvent_Action `protobuf_oneof:"action"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *ValidatorEvent) Reset()         { *m = ValidatorEvent{} }
func (m *ValidatorEvent) String() string { return proto.CompactTextString(m) }
func (*ValidatorEvent) ProtoMessage()    {}
func (*ValidatorEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{16}
}

func (m *ValidatorEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ValidatorEvent.Unmarshal(m, b)
}
func (m *ValidatorEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ValidatorEvent.Marshal(b, m, deterministic)
}
func (m *ValidatorEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorEvent.Merge(m, src)
}
func (m *ValidatorEvent) XXX_Size() int {
	return xxx_messageInfo_ValidatorEvent.Size(m)
}
func (m *ValidatorEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorEvent.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorEvent proto.InternalMessageInfo

func (m *ValidatorEvent) GetSourceId() string {
	if m != nil {
		return m.SourceId
	}
	return ""
}

type isValidatorEvent_Action interface {
	isValidatorEvent_Action()
}

type ValidatorEvent_Add struct {
	Add *AddValidator `protobuf:"bytes,1001,opt,name=add,proto3,oneof"`
}

type ValidatorEvent_Rm struct {
	Rm *RemoveValidator `protobuf:"bytes,1002,opt,name=rm,proto3,oneof"`
}

func (*ValidatorEvent_Add) isValidatorEvent_Action() {}

func (*ValidatorEvent_Rm) isValidatorEvent_Action() {}

func (m *ValidatorEvent) GetAction() isValidatorEvent_Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *ValidatorEvent) GetAdd() *AddValidator {
	if x, ok := m.GetAction().(*ValidatorEvent_Add); ok {
		return x.Add
	}
	return nil
}

func (m *ValidatorEvent) GetRm() *RemoveValidator {
	if x, ok := m.GetAction().(*ValidatorEvent_Rm); ok {
		return x.Rm
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ValidatorEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ValidatorEvent_Add)(nil),
		(*ValidatorEvent_Rm)(nil),
	}
}

type StakingEvent struct {
	// Index of the transaction
	Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// The block in which the transaction was added
	Block uint64 `protobuf:"varint,2,opt,name=block,proto3" json:"block,omitempty"`
	// Types that are valid to be assigned to Action:
	//	*StakingEvent_StakeDeposited
	//	*StakingEvent_StakeRemoved
	Action               isStakingEvent_Action `protobuf_oneof:"action"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *StakingEvent) Reset()         { *m = StakingEvent{} }
func (m *StakingEvent) String() string { return proto.CompactTextString(m) }
func (*StakingEvent) ProtoMessage()    {}
func (*StakingEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{17}
}

func (m *StakingEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StakingEvent.Unmarshal(m, b)
}
func (m *StakingEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StakingEvent.Marshal(b, m, deterministic)
}
func (m *StakingEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StakingEvent.Merge(m, src)
}
func (m *StakingEvent) XXX_Size() int {
	return xxx_messageInfo_StakingEvent.Size(m)
}
func (m *StakingEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_StakingEvent.DiscardUnknown(m)
}

var xxx_messageInfo_StakingEvent proto.InternalMessageInfo

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

func (m *StakingEvent) GetBlock() uint64 {
	if m != nil {
		return m.Block
	}
	return 0
}

type isStakingEvent_Action interface {
	isStakingEvent_Action()
}

type StakingEvent_StakeDeposited struct {
	StakeDeposited *StakeDeposited `protobuf:"bytes,1001,opt,name=stake_deposited,json=stakeDeposited,proto3,oneof"`
}

type StakingEvent_StakeRemoved struct {
	StakeRemoved *StakeRemoved `protobuf:"bytes,1002,opt,name=stake_removed,json=stakeRemoved,proto3,oneof"`
}

func (*StakingEvent_StakeDeposited) isStakingEvent_Action() {}

func (*StakingEvent_StakeRemoved) isStakingEvent_Action() {}

func (m *StakingEvent) GetAction() isStakingEvent_Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *StakingEvent) GetStakeDeposited() *StakeDeposited {
	if x, ok := m.GetAction().(*StakingEvent_StakeDeposited); ok {
		return x.StakeDeposited
	}
	return nil
}

func (m *StakingEvent) GetStakeRemoved() *StakeRemoved {
	if x, ok := m.GetAction().(*StakingEvent_StakeRemoved); ok {
		return x.StakeRemoved
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*StakingEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*StakingEvent_StakeDeposited)(nil),
		(*StakingEvent_StakeRemoved)(nil),
	}
}

type StakeDeposited struct {
	// Ethereum Address of the user depositing stake (hex encode with 0x prefix)
	EthereumAddress string `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"`
	// The public of the party receiving the stake deposit (hex encode)
	VegaPublicKey string `protobuf:"bytes,2,opt,name=vega_public_key,json=vegaPublicKey,proto3" json:"vega_public_key,omitempty"`
	// The amount deposited (base 10)
	Amount string `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// The time at which the block was produced
	// will be used to inform the core at what time
	// the stake started to be available.
	BlockTime            int64    `protobuf:"varint,4,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StakeDeposited) Reset()         { *m = StakeDeposited{} }
func (m *StakeDeposited) String() string { return proto.CompactTextString(m) }
func (*StakeDeposited) ProtoMessage()    {}
func (*StakeDeposited) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{18}
}

func (m *StakeDeposited) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StakeDeposited.Unmarshal(m, b)
}
func (m *StakeDeposited) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StakeDeposited.Marshal(b, m, deterministic)
}
func (m *StakeDeposited) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StakeDeposited.Merge(m, src)
}
func (m *StakeDeposited) XXX_Size() int {
	return xxx_messageInfo_StakeDeposited.Size(m)
}
func (m *StakeDeposited) XXX_DiscardUnknown() {
	xxx_messageInfo_StakeDeposited.DiscardUnknown(m)
}

var xxx_messageInfo_StakeDeposited proto.InternalMessageInfo

func (m *StakeDeposited) GetEthereumAddress() string {
	if m != nil {
		return m.EthereumAddress
	}
	return ""
}

func (m *StakeDeposited) GetVegaPublicKey() string {
	if m != nil {
		return m.VegaPublicKey
	}
	return ""
}

func (m *StakeDeposited) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func (m *StakeDeposited) GetBlockTime() int64 {
	if m != nil {
		return m.BlockTime
	}
	return 0
}

type StakeRemoved struct {
	// Ethereum address of the user removing stake (hex encode with 0x prefix)
	EthereumAddress string `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"`
	// The public key of the party from which to remove stake (hex encode)
	VegaPublicKey string `protobuf:"bytes,2,opt,name=vega_public_key,json=vegaPublicKey,proto3" json:"vega_public_key,omitempty"`
	// The amount removed (base 10)
	Amount string `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// The time at which the block was produced
	// will be used to inform the core at what time
	// the stake was made unavailable.
	BlockTime            int64    `protobuf:"varint,4,opt,name=block_time,json=blockTime,proto3" json:"block_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StakeRemoved) Reset()         { *m = StakeRemoved{} }
func (m *StakeRemoved) String() string { return proto.CompactTextString(m) }
func (*StakeRemoved) ProtoMessage()    {}
func (*StakeRemoved) Descriptor() ([]byte, []int) {
	return fileDescriptor_5269c2ee1b00a4bc, []int{19}
}

func (m *StakeRemoved) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StakeRemoved.Unmarshal(m, b)
}
func (m *StakeRemoved) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StakeRemoved.Marshal(b, m, deterministic)
}
func (m *StakeRemoved) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StakeRemoved.Merge(m, src)
}
func (m *StakeRemoved) XXX_Size() int {
	return xxx_messageInfo_StakeRemoved.Size(m)
}
func (m *StakeRemoved) XXX_DiscardUnknown() {
	xxx_messageInfo_StakeRemoved.DiscardUnknown(m)
}

var xxx_messageInfo_StakeRemoved proto.InternalMessageInfo

func (m *StakeRemoved) GetEthereumAddress() string {
	if m != nil {
		return m.EthereumAddress
	}
	return ""
}

func (m *StakeRemoved) GetVegaPublicKey() string {
	if m != nil {
		return m.VegaPublicKey
	}
	return ""
}

func (m *StakeRemoved) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func (m *StakeRemoved) GetBlockTime() int64 {
	if m != nil {
		return m.BlockTime
	}
	return 0
}

func init() {
	proto.RegisterType((*BuiltinAssetDeposit)(nil), "vega.BuiltinAssetDeposit")
	proto.RegisterType((*BuiltinAssetWithdrawal)(nil), "vega.BuiltinAssetWithdrawal")
	proto.RegisterType((*BuiltinAssetEvent)(nil), "vega.BuiltinAssetEvent")
	proto.RegisterType((*ERC20AssetList)(nil), "vega.ERC20AssetList")
	proto.RegisterType((*ERC20AssetDelist)(nil), "vega.ERC20AssetDelist")
	proto.RegisterType((*ERC20Deposit)(nil), "vega.ERC20Deposit")
	proto.RegisterType((*ERC20Withdrawal)(nil), "vega.ERC20Withdrawal")
	proto.RegisterType((*ERC20Event)(nil), "vega.ERC20Event")
	proto.RegisterType((*BTCDeposit)(nil), "vega.BTCDeposit")
	proto.RegisterType((*BTCWithdrawal)(nil), "vega.BTCWithdrawal")
	proto.RegisterType((*BTCEvent)(nil), "vega.BTCEvent")
	proto.RegisterType((*EthereumAddress)(nil), "vega.EthereumAddress")
	proto.RegisterType((*BitcoinAddress)(nil), "vega.BitcoinAddress")
	proto.RegisterType((*Identifier)(nil), "vega.Identifier")
	proto.RegisterType((*AddValidator)(nil), "vega.AddValidator")
	proto.RegisterType((*RemoveValidator)(nil), "vega.RemoveValidator")
	proto.RegisterType((*ValidatorEvent)(nil), "vega.ValidatorEvent")
	proto.RegisterType((*StakingEvent)(nil), "vega.StakingEvent")
	proto.RegisterType((*StakeDeposited)(nil), "vega.StakeDeposited")
	proto.RegisterType((*StakeRemoved)(nil), "vega.StakeRemoved")
}

func init() { proto.RegisterFile("vega/chain_events.proto", fileDescriptor_5269c2ee1b00a4bc) }

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