github.com/matrixorigin/matrixone@v0.7.0/pkg/pb/txn/txn.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: txn.proto

package txn

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	metadata "github.com/matrixorigin/matrixone/pkg/pb/metadata"
	timestamp "github.com/matrixorigin/matrixone/pkg/pb/timestamp"
)

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

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

// TxnStatus transaction status
type TxnStatus int32

const (
	// Active is the state of transaction creation, in this state, can execute the
	// transaction Read/Write/Commit/Rollback.
	TxnStatus_Active TxnStatus = 0
	// Prepared for distributed transactions across DNs, a 2pc commit is performed,
	// and the prepared status means that the transaction on a DN was executed
	// successfully in the first phase.
	//
	// Note that this status needs to be saved to the LogService. Once the first
	// phase of a transaction is successful, data cannot be lost.
	TxnStatus_Prepared TxnStatus = 1
	// Committing for distributed transactions across DNs, once all DNs have completed
	// the first phase, the transaction enters the Committing state and initiates an
	// asynchronous process to handle the commit of temporary data.
	//
	// Note that when all DNs involved are in the prepared state, the distributed
	// transaction can be considered committed because all data has been written
	// successfully. The subsequent Committing process just explicitly converts these
	// writes into committed data.
	//
	// Note that the state exists only in memory and is not persisted to the LogService.
	// It can be restored through the Prepared state, if all(DN).Status == Prepared.
	TxnStatus_Committing TxnStatus = 2
	// Committed after the Committing phase has transformed all DN data involved into
	// committed data, the status of the distributed transaction is explicitly recorded
	// as Committed.
	//
	// Note that this status needs to be saved to the LogService
	TxnStatus_Committed TxnStatus = 3
	// Aborting a client initiating a Rollback call or a distributed transaction that has
	// any error in the first phase will enter the Aborting state. This state starts an
	// asynchronous task to clean up the temporary data written by the transaction.
	//
	// Note that the state exists only in memory and is not persisted to the LogService.
	// It can be restored through the Prepared state, if Any(DN).Status != Prepared.
	TxnStatus_Aborting TxnStatus = 4
	// Aborted after the Aborting phase, all data involved in the DN is cleaned up and
	// the transaction status is explicitly recorded as Aborted.
	//
	// Note that this status needs to be saved to the LogService
	TxnStatus_Aborted TxnStatus = 5
)

var TxnStatus_name = map[int32]string{
	0: "Active",
	1: "Prepared",
	2: "Committing",
	3: "Committed",
	4: "Aborting",
	5: "Aborted",
}

var TxnStatus_value = map[string]int32{
	"Active":     0,
	"Prepared":   1,
	"Committing": 2,
	"Committed":  3,
	"Aborting":   4,
	"Aborted":    5,
}

func (x TxnStatus) String() string {
	return proto.EnumName(TxnStatus_name, int32(x))
}

func (TxnStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4f782e76b37adb9a, []int{0}
}

// TxnMethod transaction operations
type TxnMethod int32

const (
	// Read transaction read
	TxnMethod_Read TxnMethod = 0
	// Write transaction write
	TxnMethod_Write TxnMethod = 1
	// Commit commit transaction
	TxnMethod_Commit TxnMethod = 2
	// Rollback rollback transaction
	TxnMethod_Rollback TxnMethod = 3
	// Prepare when DN(Coordinator) receives a commit request from CN, it sends a prepare to
	// each DN(DNShard)
	TxnMethod_Prepare TxnMethod = 4
	// GetStatus query the status of a transaction on a DN. When a DN encounters a transaction
	// in the Prepared state, it needs to go to the DN(Coordinator) to query the status of the
	// current transaction. When a DN encounters a transaction in the Prepared state during the
	// recover, it needs to query the status of the transaction on each DN(DNShard) to determine
	// if the transaction is committed.
	TxnMethod_GetStatus TxnMethod = 5
	// CommitDNShard after the 2pc transaction is committed, the temporary data on each DN needs
	// to be explicitly converted to committed data.
	TxnMethod_CommitDNShard TxnMethod = 6
	// RollbackDNShard after the 2pc transaction is aborted, the temporary data on each DN needs
	// to cleanup.
	TxnMethod_RollbackDNShard TxnMethod = 7
	// RemoveMedata Remove metadata for transactions on DNShard. For a 2pc distributed transaction,
	// after all participating DNShards have Prepared successfully, the asynchronous commit process
	// starts, sending CommitDNShard requests to all participating DNShards in parallel. After each
	// DNShard has processed the CommitDNShard, the metadata of the transaction cannot be deleted
	// immediately, otherwise when the transaction coordinator node is down and restarted, the commit
	// status of the transaction cannot be determined in the recovery process, as it is possible that
	// some participating DNShards cannot find the transaction information.
	//
	// TODO: needs to work with TAE's log compaction, not currently supported.
	TxnMethod_RemoveMedata TxnMethod = 8
	// DEBUG used to send debug request from cn to dn, and received response from dn to cn
	TxnMethod_DEBUG TxnMethod = 9
)

var TxnMethod_name = map[int32]string{
	0: "Read",
	1: "Write",
	2: "Commit",
	3: "Rollback",
	4: "Prepare",
	5: "GetStatus",
	6: "CommitDNShard",
	7: "RollbackDNShard",
	8: "RemoveMedata",
	9: "DEBUG",
}

var TxnMethod_value = map[string]int32{
	"Read":            0,
	"Write":           1,
	"Commit":          2,
	"Rollback":        3,
	"Prepare":         4,
	"GetStatus":       5,
	"CommitDNShard":   6,
	"RollbackDNShard": 7,
	"RemoveMedata":    8,
	"DEBUG":           9,
}

func (x TxnMethod) String() string {
	return proto.EnumName(TxnMethod_name, int32(x))
}

func (TxnMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4f782e76b37adb9a, []int{1}
}

// TxnMeta transaction metadata
type TxnMeta struct {
	// ID transaction id, generated at the CN node at the time of transaction creation,
	// globally unique.
	ID []byte `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	// Status transaction status
	Status TxnStatus `protobuf:"varint,2,opt,name=Status,proto3,enum=txn.TxnStatus" json:"Status,omitempty"`
	// SnapshotTS transaction read timestamp, generated at the CN node at the time of
	// transaction creation. All data.TS < txn.SnapshotTS is visible for the current
	// transaction.
	SnapshotTS timestamp.Timestamp `protobuf:"bytes,3,opt,name=SnapshotTS,proto3" json:"SnapshotTS"`
	// PreparedTS timestamp to complete the first phase of a 2pc commit transaction.
	PreparedTS timestamp.Timestamp `protobuf:"bytes,4,opt,name=PreparedTS,proto3" json:"PreparedTS"`
	// CommitTS transaction commit timestamp. For a 2pc transaction, commitTS = max(preparedTS).
	CommitTS timestamp.Timestamp `protobuf:"bytes,5,opt,name=CommitTS,proto3" json:"CommitTS"`
	// DNShards all DNShards that have written data. The first DN is the coordinator of the
	// transaction
	DNShards             []metadata.DNShard `protobuf:"bytes,6,rep,name=DNShards,proto3" json:"DNShards"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_TxnMeta proto.InternalMessageInfo

func (m *TxnMeta) GetID() []byte {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *TxnMeta) GetStatus() TxnStatus {
	if m != nil {
		return m.Status
	}
	return TxnStatus_Active
}

func (m *TxnMeta) GetSnapshotTS() timestamp.Timestamp {
	if m != nil {
		return m.SnapshotTS
	}
	return timestamp.Timestamp{}
}

func (m *TxnMeta) GetPreparedTS() timestamp.Timestamp {
	if m != nil {
		return m.PreparedTS
	}
	return timestamp.Timestamp{}
}

func (m *TxnMeta) GetCommitTS() timestamp.Timestamp {
	if m != nil {
		return m.CommitTS
	}
	return timestamp.Timestamp{}
}

func (m *TxnMeta) GetDNShards() []metadata.DNShard {
	if m != nil {
		return m.DNShards
	}
	return nil
}

// CNTxnSnapshot snapshot of the cn txn operation.
type CNTxnSnapshot struct {
	// ID txn id
	Txn TxnMeta `protobuf:"bytes,1,opt,name=Txn,proto3" json:"Txn"`
	// ReadyOnly txn options
	ReadyOnly bool `protobuf:"varint,2,opt,name=ReadyOnly,proto3" json:"ReadyOnly,omitempty"`
	// EnableCacheWrite txn options
	EnableCacheWrite bool `protobuf:"varint,3,opt,name=EnableCacheWrite,proto3" json:"EnableCacheWrite,omitempty"`
	// Disable1PCOpt txn options
	Disable1PCOpt        bool     `protobuf:"varint,4,opt,name=Disable1PCOpt,proto3" json:"Disable1PCOpt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CNTxnSnapshot proto.InternalMessageInfo

func (m *CNTxnSnapshot) GetTxn() TxnMeta {
	if m != nil {
		return m.Txn
	}
	return TxnMeta{}
}

func (m *CNTxnSnapshot) GetReadyOnly() bool {
	if m != nil {
		return m.ReadyOnly
	}
	return false
}

func (m *CNTxnSnapshot) GetEnableCacheWrite() bool {
	if m != nil {
		return m.EnableCacheWrite
	}
	return false
}

func (m *CNTxnSnapshot) GetDisable1PCOpt() bool {
	if m != nil {
		return m.Disable1PCOpt
	}
	return false
}

// CNOpRequest cn read/write request, CN -> DN. If data is written to more than one DN (>1) in a
// single transaction, then the transaction becomes a 2pc transaction.
type CNOpRequest struct {
	// OpCode request operation type
	OpCode uint32 `protobuf:"varint,1,opt,name=OpCode,proto3" json:"OpCode,omitempty"`
	// Payload the content of the request, TxnClient does not perceive the exact
	// format and content
	Payload []byte `protobuf:"bytes,2,opt,name=Payload,proto3" json:"Payload,omitempty"`
	// Target target to which the request was sent
	Target               metadata.DNShard `protobuf:"bytes,3,opt,name=Target,proto3" json:"Target"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_CNOpRequest proto.InternalMessageInfo

func (m *CNOpRequest) GetOpCode() uint32 {
	if m != nil {
		return m.OpCode
	}
	return 0
}

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

func (m *CNOpRequest) GetTarget() metadata.DNShard {
	if m != nil {
		return m.Target
	}
	return metadata.DNShard{}
}

// CNOpResponse cn read/write response, DN -> CN. A request corresponds to a response.
type CNOpResponse struct {
	// Payload response payload
	Payload              []byte   `protobuf:"bytes,1,opt,name=Payload,proto3" json:"Payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CNOpResponse proto.InternalMessageInfo

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

// TxnRequest transaction request. All requests for the transaction are made using TxnRequest, so that
// the codec and logical processing of the RPC can be unified. Specific requests are selected according
// to TxnMethod.
//
// Request flow of TxnRequest as below:
//  1. CN -> DN (TxnMethod.Read, TxnMethod.Write, TxnMethod.Commit, TxnMethod.Rollback)
//  2. DN -> DN (TxnMethod.Prepare, TxnMethod.GetStatus, TxnMethod.CommitDNShard, TxnMethod.RollbackDNShard,
//     TxnMethod.RemoveMetadata)
type TxnRequest struct {
	// RequestID request id
	RequestID uint64 `protobuf:"varint,1,opt,name=RequestID,proto3" json:"RequestID,omitempty"`
	// Txn transaction metadata
	Txn TxnMeta `protobuf:"bytes,2,opt,name=Txn,proto3" json:"Txn"`
	// TxnMethod TxnRequest opCode, select the Request defined below according to TxnMethod.
	Method TxnMethod `protobuf:"varint,3,opt,name=Method,proto3,enum=txn.TxnMethod" json:"Method,omitempty"`
	// Flag request flag
	Flag uint32 `protobuf:"varint,4,opt,name=Flag,proto3" json:"Flag,omitempty"`
	// CNOpRequest corresponds to TxnMethod.Read, TxnMethod.Write
	CNRequest *CNOpRequest `protobuf:"bytes,5,opt,name=CNRequest,proto3" json:"CNRequest,omitempty"`
	// TxnCommitRequest corresponds to TxnMethod.Commit
	CommitRequest *TxnCommitRequest `protobuf:"bytes,6,opt,name=CommitRequest,proto3" json:"CommitRequest,omitempty"`
	// TxnRollbackRequest corresponds to TxnMethod.Rollback
	RollbackRequest *TxnRollbackRequest `protobuf:"bytes,7,opt,name=RollbackRequest,proto3" json:"RollbackRequest,omitempty"`
	// TxnPrepareRequest corresponds to TxnMethod.Prepare
	PrepareRequest *TxnPrepareRequest `protobuf:"bytes,8,opt,name=PrepareRequest,proto3" json:"PrepareRequest,omitempty"`
	// TxnGetStatusRequest corresponds to TxnMethod.GetStatus
	GetStatusRequest *TxnGetStatusRequest `protobuf:"bytes,9,opt,name=GetStatusRequest,proto3" json:"GetStatusRequest,omitempty"`
	// TxnCommitDNShardRequest corresponds to TxnMethod.CommitDNShard
	CommitDNShardRequest *TxnCommitDNShardRequest `protobuf:"bytes,10,opt,name=CommitDNShardRequest,proto3" json:"CommitDNShardRequest,omitempty"`
	// TxnRollbackDNShardRequest corresponds to TxnMethod.RollbackDNShard
	RollbackDNShardRequest *TxnRollbackDNShardRequest `protobuf:"bytes,11,opt,name=RollbackDNShardRequest,proto3" json:"RollbackDNShardRequest,omitempty"`
	// TxnRemoveMetadataRequest  corresponds to TxnMethod.RemoveMetadata
	RemoveMetadata *TxnRemoveMetadataRequest `protobuf:"bytes,12,opt,name=RemoveMetadata,proto3" json:"RemoveMetadata,omitempty"`
	// TxnRequestOptions request options
	Options              *TxnRequestOptions `protobuf:"bytes,13,opt,name=Options,proto3" json:"Options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_TxnRequest proto.InternalMessageInfo

func (m *TxnRequest) GetRequestID() uint64 {
	if m != nil {
		return m.RequestID
	}
	return 0
}

func (m *TxnRequest) GetTxn() TxnMeta {
	if m != nil {
		return m.Txn
	}
	return TxnMeta{}
}

func (m *TxnRequest) GetMethod() TxnMethod {
	if m != nil {
		return m.Method
	}
	return TxnMethod_Read
}

func (m *TxnRequest) GetFlag() uint32 {
	if m != nil {
		return m.Flag
	}
	return 0
}

func (m *TxnRequest) GetCNRequest() *CNOpRequest {
	if m != nil {
		return m.CNRequest
	}
	return nil
}

func (m *TxnRequest) GetCommitRequest() *TxnCommitRequest {
	if m != nil {
		return m.CommitRequest
	}
	return nil
}

func (m *TxnRequest) GetRollbackRequest() *TxnRollbackRequest {
	if m != nil {
		return m.RollbackRequest
	}
	return nil
}

func (m *TxnRequest) GetPrepareRequest() *TxnPrepareRequest {
	if m != nil {
		return m.PrepareRequest
	}
	return nil
}

func (m *TxnRequest) GetGetStatusRequest() *TxnGetStatusRequest {
	if m != nil {
		return m.GetStatusRequest
	}
	return nil
}

func (m *TxnRequest) GetCommitDNShardRequest() *TxnCommitDNShardRequest {
	if m != nil {
		return m.CommitDNShardRequest
	}
	return nil
}

func (m *TxnRequest) GetRollbackDNShardRequest() *TxnRollbackDNShardRequest {
	if m != nil {
		return m.RollbackDNShardRequest
	}
	return nil
}

func (m *TxnRequest) GetRemoveMetadata() *TxnRemoveMetadataRequest {
	if m != nil {
		return m.RemoveMetadata
	}
	return nil
}

func (m *TxnRequest) GetOptions() *TxnRequestOptions {
	if m != nil {
		return m.Options
	}
	return nil
}

// TxnRequestOptions txn options
type TxnRequestOptions struct {
	// RetryCodes when DN processes TxnRequest and encounters the specified error, it needs to retry
	// on the server side. Only read and write can retry.
	RetryCodes []int32 `protobuf:"varint,1,rep,packed,name=RetryCodes,proto3" json:"RetryCodes,omitempty"`
	// RetryInterval retry interval, default is 100ms.
	RetryInterval        int64    `protobuf:"varint,2,opt,name=RetryInterval,proto3" json:"RetryInterval,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnRequestOptions proto.InternalMessageInfo

func (m *TxnRequestOptions) GetRetryCodes() []int32 {
	if m != nil {
		return m.RetryCodes
	}
	return nil
}

func (m *TxnRequestOptions) GetRetryInterval() int64 {
	if m != nil {
		return m.RetryInterval
	}
	return 0
}

// TxnResponse response of TxnRequest.
type TxnResponse struct {
	// RequestID corresponding request id
	RequestID uint64 `protobuf:"varint,1,opt,name=RequestID,proto3" json:"RequestID,omitempty"`
	// Txn transaction metadata. TxnResponse.TxnMeta and TxnRequest.TxnMeta may differ
	// in that the node initiating the TxnRequest needs to process the returned TxnMeta,
	// e.g. to determine whether the transaction is Aborted by the status of the returned
	// TxnMeta.
	Txn *TxnMeta `protobuf:"bytes,2,opt,name=Txn,proto3" json:"Txn,omitempty"`
	// TxnMethod same as TxnRequest.TxnMethod
	Method TxnMethod `protobuf:"varint,3,opt,name=Method,proto3,enum=txn.TxnMethod" json:"Method,omitempty"`
	// Flag request flag, same as the corresponding request
	Flag uint32 `protobuf:"varint,4,opt,name=Flag,proto3" json:"Flag,omitempty"`
	// TxnError explicit error
	TxnError *TxnError `protobuf:"bytes,5,opt,name=TxnError,proto3" json:"TxnError,omitempty"`
	// CNOpResponse corresponds to TxnMethod.Read, TxnMethod.Write response
	CNOpResponse *CNOpResponse `protobuf:"bytes,6,opt,name=CNOpResponse,proto3" json:"CNOpResponse,omitempty"`
	// TxnCommitResponse corresponds to TxnMethod.Commit response
	CommitResponse *TxnCommitResponse `protobuf:"bytes,7,opt,name=CommitResponse,proto3" json:"CommitResponse,omitempty"`
	// TxnRollbackResponse corresponds to TxnMethod.Rollback response
	RollbackResponse *TxnRollbackResponse `protobuf:"bytes,8,opt,name=RollbackResponse,proto3" json:"RollbackResponse,omitempty"`
	// TxnPrepareResponse corresponds to TxnMethod.Prepare response
	PrepareResponse *TxnPrepareResponse `protobuf:"bytes,9,opt,name=PrepareResponse,proto3" json:"PrepareResponse,omitempty"`
	// TxnGetStatusResponse corresponds to TxnMethod.GetStatus response
	GetStatusResponse *TxnGetStatusResponse `protobuf:"bytes,10,opt,name=GetStatusResponse,proto3" json:"GetStatusResponse,omitempty"`
	// TxnCommitDNShardResponse corresponds to TxnMethod.CommitDNShard response
	CommitDNShardResponse *TxnCommitDNShardResponse `protobuf:"bytes,11,opt,name=CommitDNShardResponse,proto3" json:"CommitDNShardResponse,omitempty"`
	// TxnRollbackDNShardResponse corresponds to TxnMethod.RollbackDNShard response
	RollbackDNShardResponse *TxnRollbackDNShardResponse `protobuf:"bytes,12,opt,name=RollbackDNShardResponse,proto3" json:"RollbackDNShardResponse,omitempty"`
	// TxnRemoveMetadataResponse  corresponds to TxnMethod.RemoveMetadata
	RemoveMetadata       *TxnRemoveMetadataResponse `protobuf:"bytes,13,opt,name=RemoveMetadata,proto3" json:"RemoveMetadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

var xxx_messageInfo_TxnResponse proto.InternalMessageInfo

func (m *TxnResponse) GetRequestID() uint64 {
	if m != nil {
		return m.RequestID
	}
	return 0
}

func (m *TxnResponse) GetTxn() *TxnMeta {
	if m != nil {
		return m.Txn
	}
	return nil
}

func (m *TxnResponse) GetMethod() TxnMethod {
	if m != nil {
		return m.Method
	}
	return TxnMethod_Read
}

func (m *TxnResponse) GetFlag() uint32 {
	if m != nil {
		return m.Flag
	}
	return 0
}

func (m *TxnResponse) GetTxnError() *TxnError {
	if m != nil {
		return m.TxnError
	}
	return nil
}

func (m *TxnResponse) GetCNOpResponse() *CNOpResponse {
	if m != nil {
		return m.CNOpResponse
	}
	return nil
}

func (m *TxnResponse) GetCommitResponse() *TxnCommitResponse {
	if m != nil {
		return m.CommitResponse
	}
	return nil
}

func (m *TxnResponse) GetRollbackResponse() *TxnRollbackResponse {
	if m != nil {
		return m.RollbackResponse
	}
	return nil
}

func (m *TxnResponse) GetPrepareResponse() *TxnPrepareResponse {
	if m != nil {
		return m.PrepareResponse
	}
	return nil
}

func (m *TxnResponse) GetGetStatusResponse() *TxnGetStatusResponse {
	if m != nil {
		return m.GetStatusResponse
	}
	return nil
}

func (m *TxnResponse) GetCommitDNShardResponse() *TxnCommitDNShardResponse {
	if m != nil {
		return m.CommitDNShardResponse
	}
	return nil
}

func (m *TxnResponse) GetRollbackDNShardResponse() *TxnRollbackDNShardResponse {
	if m != nil {
		return m.RollbackDNShardResponse
	}
	return nil
}

func (m *TxnResponse) GetRemoveMetadata() *TxnRemoveMetadataResponse {
	if m != nil {
		return m.RemoveMetadata
	}
	return nil
}

// TxnCommitRequest CN sent the commit request to coordinator DN.
type TxnCommitRequest struct {
	Disable1PCOpt        bool     `protobuf:"varint,2,opt,name=Disable1PCOpt,proto3" json:"Disable1PCOpt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnCommitRequest proto.InternalMessageInfo

func (m *TxnCommitRequest) GetDisable1PCOpt() bool {
	if m != nil {
		return m.Disable1PCOpt
	}
	return false
}

// TxnCommitResponse response of TxnCommitRequest.
type TxnCommitResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnCommitResponse proto.InternalMessageInfo

// TxnCommitRequest CN sent the rollback request to coordinator DN.
type TxnRollbackRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnRollbackRequest proto.InternalMessageInfo

// TxnRollbackResponse response of TxnRollbackRequest.
type TxnRollbackResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnRollbackResponse proto.InternalMessageInfo

// TxnPrepareRequest when a DN(coordinator) receives a Commit request from a CN, if
// more than one DN is involved, the 2PC commit process is enabled and the first phase
// is to send prepare requests to all DNs.
type TxnPrepareRequest struct {
	// DNShard prepare DN
	DNShard              metadata.DNShard `protobuf:"bytes,1,opt,name=DNShard,proto3" json:"DNShard"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TxnPrepareRequest proto.InternalMessageInfo

func (m *TxnPrepareRequest) GetDNShard() metadata.DNShard {
	if m != nil {
		return m.DNShard
	}
	return metadata.DNShard{}
}

// TxnPrepareResponse response of TxnPrepareRequest
type TxnPrepareResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnPrepareResponse proto.InternalMessageInfo

// TxnGetStatusRequest query the status of a transaction on DN
type TxnGetStatusRequest struct {
	// DNShard target DN
	DNShard              metadata.DNShard `protobuf:"bytes,1,opt,name=DNShard,proto3" json:"DNShard"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TxnGetStatusRequest proto.InternalMessageInfo

func (m *TxnGetStatusRequest) GetDNShard() metadata.DNShard {
	if m != nil {
		return m.DNShard
	}
	return metadata.DNShard{}
}

// TxnGetStatusResponse response of TxnGetStatusRequest
type TxnGetStatusResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnGetStatusResponse proto.InternalMessageInfo

// TxnCommitDNShardRequest commit txn on DNShard. Data needs to be written to the
// LogService.
type TxnCommitDNShardRequest struct {
	// DNShard target DN
	DNShard              metadata.DNShard `protobuf:"bytes,1,opt,name=DNShard,proto3" json:"DNShard"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TxnCommitDNShardRequest proto.InternalMessageInfo

func (m *TxnCommitDNShardRequest) GetDNShard() metadata.DNShard {
	if m != nil {
		return m.DNShard
	}
	return metadata.DNShard{}
}

// TxnCommitDNShardResponse response of TxnCommitDNShardRequest
type TxnCommitDNShardResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnCommitDNShardResponse proto.InternalMessageInfo

// TxnRollbackDNShardRequest rollback txn on DNShard
type TxnRollbackDNShardRequest struct {
	// DNShard target DN
	DNShard              metadata.DNShard `protobuf:"bytes,1,opt,name=DNShard,proto3" json:"DNShard"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TxnRollbackDNShardRequest proto.InternalMessageInfo

func (m *TxnRollbackDNShardRequest) GetDNShard() metadata.DNShard {
	if m != nil {
		return m.DNShard
	}
	return metadata.DNShard{}
}

// TxnRollbackDNShardResponse response of TxnRollbackDNShardRequest
type TxnRollbackDNShardResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnRollbackDNShardResponse proto.InternalMessageInfo

// TxnRemoveMetadataRequest remove txn metadata on DNShard
type TxnRemoveMetadataRequest struct {
	// DNShard target DN
	DNShard              metadata.DNShard `protobuf:"bytes,1,opt,name=DNShard,proto3" json:"DNShard"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TxnRemoveMetadataRequest proto.InternalMessageInfo

func (m *TxnRemoveMetadataRequest) GetDNShard() metadata.DNShard {
	if m != nil {
		return m.DNShard
	}
	return metadata.DNShard{}
}

// TxnRemoveMetadataResponse response of TxnRemoveMetadataRequest
type TxnRemoveMetadataResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnRemoveMetadataResponse proto.InternalMessageInfo

// TxnError all explicit errors in transaction operations.
type TxnError struct {
	// Code moerr code, used to special error handle without unmarshal moerr
	Code uint32 `protobuf:"varint,1,opt,name=Code,proto3" json:"Code,omitempty"`
	// Error we use this field to send moerr from dn to cn. Set with
	// moerr.MarshalBinary, and use moerr.UnmarshalBinary to restore
	// moerr.
	Error []byte `protobuf:"bytes,2,opt,name=Error,proto3" json:"Error,omitempty"`
	// TxnErrCode is a internal err code in the txn framework and used to indicate
	// what transaction operation failed. Usually this value is the same as the value
	// of Code, except for the error returned by the interface call to TxnStorage.
	// Because the types of errors returned by TxnStorage's interface are unknown to the
	// transaction framework, it is necessary to use a code for the interface call to uniformly
	// replace these error codes.
	TxnErrCode           uint32   `protobuf:"varint,3,opt,name=TxnErrCode,proto3" json:"TxnErrCode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnError proto.InternalMessageInfo

func (m *TxnError) GetCode() uint32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *TxnError) GetError() []byte {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *TxnError) GetTxnErrCode() uint32 {
	if m != nil {
		return m.TxnErrCode
	}
	return 0
}

func init() {
	proto.RegisterEnum("txn.TxnStatus", TxnStatus_name, TxnStatus_value)
	proto.RegisterEnum("txn.TxnMethod", TxnMethod_name, TxnMethod_value)
	proto.RegisterType((*TxnMeta)(nil), "txn.TxnMeta")
	proto.RegisterType((*CNTxnSnapshot)(nil), "txn.CNTxnSnapshot")
	proto.RegisterType((*CNOpRequest)(nil), "txn.CNOpRequest")
	proto.RegisterType((*CNOpResponse)(nil), "txn.CNOpResponse")
	proto.RegisterType((*TxnRequest)(nil), "txn.TxnRequest")
	proto.RegisterType((*TxnRequestOptions)(nil), "txn.TxnRequestOptions")
	proto.RegisterType((*TxnResponse)(nil), "txn.TxnResponse")
	proto.RegisterType((*TxnCommitRequest)(nil), "txn.TxnCommitRequest")
	proto.RegisterType((*TxnCommitResponse)(nil), "txn.TxnCommitResponse")
	proto.RegisterType((*TxnRollbackRequest)(nil), "txn.TxnRollbackRequest")
	proto.RegisterType((*TxnRollbackResponse)(nil), "txn.TxnRollbackResponse")
	proto.RegisterType((*TxnPrepareRequest)(nil), "txn.TxnPrepareRequest")
	proto.RegisterType((*TxnPrepareResponse)(nil), "txn.TxnPrepareResponse")
	proto.RegisterType((*TxnGetStatusRequest)(nil), "txn.TxnGetStatusRequest")
	proto.RegisterType((*TxnGetStatusResponse)(nil), "txn.TxnGetStatusResponse")
	proto.RegisterType((*TxnCommitDNShardRequest)(nil), "txn.TxnCommitDNShardRequest")
	proto.RegisterType((*TxnCommitDNShardResponse)(nil), "txn.TxnCommitDNShardResponse")
	proto.RegisterType((*TxnRollbackDNShardRequest)(nil), "txn.TxnRollbackDNShardRequest")
	proto.RegisterType((*TxnRollbackDNShardResponse)(nil), "txn.TxnRollbackDNShardResponse")
	proto.RegisterType((*TxnRemoveMetadataRequest)(nil), "txn.TxnRemoveMetadataRequest")
	proto.RegisterType((*TxnRemoveMetadataResponse)(nil), "txn.TxnRemoveMetadataResponse")
	proto.RegisterType((*TxnError)(nil), "txn.TxnError")
}

func init() { proto.RegisterFile("txn.proto", fileDescriptor_4f782e76b37adb9a) }

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

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

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

func (m *TxnMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.DNShards) > 0 {
		for iNdEx := len(m.DNShards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DNShards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTxn(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	{
		size, err := m.CommitTS.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.PreparedTS.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.SnapshotTS.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.Status != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintTxn(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CNTxnSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Disable1PCOpt {
		i--
		if m.Disable1PCOpt {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.EnableCacheWrite {
		i--
		if m.EnableCacheWrite {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.ReadyOnly {
		i--
		if m.ReadyOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Txn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *CNOpRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Target.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintTxn(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x12
	}
	if m.OpCode != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.OpCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CNOpResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintTxn(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Options != nil {
		{
			size, err := m.Options.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if m.RemoveMetadata != nil {
		{
			size, err := m.RemoveMetadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.RollbackDNShardRequest != nil {
		{
			size, err := m.RollbackDNShardRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.CommitDNShardRequest != nil {
		{
			size, err := m.CommitDNShardRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.GetStatusRequest != nil {
		{
			size, err := m.GetStatusRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.PrepareRequest != nil {
		{
			size, err := m.PrepareRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.RollbackRequest != nil {
		{
			size, err := m.RollbackRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.CommitRequest != nil {
		{
			size, err := m.CommitRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.CNRequest != nil {
		{
			size, err := m.CNRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Flag != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.Flag))
		i--
		dAtA[i] = 0x20
	}
	if m.Method != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.Method))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.Txn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.RequestID != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.RequestID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnRequestOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RetryInterval != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.RetryInterval))
		i--
		dAtA[i] = 0x10
	}
	if len(m.RetryCodes) > 0 {
		dAtA17 := make([]byte, len(m.RetryCodes)*10)
		var j16 int
		for _, num1 := range m.RetryCodes {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA17[j16] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j16++
			}
			dAtA17[j16] = uint8(num)
			j16++
		}
		i -= j16
		copy(dAtA[i:], dAtA17[:j16])
		i = encodeVarintTxn(dAtA, i, uint64(j16))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RemoveMetadata != nil {
		{
			size, err := m.RemoveMetadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if m.RollbackDNShardResponse != nil {
		{
			size, err := m.RollbackDNShardResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.CommitDNShardResponse != nil {
		{
			size, err := m.CommitDNShardResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.GetStatusResponse != nil {
		{
			size, err := m.GetStatusResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.PrepareResponse != nil {
		{
			size, err := m.PrepareResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.RollbackResponse != nil {
		{
			size, err := m.RollbackResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.CommitResponse != nil {
		{
			size, err := m.CommitResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.CNOpResponse != nil {
		{
			size, err := m.CNOpResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.TxnError != nil {
		{
			size, err := m.TxnError.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Flag != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.Flag))
		i--
		dAtA[i] = 0x20
	}
	if m.Method != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.Method))
		i--
		dAtA[i] = 0x18
	}
	if m.Txn != nil {
		{
			size, err := m.Txn.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTxn(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.RequestID != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.RequestID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnCommitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Disable1PCOpt {
		i--
		if m.Disable1PCOpt {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnCommitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnRollbackRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnRollbackResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnPrepareRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *TxnPrepareResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnGetStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *TxnGetStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnCommitDNShardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *TxnCommitDNShardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnRollbackDNShardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *TxnRollbackDNShardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnRemoveMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTxn(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *TxnRemoveMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TxnError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.TxnErrCode != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.TxnErrCode))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintTxn(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintTxn(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintTxn(dAtA []byte, offset int, v uint64) int {
	offset -= sovTxn(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TxnMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovTxn(uint64(m.Status))
	}
	l = m.SnapshotTS.Size()
	n += 1 + l + sovTxn(uint64(l))
	l = m.PreparedTS.Size()
	n += 1 + l + sovTxn(uint64(l))
	l = m.CommitTS.Size()
	n += 1 + l + sovTxn(uint64(l))
	if len(m.DNShards) > 0 {
		for _, e := range m.DNShards {
			l = e.Size()
			n += 1 + l + sovTxn(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CNTxnSnapshot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Txn.Size()
	n += 1 + l + sovTxn(uint64(l))
	if m.ReadyOnly {
		n += 2
	}
	if m.EnableCacheWrite {
		n += 2
	}
	if m.Disable1PCOpt {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CNOpRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OpCode != 0 {
		n += 1 + sovTxn(uint64(m.OpCode))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovTxn(uint64(l))
	}
	l = m.Target.Size()
	n += 1 + l + sovTxn(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CNOpResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestID != 0 {
		n += 1 + sovTxn(uint64(m.RequestID))
	}
	l = m.Txn.Size()
	n += 1 + l + sovTxn(uint64(l))
	if m.Method != 0 {
		n += 1 + sovTxn(uint64(m.Method))
	}
	if m.Flag != 0 {
		n += 1 + sovTxn(uint64(m.Flag))
	}
	if m.CNRequest != nil {
		l = m.CNRequest.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.CommitRequest != nil {
		l = m.CommitRequest.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.RollbackRequest != nil {
		l = m.RollbackRequest.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.PrepareRequest != nil {
		l = m.PrepareRequest.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.GetStatusRequest != nil {
		l = m.GetStatusRequest.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.CommitDNShardRequest != nil {
		l = m.CommitDNShardRequest.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.RollbackDNShardRequest != nil {
		l = m.RollbackDNShardRequest.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.RemoveMetadata != nil {
		l = m.RemoveMetadata.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.Options != nil {
		l = m.Options.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnRequestOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.RetryCodes) > 0 {
		l = 0
		for _, e := range m.RetryCodes {
			l += sovTxn(uint64(e))
		}
		n += 1 + sovTxn(uint64(l)) + l
	}
	if m.RetryInterval != 0 {
		n += 1 + sovTxn(uint64(m.RetryInterval))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestID != 0 {
		n += 1 + sovTxn(uint64(m.RequestID))
	}
	if m.Txn != nil {
		l = m.Txn.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.Method != 0 {
		n += 1 + sovTxn(uint64(m.Method))
	}
	if m.Flag != 0 {
		n += 1 + sovTxn(uint64(m.Flag))
	}
	if m.TxnError != nil {
		l = m.TxnError.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.CNOpResponse != nil {
		l = m.CNOpResponse.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.CommitResponse != nil {
		l = m.CommitResponse.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.RollbackResponse != nil {
		l = m.RollbackResponse.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.PrepareResponse != nil {
		l = m.PrepareResponse.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.GetStatusResponse != nil {
		l = m.GetStatusResponse.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.CommitDNShardResponse != nil {
		l = m.CommitDNShardResponse.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.RollbackDNShardResponse != nil {
		l = m.RollbackDNShardResponse.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.RemoveMetadata != nil {
		l = m.RemoveMetadata.Size()
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnCommitRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Disable1PCOpt {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnCommitResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnRollbackRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnRollbackResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnPrepareRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.DNShard.Size()
	n += 1 + l + sovTxn(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnPrepareResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnGetStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.DNShard.Size()
	n += 1 + l + sovTxn(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnGetStatusResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnCommitDNShardRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.DNShard.Size()
	n += 1 + l + sovTxn(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnCommitDNShardResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnRollbackDNShardRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.DNShard.Size()
	n += 1 + l + sovTxn(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnRollbackDNShardResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnRemoveMetadataRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.DNShard.Size()
	n += 1 + l + sovTxn(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnRemoveMetadataResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovTxn(uint64(m.Code))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovTxn(uint64(l))
	}
	if m.TxnErrCode != 0 {
		n += 1 + sovTxn(uint64(m.TxnErrCode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovTxn(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTxn(x uint64) (n int) {
	return sovTxn(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TxnMeta) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTxn
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TxnMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxnMeta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = append(m.ID[:0], dAtA[iNdEx:postIndex]...)
			if m.ID == nil {
				m.ID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= TxnStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnapshotTS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SnapshotTS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreparedTS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PreparedTS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitTS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CommitTS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DNShards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DNShards = append(m.DNShards, metadata.DNShard{})
			if err := m.DNShards[len(m.DNShards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTxn(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTxn
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TxnRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTxn
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TxnRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxnRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestID", wireType)
			}
			m.RequestID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Txn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
			}
			m.Method = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Method |= TxnMethod(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flag", wireType)
			}
			m.Flag = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Flag |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CNRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CNRequest == nil {
				m.CNRequest = &CNOpRequest{}
			}
			if err := m.CNRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CommitRequest == nil {
				m.CommitRequest = &TxnCommitRequest{}
			}
			if err := m.CommitRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollbackRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RollbackRequest == nil {
				m.RollbackRequest = &TxnRollbackRequest{}
			}
			if err := m.RollbackRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrepareRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PrepareRequest == nil {
				m.PrepareRequest = &TxnPrepareRequest{}
			}
			if err := m.PrepareRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetStatusRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetStatusRequest == nil {
				m.GetStatusRequest = &TxnGetStatusRequest{}
			}
			if err := m.GetStatusRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitDNShardRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CommitDNShardRequest == nil {
				m.CommitDNShardRequest = &TxnCommitDNShardRequest{}
			}
			if err := m.CommitDNShardRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollbackDNShardRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RollbackDNShardRequest == nil {
				m.RollbackDNShardRequest = &TxnRollbackDNShardRequest{}
			}
			if err := m.RollbackDNShardRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RemoveMetadata == nil {
				m.RemoveMetadata = &TxnRemoveMetadataRequest{}
			}
			if err := m.RemoveMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Options == nil {
				m.Options = &TxnRequestOptions{}
			}
			if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTxn(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTxn
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TxnRequestOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTxn
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TxnRequestOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxnRequestOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTxn
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RetryCodes = append(m.RetryCodes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTxn
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTxn
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTxn
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RetryCodes) == 0 {
					m.RetryCodes = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTxn
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RetryCodes = append(m.RetryCodes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RetryCodes", wireType)
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RetryInterval", wireType)
			}
			m.RetryInterval = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RetryInterval |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTxn(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTxn
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TxnResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTxn
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TxnResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxnResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestID", wireType)
			}
			m.RequestID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Txn == nil {
				m.Txn = &TxnMeta{}
			}
			if err := m.Txn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
			}
			m.Method = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Method |= TxnMethod(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flag", wireType)
			}
			m.Flag = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Flag |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TxnError == nil {
				m.TxnError = &TxnError{}
			}
			if err := m.TxnError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CNOpResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CNOpResponse == nil {
				m.CNOpResponse = &CNOpResponse{}
			}
			if err := m.CNOpResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CommitResponse == nil {
				m.CommitResponse = &TxnCommitResponse{}
			}
			if err := m.CommitResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollbackResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RollbackResponse == nil {
				m.RollbackResponse = &TxnRollbackResponse{}
			}
			if err := m.RollbackResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrepareResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PrepareResponse == nil {
				m.PrepareResponse = &TxnPrepareResponse{}
			}
			if err := m.PrepareResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetStatusResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetStatusResponse == nil {
				m.GetStatusResponse = &TxnGetStatusResponse{}
			}
			if err := m.GetStatusResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitDNShardResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CommitDNShardResponse == nil {
				m.CommitDNShardResponse = &TxnCommitDNShardResponse{}
			}
			if err := m.CommitDNShardResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollbackDNShardResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RollbackDNShardResponse == nil {
				m.RollbackDNShardResponse = &TxnRollbackDNShardResponse{}
			}
			if err := m.RollbackDNShardResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTxn
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTxn
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTxn
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RemoveMetadata == nil {
				m.RemoveMetadata = &TxnRemoveMetadataResponse{}
			}
			if err := m.RemoveMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTxn(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTxn
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var (
	ErrInvalidLengthTxn        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTxn          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTxn = fmt.Errorf("proto: unexpected end of group")
)