func (*ExecutionStatus) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ExecutionStatus_RuntimeStatus)(nil),
		(*ExecutionStatus_AssertionFailure)(nil),
		(*ExecutionStatus_ArithmeticError)(nil),
		(*ExecutionStatus_ReferenceError)(nil),
	}
}
XXX_OneofWrappers is for the internal use of the proto package.
package gowrapper
import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
const _ = proto.ProtoPackageIsVersion3  
type VMValidationStatusCode int32
const (
	VMValidationStatusCode_UnknownValidationStatus VMValidationStatusCode = 0
	VMValidationStatusCode_InvalidSignature VMValidationStatusCode = 1
	VMValidationStatusCode_InvalidAuthKey VMValidationStatusCode = 2
	VMValidationStatusCode_SequenceNumberTooOld VMValidationStatusCode = 3
	VMValidationStatusCode_SequenceNumberTooNew VMValidationStatusCode = 4
	VMValidationStatusCode_InsufficientBalanceForTransactionFee VMValidationStatusCode = 5
	VMValidationStatusCode_TransactionExpired VMValidationStatusCode = 6
	VMValidationStatusCode_SendingAccountDoesNotExist VMValidationStatusCode = 7
	VMValidationStatusCode_RejectedWriteSet VMValidationStatusCode = 8
	VMValidationStatusCode_InvalidWriteSet VMValidationStatusCode = 9
	VMValidationStatusCode_ExceededMaxTransactionSize VMValidationStatusCode = 10
	VMValidationStatusCode_UnknownScript VMValidationStatusCode = 11
	VMValidationStatusCode_UnknownModule VMValidationStatusCode = 12
	VMValidationStatusCode_MaxGasUnitsExceedsMaxGasUnitsBound VMValidationStatusCode = 13
	VMValidationStatusCode_MaxGasUnitsBelowMinTransactionGasUnits VMValidationStatusCode = 14
	VMValidationStatusCode_GasUnitPriceBelowMinBound VMValidationStatusCode = 15
	VMValidationStatusCode_GasUnitPriceAboveMaxBound VMValidationStatusCode = 16
)
var VMValidationStatusCode_name = map[int32]string{
	0:  "UnknownValidationStatus",
	1:  "InvalidSignature",
	2:  "InvalidAuthKey",
	3:  "SequenceNumberTooOld",
	4:  "SequenceNumberTooNew",
	5:  "InsufficientBalanceForTransactionFee",
	6:  "TransactionExpired",
	7:  "SendingAccountDoesNotExist",
	8:  "RejectedWriteSet",
	9:  "InvalidWriteSet",
	10: "ExceededMaxTransactionSize",
	11: "UnknownScript",
	12: "UnknownModule",
	13: "MaxGasUnitsExceedsMaxGasUnitsBound",
	14: "MaxGasUnitsBelowMinTransactionGasUnits",
	15: "GasUnitPriceBelowMinBound",
	16: "GasUnitPriceAboveMaxBound",
}
var VMValidationStatusCode_value = map[string]int32{
	"UnknownValidationStatus":                0,
	"InvalidSignature":                       1,
	"InvalidAuthKey":                         2,
	"SequenceNumberTooOld":                   3,
	"SequenceNumberTooNew":                   4,
	"InsufficientBalanceForTransactionFee":   5,
	"TransactionExpired":                     6,
	"SendingAccountDoesNotExist":             7,
	"RejectedWriteSet":                       8,
	"InvalidWriteSet":                        9,
	"ExceededMaxTransactionSize":             10,
	"UnknownScript":                          11,
	"UnknownModule":                          12,
	"MaxGasUnitsExceedsMaxGasUnitsBound":     13,
	"MaxGasUnitsBelowMinTransactionGasUnits": 14,
	"GasUnitPriceBelowMinBound":              15,
	"GasUnitPriceAboveMaxBound":              16,
}
func (x VMValidationStatusCode) String() string {
	return proto.EnumName(VMValidationStatusCode_name, int32(x))
}
func (VMValidationStatusCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{0}
}
type VMVerificationErrorKind int32
const (
	VMVerificationErrorKind_UnknownVerificationError            VMVerificationErrorKind = 0
	VMVerificationErrorKind_IndexOutOfBounds                    VMVerificationErrorKind = 1
	VMVerificationErrorKind_RangeOutOfBounds                    VMVerificationErrorKind = 2
	VMVerificationErrorKind_InvalidSignatureToken               VMVerificationErrorKind = 3
	VMVerificationErrorKind_InvalidFieldDefReference            VMVerificationErrorKind = 4
	VMVerificationErrorKind_RecursiveStructDefinition           VMVerificationErrorKind = 5
	VMVerificationErrorKind_InvalidResourceField                VMVerificationErrorKind = 6
	VMVerificationErrorKind_InvalidFallThrough                  VMVerificationErrorKind = 7
	VMVerificationErrorKind_JoinFailure                         VMVerificationErrorKind = 8
	VMVerificationErrorKind_NegativeStackSizeWithinBlock        VMVerificationErrorKind = 9
	VMVerificationErrorKind_UnbalancedStack                     VMVerificationErrorKind = 10
	VMVerificationErrorKind_InvalidMainFunctionSignature        VMVerificationErrorKind = 11
	VMVerificationErrorKind_DuplicateElement                    VMVerificationErrorKind = 12
	VMVerificationErrorKind_InvalidModuleHandle                 VMVerificationErrorKind = 13
	VMVerificationErrorKind_UnimplementedHandle                 VMVerificationErrorKind = 14
	VMVerificationErrorKind_InconsistentFields                  VMVerificationErrorKind = 15
	VMVerificationErrorKind_UnusedFields                        VMVerificationErrorKind = 16
	VMVerificationErrorKind_LookupFailed                        VMVerificationErrorKind = 17
	VMVerificationErrorKind_VisibilityMismatch                  VMVerificationErrorKind = 18
	VMVerificationErrorKind_TypeResolutionFailure               VMVerificationErrorKind = 19
	VMVerificationErrorKind_TypeMismatch                        VMVerificationErrorKind = 20
	VMVerificationErrorKind_MissingDependency                   VMVerificationErrorKind = 21
	VMVerificationErrorKind_PopReferenceError                   VMVerificationErrorKind = 22
	VMVerificationErrorKind_PopResourceError                    VMVerificationErrorKind = 23
	VMVerificationErrorKind_ReleaseRefTypeMismatchError         VMVerificationErrorKind = 24
	VMVerificationErrorKind_BrTypeMismatchError                 VMVerificationErrorKind = 25
	VMVerificationErrorKind_AssertTypeMismatchError             VMVerificationErrorKind = 26
	VMVerificationErrorKind_StLocTypeMismatchError              VMVerificationErrorKind = 27
	VMVerificationErrorKind_StLocUnsafeToDestroyError           VMVerificationErrorKind = 28
	VMVerificationErrorKind_RetUnsafeToDestroyError             VMVerificationErrorKind = 29
	VMVerificationErrorKind_RetTypeMismatchError                VMVerificationErrorKind = 30
	VMVerificationErrorKind_FreezeRefTypeMismatchError          VMVerificationErrorKind = 31
	VMVerificationErrorKind_FreezeRefExistsMutableBorrowError   VMVerificationErrorKind = 32
	VMVerificationErrorKind_BorrowFieldTypeMismatchError        VMVerificationErrorKind = 33
	VMVerificationErrorKind_BorrowFieldBadFieldError            VMVerificationErrorKind = 34
	VMVerificationErrorKind_BorrowFieldExistsMutableBorrowError VMVerificationErrorKind = 35
	VMVerificationErrorKind_CopyLocUnavailableError             VMVerificationErrorKind = 36
	VMVerificationErrorKind_CopyLocResourceError                VMVerificationErrorKind = 37
	VMVerificationErrorKind_CopyLocExistsBorrowError            VMVerificationErrorKind = 38
	VMVerificationErrorKind_MoveLocUnavailableError             VMVerificationErrorKind = 39
	VMVerificationErrorKind_MoveLocExistsBorrowError            VMVerificationErrorKind = 40
	VMVerificationErrorKind_BorrowLocReferenceError             VMVerificationErrorKind = 41
	VMVerificationErrorKind_BorrowLocUnavailableError           VMVerificationErrorKind = 42
	VMVerificationErrorKind_BorrowLocExistsBorrowError          VMVerificationErrorKind = 43
	VMVerificationErrorKind_CallTypeMismatchError               VMVerificationErrorKind = 44
	VMVerificationErrorKind_CallBorrowedMutableReferenceError   VMVerificationErrorKind = 45
	VMVerificationErrorKind_PackTypeMismatchError               VMVerificationErrorKind = 46
	VMVerificationErrorKind_UnpackTypeMismatchError             VMVerificationErrorKind = 47
	VMVerificationErrorKind_ReadRefTypeMismatchError            VMVerificationErrorKind = 48
	VMVerificationErrorKind_ReadRefResourceError                VMVerificationErrorKind = 49
	VMVerificationErrorKind_ReadRefExistsMutableBorrowError     VMVerificationErrorKind = 50
	VMVerificationErrorKind_WriteRefTypeMismatchError           VMVerificationErrorKind = 51
	VMVerificationErrorKind_WriteRefResourceError               VMVerificationErrorKind = 52
	VMVerificationErrorKind_WriteRefExistsBorrowError           VMVerificationErrorKind = 53
	VMVerificationErrorKind_WriteRefNoMutableReferenceError     VMVerificationErrorKind = 54
	VMVerificationErrorKind_IntegerOpTypeMismatchError          VMVerificationErrorKind = 55
	VMVerificationErrorKind_BooleanOpTypeMismatchError          VMVerificationErrorKind = 56
	VMVerificationErrorKind_EqualityOpTypeMismatchError         VMVerificationErrorKind = 57
	VMVerificationErrorKind_ExistsResourceTypeMismatchError     VMVerificationErrorKind = 58
	VMVerificationErrorKind_BorrowGlobalTypeMismatchError       VMVerificationErrorKind = 59
	VMVerificationErrorKind_BorrowGlobalNoResourceError         VMVerificationErrorKind = 60
	VMVerificationErrorKind_MoveFromTypeMismatchError           VMVerificationErrorKind = 61
	VMVerificationErrorKind_MoveFromNoResourceError             VMVerificationErrorKind = 62
	VMVerificationErrorKind_MoveToSenderTypeMismatchError       VMVerificationErrorKind = 63
	VMVerificationErrorKind_MoveToSenderNoResourceError         VMVerificationErrorKind = 64
	VMVerificationErrorKind_CreateAccountTypeMismatchError      VMVerificationErrorKind = 65
	VMVerificationErrorKind_ModuleAddressDoesNotMatchSender VMVerificationErrorKind = 66
	VMVerificationErrorKind_NoModuleHandles VMVerificationErrorKind = 67
)
var VMVerificationErrorKind_name = map[int32]string{
	0:  "UnknownVerificationError",
	1:  "IndexOutOfBounds",
	2:  "RangeOutOfBounds",
	3:  "InvalidSignatureToken",
	4:  "InvalidFieldDefReference",
	5:  "RecursiveStructDefinition",
	6:  "InvalidResourceField",
	7:  "InvalidFallThrough",
	8:  "JoinFailure",
	9:  "NegativeStackSizeWithinBlock",
	10: "UnbalancedStack",
	11: "InvalidMainFunctionSignature",
	12: "DuplicateElement",
	13: "InvalidModuleHandle",
	14: "UnimplementedHandle",
	15: "InconsistentFields",
	16: "UnusedFields",
	17: "LookupFailed",
	18: "VisibilityMismatch",
	19: "TypeResolutionFailure",
	20: "TypeMismatch",
	21: "MissingDependency",
	22: "PopReferenceError",
	23: "PopResourceError",
	24: "ReleaseRefTypeMismatchError",
	25: "BrTypeMismatchError",
	26: "AssertTypeMismatchError",
	27: "StLocTypeMismatchError",
	28: "StLocUnsafeToDestroyError",
	29: "RetUnsafeToDestroyError",
	30: "RetTypeMismatchError",
	31: "FreezeRefTypeMismatchError",
	32: "FreezeRefExistsMutableBorrowError",
	33: "BorrowFieldTypeMismatchError",
	34: "BorrowFieldBadFieldError",
	35: "BorrowFieldExistsMutableBorrowError",
	36: "CopyLocUnavailableError",
	37: "CopyLocResourceError",
	38: "CopyLocExistsBorrowError",
	39: "MoveLocUnavailableError",
	40: "MoveLocExistsBorrowError",
	41: "BorrowLocReferenceError",
	42: "BorrowLocUnavailableError",
	43: "BorrowLocExistsBorrowError",
	44: "CallTypeMismatchError",
	45: "CallBorrowedMutableReferenceError",
	46: "PackTypeMismatchError",
	47: "UnpackTypeMismatchError",
	48: "ReadRefTypeMismatchError",
	49: "ReadRefResourceError",
	50: "ReadRefExistsMutableBorrowError",
	51: "WriteRefTypeMismatchError",
	52: "WriteRefResourceError",
	53: "WriteRefExistsBorrowError",
	54: "WriteRefNoMutableReferenceError",
	55: "IntegerOpTypeMismatchError",
	56: "BooleanOpTypeMismatchError",
	57: "EqualityOpTypeMismatchError",
	58: "ExistsResourceTypeMismatchError",
	59: "BorrowGlobalTypeMismatchError",
	60: "BorrowGlobalNoResourceError",
	61: "MoveFromTypeMismatchError",
	62: "MoveFromNoResourceError",
	63: "MoveToSenderTypeMismatchError",
	64: "MoveToSenderNoResourceError",
	65: "CreateAccountTypeMismatchError",
	66: "ModuleAddressDoesNotMatchSender",
	67: "NoModuleHandles",
}
var VMVerificationErrorKind_value = map[string]int32{
	"UnknownVerificationError":            0,
	"IndexOutOfBounds":                    1,
	"RangeOutOfBounds":                    2,
	"InvalidSignatureToken":               3,
	"InvalidFieldDefReference":            4,
	"RecursiveStructDefinition":           5,
	"InvalidResourceField":                6,
	"InvalidFallThrough":                  7,
	"JoinFailure":                         8,
	"NegativeStackSizeWithinBlock":        9,
	"UnbalancedStack":                     10,
	"InvalidMainFunctionSignature":        11,
	"DuplicateElement":                    12,
	"InvalidModuleHandle":                 13,
	"UnimplementedHandle":                 14,
	"InconsistentFields":                  15,
	"UnusedFields":                        16,
	"LookupFailed":                        17,
	"VisibilityMismatch":                  18,
	"TypeResolutionFailure":               19,
	"TypeMismatch":                        20,
	"MissingDependency":                   21,
	"PopReferenceError":                   22,
	"PopResourceError":                    23,
	"ReleaseRefTypeMismatchError":         24,
	"BrTypeMismatchError":                 25,
	"AssertTypeMismatchError":             26,
	"StLocTypeMismatchError":              27,
	"StLocUnsafeToDestroyError":           28,
	"RetUnsafeToDestroyError":             29,
	"RetTypeMismatchError":                30,
	"FreezeRefTypeMismatchError":          31,
	"FreezeRefExistsMutableBorrowError":   32,
	"BorrowFieldTypeMismatchError":        33,
	"BorrowFieldBadFieldError":            34,
	"BorrowFieldExistsMutableBorrowError": 35,
	"CopyLocUnavailableError":             36,
	"CopyLocResourceError":                37,
	"CopyLocExistsBorrowError":            38,
	"MoveLocUnavailableError":             39,
	"MoveLocExistsBorrowError":            40,
	"BorrowLocReferenceError":             41,
	"BorrowLocUnavailableError":           42,
	"BorrowLocExistsBorrowError":          43,
	"CallTypeMismatchError":               44,
	"CallBorrowedMutableReferenceError":   45,
	"PackTypeMismatchError":               46,
	"UnpackTypeMismatchError":             47,
	"ReadRefTypeMismatchError":            48,
	"ReadRefResourceError":                49,
	"ReadRefExistsMutableBorrowError":     50,
	"WriteRefTypeMismatchError":           51,
	"WriteRefResourceError":               52,
	"WriteRefExistsBorrowError":           53,
	"WriteRefNoMutableReferenceError":     54,
	"IntegerOpTypeMismatchError":          55,
	"BooleanOpTypeMismatchError":          56,
	"EqualityOpTypeMismatchError":         57,
	"ExistsResourceTypeMismatchError":     58,
	"BorrowGlobalTypeMismatchError":       59,
	"BorrowGlobalNoResourceError":         60,
	"MoveFromTypeMismatchError":           61,
	"MoveFromNoResourceError":             62,
	"MoveToSenderTypeMismatchError":       63,
	"MoveToSenderNoResourceError":         64,
	"CreateAccountTypeMismatchError":      65,
	"ModuleAddressDoesNotMatchSender":     66,
	"NoModuleHandles":                     67,
}
func (x VMVerificationErrorKind) String() string {
	return proto.EnumName(VMVerificationErrorKind_name, int32(x))
}
func (VMVerificationErrorKind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{1}
}
type VMInvariantViolationError int32
const (
	VMInvariantViolationError_UnknownInvariantViolationError VMInvariantViolationError = 0
	VMInvariantViolationError_OutOfBoundsIndex               VMInvariantViolationError = 1
	VMInvariantViolationError_OutOfBoundsRange               VMInvariantViolationError = 2
	VMInvariantViolationError_EmptyValueStack                VMInvariantViolationError = 3
	VMInvariantViolationError_EmptyCallStack                 VMInvariantViolationError = 4
	VMInvariantViolationError_PCOverflow                     VMInvariantViolationError = 5
	VMInvariantViolationError_LinkerError                    VMInvariantViolationError = 6
	VMInvariantViolationError_LocalReferenceError            VMInvariantViolationError = 7
	VMInvariantViolationError_StorageError                   VMInvariantViolationError = 8
)
var VMInvariantViolationError_name = map[int32]string{
	0: "UnknownInvariantViolationError",
	1: "OutOfBoundsIndex",
	2: "OutOfBoundsRange",
	3: "EmptyValueStack",
	4: "EmptyCallStack",
	5: "PCOverflow",
	6: "LinkerError",
	7: "LocalReferenceError",
	8: "StorageError",
}
var VMInvariantViolationError_value = map[string]int32{
	"UnknownInvariantViolationError": 0,
	"OutOfBoundsIndex":               1,
	"OutOfBoundsRange":               2,
	"EmptyValueStack":                3,
	"EmptyCallStack":                 4,
	"PCOverflow":                     5,
	"LinkerError":                    6,
	"LocalReferenceError":            7,
	"StorageError":                   8,
}
func (x VMInvariantViolationError) String() string {
	return proto.EnumName(VMInvariantViolationError_name, int32(x))
}
func (VMInvariantViolationError) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{2}
}
type BinaryError int32
const (
	BinaryError_UnknownBinaryError      BinaryError = 0
	BinaryError_Malformed               BinaryError = 1
	BinaryError_BadMagic                BinaryError = 2
	BinaryError_UnknownVersion          BinaryError = 3
	BinaryError_UnknownTableType        BinaryError = 4
	BinaryError_UnknownSignatureType    BinaryError = 5
	BinaryError_UnknownSerializedType   BinaryError = 6
	BinaryError_UnknownOpcode           BinaryError = 7
	BinaryError_BadHeaderTable          BinaryError = 8
	BinaryError_UnexpectedSignatureType BinaryError = 9
	BinaryError_DuplicateTable          BinaryError = 10
)
var BinaryError_name = map[int32]string{
	0:  "UnknownBinaryError",
	1:  "Malformed",
	2:  "BadMagic",
	3:  "UnknownVersion",
	4:  "UnknownTableType",
	5:  "UnknownSignatureType",
	6:  "UnknownSerializedType",
	7:  "UnknownOpcode",
	8:  "BadHeaderTable",
	9:  "UnexpectedSignatureType",
	10: "DuplicateTable",
}
var BinaryError_value = map[string]int32{
	"UnknownBinaryError":      0,
	"Malformed":               1,
	"BadMagic":                2,
	"UnknownVersion":          3,
	"UnknownTableType":        4,
	"UnknownSignatureType":    5,
	"UnknownSerializedType":   6,
	"UnknownOpcode":           7,
	"BadHeaderTable":          8,
	"UnexpectedSignatureType": 9,
	"DuplicateTable":          10,
}
func (x BinaryError) String() string {
	return proto.EnumName(BinaryError_name, int32(x))
}
func (BinaryError) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{3}
}
type RuntimeStatus int32
const (
	RuntimeStatus_UnknownRuntimeStatus RuntimeStatus = 0
	RuntimeStatus_Executed             RuntimeStatus = 1
	RuntimeStatus_OutOfGas             RuntimeStatus = 2
	RuntimeStatus_ResourceDoesNotExist RuntimeStatus = 3
	RuntimeStatus_ResourceAlreadyExists RuntimeStatus = 4
	RuntimeStatus_EvictedAccountAccess RuntimeStatus = 5
	RuntimeStatus_AccountAddressAlreadyExists RuntimeStatus = 6
	RuntimeStatus_TypeError                   RuntimeStatus = 7
	RuntimeStatus_MissingData                 RuntimeStatus = 8
	RuntimeStatus_DataFormatError             RuntimeStatus = 9
	RuntimeStatus_InvalidData                 RuntimeStatus = 10
	RuntimeStatus_RemoteDataError             RuntimeStatus = 11
	RuntimeStatus_CannotWriteExistingResource RuntimeStatus = 12
	RuntimeStatus_ValueSerializationError     RuntimeStatus = 13
	RuntimeStatus_ValueDeserializationError   RuntimeStatus = 14
	RuntimeStatus_DuplicateModuleName RuntimeStatus = 15
)
var RuntimeStatus_name = map[int32]string{
	0:  "UnknownRuntimeStatus",
	1:  "Executed",
	2:  "OutOfGas",
	3:  "ResourceDoesNotExist",
	4:  "ResourceAlreadyExists",
	5:  "EvictedAccountAccess",
	6:  "AccountAddressAlreadyExists",
	7:  "TypeError",
	8:  "MissingData",
	9:  "DataFormatError",
	10: "InvalidData",
	11: "RemoteDataError",
	12: "CannotWriteExistingResource",
	13: "ValueSerializationError",
	14: "ValueDeserializationError",
	15: "DuplicateModuleName",
}
var RuntimeStatus_value = map[string]int32{
	"UnknownRuntimeStatus":        0,
	"Executed":                    1,
	"OutOfGas":                    2,
	"ResourceDoesNotExist":        3,
	"ResourceAlreadyExists":       4,
	"EvictedAccountAccess":        5,
	"AccountAddressAlreadyExists": 6,
	"TypeError":                   7,
	"MissingData":                 8,
	"DataFormatError":             9,
	"InvalidData":                 10,
	"RemoteDataError":             11,
	"CannotWriteExistingResource": 12,
	"ValueSerializationError":     13,
	"ValueDeserializationError":   14,
	"DuplicateModuleName":         15,
}
func (x RuntimeStatus) String() string {
	return proto.EnumName(RuntimeStatus_name, int32(x))
}
func (RuntimeStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{4}
}
type VMVerificationStatus_StatusKind int32
const (
	VMVerificationStatus_SCRIPT VMVerificationStatus_StatusKind = 0
	VMVerificationStatus_MODULE VMVerificationStatus_StatusKind = 1
)
var VMVerificationStatus_StatusKind_name = map[int32]string{
	0: "SCRIPT",
	1: "MODULE",
}
var VMVerificationStatus_StatusKind_value = map[string]int32{
	"SCRIPT": 0,
	"MODULE": 1,
}
func (x VMVerificationStatus_StatusKind) String() string {
	return proto.EnumName(VMVerificationStatus_StatusKind_name, int32(x))
}
func (VMVerificationStatus_StatusKind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{2, 0}
}
type ArithmeticError_ArithmeticErrorType int32
const (
	ArithmeticError_UnknownArithmeticError ArithmeticError_ArithmeticErrorType = 0
	ArithmeticError_Underflow              ArithmeticError_ArithmeticErrorType = 1
	ArithmeticError_Overflow               ArithmeticError_ArithmeticErrorType = 2
	ArithmeticError_DivisionByZero         ArithmeticError_ArithmeticErrorType = 3
)
var ArithmeticError_ArithmeticErrorType_name = map[int32]string{
	0: "UnknownArithmeticError",
	1: "Underflow",
	2: "Overflow",
	3: "DivisionByZero",
}
var ArithmeticError_ArithmeticErrorType_value = map[string]int32{
	"UnknownArithmeticError": 0,
	"Underflow":              1,
	"Overflow":               2,
	"DivisionByZero":         3,
}
func (x ArithmeticError_ArithmeticErrorType) String() string {
	return proto.EnumName(ArithmeticError_ArithmeticErrorType_name, int32(x))
}
func (ArithmeticError_ArithmeticErrorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{4, 0}
}
type DynamicReferenceError_DynamicReferenceErrorType int32
const (
	DynamicReferenceError_UnknownDynamicReferenceError DynamicReferenceError_DynamicReferenceErrorType = 0
	DynamicReferenceError_MoveOfBorrowedResource       DynamicReferenceError_DynamicReferenceErrorType = 1
	DynamicReferenceError_GlobalRefAlreadyReleased     DynamicReferenceError_DynamicReferenceErrorType = 2
	DynamicReferenceError_MissingReleaseRef            DynamicReferenceError_DynamicReferenceErrorType = 3
	DynamicReferenceError_GlobalAlreadyBorrowed        DynamicReferenceError_DynamicReferenceErrorType = 4
)
var DynamicReferenceError_DynamicReferenceErrorType_name = map[int32]string{
	0: "UnknownDynamicReferenceError",
	1: "MoveOfBorrowedResource",
	2: "GlobalRefAlreadyReleased",
	3: "MissingReleaseRef",
	4: "GlobalAlreadyBorrowed",
}
var DynamicReferenceError_DynamicReferenceErrorType_value = map[string]int32{
	"UnknownDynamicReferenceError": 0,
	"MoveOfBorrowedResource":       1,
	"GlobalRefAlreadyReleased":     2,
	"MissingReleaseRef":            3,
	"GlobalAlreadyBorrowed":        4,
}
func (x DynamicReferenceError_DynamicReferenceErrorType) String() string {
	return proto.EnumName(DynamicReferenceError_DynamicReferenceErrorType_name, int32(x))
}
func (DynamicReferenceError_DynamicReferenceErrorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{5, 0}
}
type VMValidationStatus struct {
	Code                 VMValidationStatusCode `protobuf:"varint,1,opt,name=code,proto3,enum=types.VMValidationStatusCode" json:"code,omitempty"`
	Message              string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}
func (m *VMValidationStatus) Reset()         { *m = VMValidationStatus{} }
func (m *VMValidationStatus) String() string { return proto.CompactTextString(m) }
func (*VMValidationStatus) ProtoMessage()    {}
func (*VMValidationStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{0}
}
func (m *VMValidationStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VMValidationStatus.Unmarshal(m, b)
}
func (m *VMValidationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VMValidationStatus.Marshal(b, m, deterministic)
}
func (m *VMValidationStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VMValidationStatus.Merge(m, src)
}
func (m *VMValidationStatus) XXX_Size() int {
	return xxx_messageInfo_VMValidationStatus.Size(m)
}
func (m *VMValidationStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_VMValidationStatus.DiscardUnknown(m)
}
var xxx_messageInfo_VMValidationStatus proto.InternalMessageInfo
func (m *VMValidationStatus) GetCode() VMValidationStatusCode {
	if m != nil {
		return m.Code
	}
	return VMValidationStatusCode_UnknownValidationStatus
}
func (m *VMValidationStatus) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}
type VMVerificationStatusList struct {
	StatusList           []*VMVerificationStatus `protobuf:"bytes,1,rep,name=status_list,json=statusList,proto3" json:"status_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}
func (m *VMVerificationStatusList) Reset()         { *m = VMVerificationStatusList{} }
func (m *VMVerificationStatusList) String() string { return proto.CompactTextString(m) }
func (*VMVerificationStatusList) ProtoMessage()    {}
func (*VMVerificationStatusList) Descriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{1}
}
func (m *VMVerificationStatusList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VMVerificationStatusList.Unmarshal(m, b)
}
func (m *VMVerificationStatusList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VMVerificationStatusList.Marshal(b, m, deterministic)
}
func (m *VMVerificationStatusList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VMVerificationStatusList.Merge(m, src)
}
func (m *VMVerificationStatusList) XXX_Size() int {
	return xxx_messageInfo_VMVerificationStatusList.Size(m)
}
func (m *VMVerificationStatusList) XXX_DiscardUnknown() {
	xxx_messageInfo_VMVerificationStatusList.DiscardUnknown(m)
}
var xxx_messageInfo_VMVerificationStatusList proto.InternalMessageInfo
func (m *VMVerificationStatusList) GetStatusList() []*VMVerificationStatus {
	if m != nil {
		return m.StatusList
	}
	return nil
}
type VMVerificationStatus struct {
	StatusKind VMVerificationStatus_StatusKind `protobuf:"varint,1,opt,name=status_kind,json=statusKind,proto3,enum=types.VMVerificationStatus_StatusKind" json:"status_kind,omitempty"`
	ModuleIdx            uint32                  `protobuf:"varint,2,opt,name=module_idx,json=moduleIdx,proto3" json:"module_idx,omitempty"`
	ErrorKind            VMVerificationErrorKind `protobuf:"varint,3,opt,name=error_kind,json=errorKind,proto3,enum=types.VMVerificationErrorKind" json:"error_kind,omitempty"`
	Message              string                  `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}
func (m *VMVerificationStatus) Reset()         { *m = VMVerificationStatus{} }
func (m *VMVerificationStatus) String() string { return proto.CompactTextString(m) }
func (*VMVerificationStatus) ProtoMessage()    {}
func (*VMVerificationStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{2}
}
func (m *VMVerificationStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VMVerificationStatus.Unmarshal(m, b)
}
func (m *VMVerificationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VMVerificationStatus.Marshal(b, m, deterministic)
}
func (m *VMVerificationStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VMVerificationStatus.Merge(m, src)
}
func (m *VMVerificationStatus) XXX_Size() int {
	return xxx_messageInfo_VMVerificationStatus.Size(m)
}
func (m *VMVerificationStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_VMVerificationStatus.DiscardUnknown(m)
}
var xxx_messageInfo_VMVerificationStatus proto.InternalMessageInfo
func (m *VMVerificationStatus) GetStatusKind() VMVerificationStatus_StatusKind {
	if m != nil {
		return m.StatusKind
	}
	return VMVerificationStatus_SCRIPT
}
func (m *VMVerificationStatus) GetModuleIdx() uint32 {
	if m != nil {
		return m.ModuleIdx
	}
	return 0
}
func (m *VMVerificationStatus) GetErrorKind() VMVerificationErrorKind {
	if m != nil {
		return m.ErrorKind
	}
	return VMVerificationErrorKind_UnknownVerificationError
}
func (m *VMVerificationStatus) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}
type AssertionFailure struct {
	AssertionErrorCode   uint64   `protobuf:"varint,1,opt,name=assertion_error_code,json=assertionErrorCode,proto3" json:"assertion_error_code,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}
func (m *AssertionFailure) Reset()         { *m = AssertionFailure{} }
func (m *AssertionFailure) String() string { return proto.CompactTextString(m) }
func (*AssertionFailure) ProtoMessage()    {}
func (*AssertionFailure) Descriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{3}
}
func (m *AssertionFailure) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AssertionFailure.Unmarshal(m, b)
}
func (m *AssertionFailure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AssertionFailure.Marshal(b, m, deterministic)
}
func (m *AssertionFailure) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AssertionFailure.Merge(m, src)
}
func (m *AssertionFailure) XXX_Size() int {
	return xxx_messageInfo_AssertionFailure.Size(m)
}
func (m *AssertionFailure) XXX_DiscardUnknown() {
	xxx_messageInfo_AssertionFailure.DiscardUnknown(m)
}
var xxx_messageInfo_AssertionFailure proto.InternalMessageInfo
func (m *AssertionFailure) GetAssertionErrorCode() uint64 {
	if m != nil {
		return m.AssertionErrorCode
	}
	return 0
}
type ArithmeticError struct {
	ErrorCode            ArithmeticError_ArithmeticErrorType `protobuf:"varint,1,opt,name=error_code,json=errorCode,proto3,enum=types.ArithmeticError_ArithmeticErrorType" json:"error_code,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}
func (m *ArithmeticError) Reset()         { *m = ArithmeticError{} }
func (m *ArithmeticError) String() string { return proto.CompactTextString(m) }
func (*ArithmeticError) ProtoMessage()    {}
func (*ArithmeticError) Descriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{4}
}
func (m *ArithmeticError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ArithmeticError.Unmarshal(m, b)
}
func (m *ArithmeticError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ArithmeticError.Marshal(b, m, deterministic)
}
func (m *ArithmeticError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ArithmeticError.Merge(m, src)
}
func (m *ArithmeticError) XXX_Size() int {
	return xxx_messageInfo_ArithmeticError.Size(m)
}
func (m *ArithmeticError) XXX_DiscardUnknown() {
	xxx_messageInfo_ArithmeticError.DiscardUnknown(m)
}
var xxx_messageInfo_ArithmeticError proto.InternalMessageInfo
func (m *ArithmeticError) GetErrorCode() ArithmeticError_ArithmeticErrorType {
	if m != nil {
		return m.ErrorCode
	}
	return ArithmeticError_UnknownArithmeticError
}
type DynamicReferenceError struct {
	ErrorCode            DynamicReferenceError_DynamicReferenceErrorType `protobuf:"varint,1,opt,name=error_code,json=errorCode,proto3,enum=types.DynamicReferenceError_DynamicReferenceErrorType" json:"error_code,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                        `json:"-"`
	XXX_unrecognized     []byte                                          `json:"-"`
	XXX_sizecache        int32                                           `json:"-"`
}
func (m *DynamicReferenceError) Reset()         { *m = DynamicReferenceError{} }
func (m *DynamicReferenceError) String() string { return proto.CompactTextString(m) }
func (*DynamicReferenceError) ProtoMessage()    {}
func (*DynamicReferenceError) Descriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{5}
}
func (m *DynamicReferenceError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DynamicReferenceError.Unmarshal(m, b)
}
func (m *DynamicReferenceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DynamicReferenceError.Marshal(b, m, deterministic)
}
func (m *DynamicReferenceError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DynamicReferenceError.Merge(m, src)
}
func (m *DynamicReferenceError) XXX_Size() int {
	return xxx_messageInfo_DynamicReferenceError.Size(m)
}
func (m *DynamicReferenceError) XXX_DiscardUnknown() {
	xxx_messageInfo_DynamicReferenceError.DiscardUnknown(m)
}
var xxx_messageInfo_DynamicReferenceError proto.InternalMessageInfo
func (m *DynamicReferenceError) GetErrorCode() DynamicReferenceError_DynamicReferenceErrorType {
	if m != nil {
		return m.ErrorCode
	}
	return DynamicReferenceError_UnknownDynamicReferenceError
}
type ExecutionStatus struct {
	ExecutionStatus      isExecutionStatus_ExecutionStatus `protobuf_oneof:"execution_status"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}
func (m *ExecutionStatus) Reset()         { *m = ExecutionStatus{} }
func (m *ExecutionStatus) String() string { return proto.CompactTextString(m) }
func (*ExecutionStatus) ProtoMessage()    {}
func (*ExecutionStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_5824ced5fb3a3c2c, []int{6}
}
func (m *ExecutionStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecutionStatus.Unmarshal(m, b)
}
func (m *ExecutionStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecutionStatus.Marshal(b, m, deterministic)
}
func (m *ExecutionStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecutionStatus.Merge(m, src)
}
func (m *ExecutionStatus) XXX_Size() int {
	return xxx_messageInfo_ExecutionStatus.Size(m)
}
func (m *ExecutionStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecutionStatus.DiscardUnknown(m)
}
var xxx_messageInfo_ExecutionStatus proto.InternalMessageInfo
type isExecutionStatus_ExecutionStatus interface {
	isExecutionStatus_ExecutionStatus()
}
type ExecutionStatus_RuntimeStatus struct {
	RuntimeStatus RuntimeStatus `protobuf:"varint,1,opt,name=runtime_status,json=runtimeStatus,proto3,enum=types.RuntimeStatus,oneof"`
}
type ExecutionStatus_AssertionFailure struct {
	AssertionFailure *AssertionFailure `protobuf:"bytes,2,opt,name=assertion_failure,json=assertionFailure,proto3,oneof"`
}
type ExecutionStatus_ArithmeticError struct {
	ArithmeticError *ArithmeticError `protobuf:"bytes,3,opt,name=arithmetic_error,json=arithmeticError,proto3,oneof"`
}
type ExecutionStatus_ReferenceError struct {
	ReferenceError *DynamicReferenceError `protobuf:"bytes,4,opt,name=reference_error,json=referenceError,proto3,oneof"`
}
func (*ExecutionStatus_RuntimeStatus) isExecutionStatus_ExecutionStatus() {}
func (*ExecutionStatus_AssertionFailure) isExecutionStatus_ExecutionStatus() {}
func (*ExecutionStatus_ArithmeticError) isExecutionStatus_ExecutionStatus() {}
func (*ExecutionStatus_ReferenceError) isExecutionStatus_ExecutionStatus() {}
func (m *ExecutionStatus) GetExecutionStatus() isExecutionStatus_ExecutionStatus {
	if m != nil {
		return m.ExecutionStatus
	}
	return nil
}
func (m *ExecutionStatus) GetRuntimeStatus() RuntimeStatus {
	if x, ok := m.GetExecutionStatus().(*ExecutionStatus_RuntimeStatus); ok {
		return x.RuntimeStatus
	}
	return RuntimeStatus_UnknownRuntimeStatus
}
func (m *ExecutionStatus) GetAssertionFailure() *AssertionFailure {
	if x, ok := m.GetExecutionStatus().(*ExecutionStatus_AssertionFailure); ok {
		return x.AssertionFailure
	}
	return nil
}
func (m *ExecutionStatus) GetArithmeticError() *ArithmeticError {
	if x, ok := m.GetExecutionStatus().(*ExecutionStatus_ArithmeticError); ok {
		return x.ArithmeticError
	}
	return nil
}
func (m *ExecutionStatus) GetReferenceError() *DynamicReferenceError {
	if x, ok := m.GetExecutionStatus().(*ExecutionStatus_ReferenceError); ok {
		return x.ReferenceError
	}
	return nil
}