transaction.pb.go

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

package java

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

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

type InvalidTransactionRecord_ErrType int32

const (
	InvalidTransactionRecord_OUTOFBALANCE           InvalidTransactionRecord_ErrType = 0
	InvalidTransactionRecord_SIGFAILED              InvalidTransactionRecord_ErrType = 1
	InvalidTransactionRecord_INVOKE_CONTRACT_FAILED InvalidTransactionRecord_ErrType = 2
	InvalidTransactionRecord_DEPLOY_CONTRACT_FAILED InvalidTransactionRecord_ErrType = 3
	InvalidTransactionRecord_INVALID_PERMISSION     InvalidTransactionRecord_ErrType = 4
)

var InvalidTransactionRecord_ErrType_name = map[int32]string{
	0: "OUTOFBALANCE",
	1: "SIGFAILED",
	2: "INVOKE_CONTRACT_FAILED",
	3: "DEPLOY_CONTRACT_FAILED",
	4: "INVALID_PERMISSION",
}
var InvalidTransactionRecord_ErrType_value = map[string]int32{
	"OUTOFBALANCE":           0,
	"SIGFAILED":              1,
	"INVOKE_CONTRACT_FAILED": 2,
	"DEPLOY_CONTRACT_FAILED": 3,
	"INVALID_PERMISSION":     4,
}

func (x InvalidTransactionRecord_ErrType) String() string {
	return proto.EnumName(InvalidTransactionRecord_ErrType_name, int32(x))
}
func (InvalidTransactionRecord_ErrType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{1, 0}
}

type TransactionValue_Opcode int32

const (
	TransactionValue_NORMAL   TransactionValue_Opcode = 0
	TransactionValue_UPDATE   TransactionValue_Opcode = 1
	TransactionValue_FREEZE   TransactionValue_Opcode = 2
	TransactionValue_UNFREEZE TransactionValue_Opcode = 3
	TransactionValue_SKIPVM   TransactionValue_Opcode = 4
	TransactionValue_ARCHIVE  TransactionValue_Opcode = 100
)

var TransactionValue_Opcode_name = map[int32]string{
	0:   "NORMAL",
	1:   "UPDATE",
	2:   "FREEZE",
	3:   "UNFREEZE",
	4:   "SKIPVM",
	100: "ARCHIVE",
}
var TransactionValue_Opcode_value = map[string]int32{
	"NORMAL":   0,
	"UPDATE":   1,
	"FREEZE":   2,
	"UNFREEZE": 3,
	"SKIPVM":   4,
	"ARCHIVE":  100,
}

func (x TransactionValue_Opcode) String() string {
	return proto.EnumName(TransactionValue_Opcode_name, int32(x))
}
func (TransactionValue_Opcode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{5, 0}
}

type TransactionValue_VmType int32

const (
	TransactionValue_EVM TransactionValue_VmType = 0
	TransactionValue_JVM TransactionValue_VmType = 1
)

var TransactionValue_VmType_name = map[int32]string{
	0: "EVM",
	1: "JVM",
}
var TransactionValue_VmType_value = map[string]int32{
	"EVM": 0,
	"JVM": 1,
}

func (x TransactionValue_VmType) String() string {
	return proto.EnumName(TransactionValue_VmType_name, int32(x))
}
func (TransactionValue_VmType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{5, 1}
}

type Transaction struct {
	Version              []byte   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	From                 []byte   `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	To                   []byte   `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
	Value                []byte   `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
	Timestamp            int64    `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Signature            []byte   `protobuf:"bytes,6,opt,name=signature,proto3" json:"signature,omitempty"`
	Id                   uint64   `protobuf:"varint,7,opt,name=id,proto3" json:"id,omitempty"`
	TransactionHash      []byte   `protobuf:"bytes,8,opt,name=transactionHash,proto3" json:"transactionHash,omitempty"`
	Nonce                int64    `protobuf:"varint,9,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Other                *NonHash `protobuf:"bytes,10,opt,name=other,proto3" json:"other,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Transaction) Reset()         { *m = Transaction{} }
func (m *Transaction) String() string { return proto.CompactTextString(m) }
func (*Transaction) ProtoMessage()    {}
func (*Transaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{0}
}
func (m *Transaction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Transaction.Unmarshal(m, b)
}
func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Transaction.Marshal(b, m, deterministic)
}
func (dst *Transaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Transaction.Merge(dst, src)
}
func (m *Transaction) XXX_Size() int {
	return xxx_messageInfo_Transaction.Size(m)
}
func (m *Transaction) XXX_DiscardUnknown() {
	xxx_messageInfo_Transaction.DiscardUnknown(m)
}

var xxx_messageInfo_Transaction proto.InternalMessageInfo

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

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

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

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

func (m *Transaction) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

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

func (m *Transaction) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

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

func (m *Transaction) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *Transaction) GetOther() *NonHash {
	if m != nil {
		return m.Other
	}
	return nil
}

type InvalidTransactionRecord struct {
	Tx                   *Transaction                     `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	ErrType              InvalidTransactionRecord_ErrType `protobuf:"varint,2,opt,name=errType,proto3,enum=proto.InvalidTransactionRecord_ErrType" json:"errType,omitempty"`
	ErrMsg               []byte                           `protobuf:"bytes,3,opt,name=errMsg,proto3" json:"errMsg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *InvalidTransactionRecord) Reset()         { *m = InvalidTransactionRecord{} }
func (m *InvalidTransactionRecord) String() string { return proto.CompactTextString(m) }
func (*InvalidTransactionRecord) ProtoMessage()    {}
func (*InvalidTransactionRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{1}
}
func (m *InvalidTransactionRecord) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvalidTransactionRecord.Unmarshal(m, b)
}
func (m *InvalidTransactionRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvalidTransactionRecord.Marshal(b, m, deterministic)
}
func (dst *InvalidTransactionRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvalidTransactionRecord.Merge(dst, src)
}
func (m *InvalidTransactionRecord) XXX_Size() int {
	return xxx_messageInfo_InvalidTransactionRecord.Size(m)
}
func (m *InvalidTransactionRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_InvalidTransactionRecord.DiscardUnknown(m)
}

var xxx_messageInfo_InvalidTransactionRecord proto.InternalMessageInfo

func (m *InvalidTransactionRecord) GetTx() *Transaction {
	if m != nil {
		return m.Tx
	}
	return nil
}

func (m *InvalidTransactionRecord) GetErrType() InvalidTransactionRecord_ErrType {
	if m != nil {
		return m.ErrType
	}
	return InvalidTransactionRecord_OUTOFBALANCE
}

func (m *InvalidTransactionRecord) GetErrMsg() []byte {
	if m != nil {
		return m.ErrMsg
	}
	return nil
}

type InvalidTransactionRecords struct {
	Records              []*InvalidTransactionRecord `protobuf:"bytes,1,rep,name=records,proto3" json:"records,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *InvalidTransactionRecords) Reset()         { *m = InvalidTransactionRecords{} }
func (m *InvalidTransactionRecords) String() string { return proto.CompactTextString(m) }
func (*InvalidTransactionRecords) ProtoMessage()    {}
func (*InvalidTransactionRecords) Descriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{2}
}
func (m *InvalidTransactionRecords) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvalidTransactionRecords.Unmarshal(m, b)
}
func (m *InvalidTransactionRecords) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvalidTransactionRecords.Marshal(b, m, deterministic)
}
func (dst *InvalidTransactionRecords) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvalidTransactionRecords.Merge(dst, src)
}
func (m *InvalidTransactionRecords) XXX_Size() int {
	return xxx_messageInfo_InvalidTransactionRecords.Size(m)
}
func (m *InvalidTransactionRecords) XXX_DiscardUnknown() {
	xxx_messageInfo_InvalidTransactionRecords.DiscardUnknown(m)
}

var xxx_messageInfo_InvalidTransactionRecords proto.InternalMessageInfo

func (m *InvalidTransactionRecords) GetRecords() []*InvalidTransactionRecord {
	if m != nil {
		return m.Records
	}
	return nil
}

type TransactionMeta struct {
	BlockIndex           uint64   `protobuf:"varint,1,opt,name=BlockIndex,proto3" json:"BlockIndex,omitempty"`
	Index                int64    `protobuf:"varint,2,opt,name=Index,proto3" json:"Index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TransactionMeta) Reset()         { *m = TransactionMeta{} }
func (m *TransactionMeta) String() string { return proto.CompactTextString(m) }
func (*TransactionMeta) ProtoMessage()    {}
func (*TransactionMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{3}
}
func (m *TransactionMeta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TransactionMeta.Unmarshal(m, b)
}
func (m *TransactionMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TransactionMeta.Marshal(b, m, deterministic)
}
func (dst *TransactionMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionMeta.Merge(dst, src)
}
func (m *TransactionMeta) XXX_Size() int {
	return xxx_messageInfo_TransactionMeta.Size(m)
}
func (m *TransactionMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionMeta.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionMeta proto.InternalMessageInfo

func (m *TransactionMeta) GetBlockIndex() uint64 {
	if m != nil {
		return m.BlockIndex
	}
	return 0
}

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

type TransactionWrapper struct {
	TransactionVersion   []byte   `protobuf:"bytes,1,opt,name=transactionVersion,proto3" json:"transactionVersion,omitempty"`
	Transaction          []byte   `protobuf:"bytes,2,opt,name=transaction,proto3" json:"transaction,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TransactionWrapper) Reset()         { *m = TransactionWrapper{} }
func (m *TransactionWrapper) String() string { return proto.CompactTextString(m) }
func (*TransactionWrapper) ProtoMessage()    {}
func (*TransactionWrapper) Descriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{4}
}
func (m *TransactionWrapper) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TransactionWrapper.Unmarshal(m, b)
}
func (m *TransactionWrapper) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TransactionWrapper.Marshal(b, m, deterministic)
}
func (dst *TransactionWrapper) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionWrapper.Merge(dst, src)
}
func (m *TransactionWrapper) XXX_Size() int {
	return xxx_messageInfo_TransactionWrapper.Size(m)
}
func (m *TransactionWrapper) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionWrapper.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionWrapper proto.InternalMessageInfo

func (m *TransactionWrapper) GetTransactionVersion() []byte {
	if m != nil {
		return m.TransactionVersion
	}
	return nil
}

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

type TransactionValue struct {
	Price                int64                   `protobuf:"varint,1,opt,name=price,proto3" json:"price,omitempty"`
	GasLimit             int64                   `protobuf:"varint,2,opt,name=gasLimit,proto3" json:"gasLimit,omitempty"`
	Amount               int64                   `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	Payload              []byte                  `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"`
	EncryptedAmount      []byte                  `protobuf:"bytes,5,opt,name=encryptedAmount,proto3" json:"encryptedAmount,omitempty"`
	HomomorphicAmount    []byte                  `protobuf:"bytes,6,opt,name=homomorphicAmount,proto3" json:"homomorphicAmount,omitempty"`
	HomomorphicBalance   []byte                  `protobuf:"bytes,7,opt,name=homomorphicBalance,proto3" json:"homomorphicBalance,omitempty"`
	Op                   TransactionValue_Opcode `protobuf:"varint,8,opt,name=op,proto3,enum=proto.TransactionValue_Opcode" json:"op,omitempty"`
	Extra                []byte                  `protobuf:"bytes,9,opt,name=extra,proto3" json:"extra,omitempty"`
	VmType               TransactionValue_VmType `protobuf:"varint,10,opt,name=vmType,proto3,enum=proto.TransactionValue_VmType" json:"vmType,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *TransactionValue) Reset()         { *m = TransactionValue{} }
func (m *TransactionValue) String() string { return proto.CompactTextString(m) }
func (*TransactionValue) ProtoMessage()    {}
func (*TransactionValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{5}
}
func (m *TransactionValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TransactionValue.Unmarshal(m, b)
}
func (m *TransactionValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TransactionValue.Marshal(b, m, deterministic)
}
func (dst *TransactionValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionValue.Merge(dst, src)
}
func (m *TransactionValue) XXX_Size() int {
	return xxx_messageInfo_TransactionValue.Size(m)
}
func (m *TransactionValue) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionValue.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionValue proto.InternalMessageInfo

func (m *TransactionValue) GetPrice() int64 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *TransactionValue) GetGasLimit() int64 {
	if m != nil {
		return m.GasLimit
	}
	return 0
}

func (m *TransactionValue) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *TransactionValue) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *TransactionValue) GetEncryptedAmount() []byte {
	if m != nil {
		return m.EncryptedAmount
	}
	return nil
}

func (m *TransactionValue) GetHomomorphicAmount() []byte {
	if m != nil {
		return m.HomomorphicAmount
	}
	return nil
}

func (m *TransactionValue) GetHomomorphicBalance() []byte {
	if m != nil {
		return m.HomomorphicBalance
	}
	return nil
}

func (m *TransactionValue) GetOp() TransactionValue_Opcode {
	if m != nil {
		return m.Op
	}
	return TransactionValue_NORMAL
}

func (m *TransactionValue) GetExtra() []byte {
	if m != nil {
		return m.Extra
	}
	return nil
}

func (m *TransactionValue) GetVmType() TransactionValue_VmType {
	if m != nil {
		return m.VmType
	}
	return TransactionValue_EVM
}

type InvokeArgs struct {
	Code                 []byte   `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
	MethodName           string   `protobuf:"bytes,2,opt,name=methodName,proto3" json:"methodName,omitempty"`
	Args                 [][]byte `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *InvokeArgs) Reset()         { *m = InvokeArgs{} }
func (m *InvokeArgs) String() string { return proto.CompactTextString(m) }
func (*InvokeArgs) ProtoMessage()    {}
func (*InvokeArgs) Descriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{6}
}
func (m *InvokeArgs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvokeArgs.Unmarshal(m, b)
}
func (m *InvokeArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvokeArgs.Marshal(b, m, deterministic)
}
func (dst *InvokeArgs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvokeArgs.Merge(dst, src)
}
func (m *InvokeArgs) XXX_Size() int {
	return xxx_messageInfo_InvokeArgs.Size(m)
}
func (m *InvokeArgs) XXX_DiscardUnknown() {
	xxx_messageInfo_InvokeArgs.DiscardUnknown(m)
}

var xxx_messageInfo_InvokeArgs proto.InternalMessageInfo

func (m *InvokeArgs) GetCode() []byte {
	if m != nil {
		return m.Code
	}
	return nil
}

func (m *InvokeArgs) GetMethodName() string {
	if m != nil {
		return m.MethodName
	}
	return ""
}

func (m *InvokeArgs) GetArgs() [][]byte {
	if m != nil {
		return m.Args
	}
	return nil
}

type NonHash struct {
	NodeHash             []byte   `protobuf:"bytes,1,opt,name=nodeHash,proto3" json:"nodeHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NonHash) Reset()         { *m = NonHash{} }
func (m *NonHash) String() string { return proto.CompactTextString(m) }
func (*NonHash) ProtoMessage()    {}
func (*NonHash) Descriptor() ([]byte, []int) {
	return fileDescriptor_transaction_5439e9cf8e3d0ffc, []int{7}
}
func (m *NonHash) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NonHash.Unmarshal(m, b)
}
func (m *NonHash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NonHash.Marshal(b, m, deterministic)
}
func (dst *NonHash) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NonHash.Merge(dst, src)
}
func (m *NonHash) XXX_Size() int {
	return xxx_messageInfo_NonHash.Size(m)
}
func (m *NonHash) XXX_DiscardUnknown() {
	xxx_messageInfo_NonHash.DiscardUnknown(m)
}

var xxx_messageInfo_NonHash proto.InternalMessageInfo

func (m *NonHash) GetNodeHash() []byte {
	if m != nil {
		return m.NodeHash
	}
	return nil
}

func init() {
	proto.RegisterType((*Transaction)(nil), "proto.Transaction")
	proto.RegisterType((*InvalidTransactionRecord)(nil), "proto.InvalidTransactionRecord")
	proto.RegisterType((*InvalidTransactionRecords)(nil), "proto.InvalidTransactionRecords")
	proto.RegisterType((*TransactionMeta)(nil), "proto.TransactionMeta")
	proto.RegisterType((*TransactionWrapper)(nil), "proto.TransactionWrapper")
	proto.RegisterType((*TransactionValue)(nil), "proto.TransactionValue")
	proto.RegisterType((*InvokeArgs)(nil), "proto.InvokeArgs")
	proto.RegisterType((*NonHash)(nil), "proto.NonHash")
	proto.RegisterEnum("proto.InvalidTransactionRecord_ErrType", InvalidTransactionRecord_ErrType_name, InvalidTransactionRecord_ErrType_value)
	proto.RegisterEnum("proto.TransactionValue_Opcode", TransactionValue_Opcode_name, TransactionValue_Opcode_value)
	proto.RegisterEnum("proto.TransactionValue_VmType", TransactionValue_VmType_name, TransactionValue_VmType_value)
}

func init() { proto.RegisterFile("transaction.proto", fileDescriptor_transaction_5439e9cf8e3d0ffc) }

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