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

package pb

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

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_meshplus_bitxhub_kit_types "github.com/meshplus/bitxhub-kit/types"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = proto.Marshal
	_ = fmt.Errorf
	_ = 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

type TransactionStatus int32

const (
	TransactionStatus_BEGIN   TransactionStatus = 0
	TransactionStatus_SUCCESS TransactionStatus = 1
	TransactionStatus_FAILURE TransactionStatus = 2
)

var TransactionStatus_name = map[int32]string{
	0: "BEGIN",
	1: "SUCCESS",
	2: "FAILURE",
}

var TransactionStatus_value = map[string]int32{
	"BEGIN":   0,
	"SUCCESS": 1,
	"FAILURE": 2,
}

func (x TransactionStatus) String() string {
	return proto.EnumName(TransactionStatus_name, int32(x))
}

func (TransactionStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{0}
}

type AssetExchangeStatus int32

const (
	AssetExchangeStatus_INIT   AssetExchangeStatus = 0
	AssetExchangeStatus_REDEEM AssetExchangeStatus = 1
	AssetExchangeStatus_REFUND AssetExchangeStatus = 2
)

var AssetExchangeStatus_name = map[int32]string{
	0: "INIT",
	1: "REDEEM",
	2: "REFUND",
}

var AssetExchangeStatus_value = map[string]int32{
	"INIT":   0,
	"REDEEM": 1,
	"REFUND": 2,
}

func (x AssetExchangeStatus) String() string {
	return proto.EnumName(AssetExchangeStatus_name, int32(x))
}

func (AssetExchangeStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{1}
}

type TransactionData_Type int32

const (
	TransactionData_NORMAL   TransactionData_Type = 0
	TransactionData_INVOKE   TransactionData_Type = 1
	TransactionData_UPDATE   TransactionData_Type = 2
	TransactionData_FREEZE   TransactionData_Type = 3
	TransactionData_UNFREEZE TransactionData_Type = 4
)

var TransactionData_Type_name = map[int32]string{
	0: "NORMAL",
	1: "INVOKE",
	2: "UPDATE",
	3: "FREEZE",
	4: "UNFREEZE",
}

var TransactionData_Type_value = map[string]int32{
	"NORMAL":   0,
	"INVOKE":   1,
	"UPDATE":   2,
	"FREEZE":   3,
	"UNFREEZE": 4,
}

func (x TransactionData_Type) String() string {
	return proto.EnumName(TransactionData_Type_name, int32(x))
}

func (TransactionData_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{1, 0}
}

type TransactionData_VMType int32

const (
	TransactionData_BVM TransactionData_VMType = 0
	TransactionData_XVM TransactionData_VMType = 1
)

var TransactionData_VMType_name = map[int32]string{
	0: "BVM",
	1: "XVM",
}

var TransactionData_VMType_value = map[string]int32{
	"BVM": 0,
	"XVM": 1,
}

func (x TransactionData_VMType) String() string {
	return proto.EnumName(TransactionData_VMType_name, int32(x))
}

func (TransactionData_VMType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{1, 1}
}

type BxhTransaction struct {
	Version         []byte                                         `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	From            *github_com_meshplus_bitxhub_kit_types.Address `protobuf:"bytes,2,opt,name=from,proto3,customtype=github.com/meshplus/bitxhub-kit/types.Address" json:"from,omitempty"`
	To              *github_com_meshplus_bitxhub_kit_types.Address `protobuf:"bytes,3,opt,name=to,proto3,customtype=github.com/meshplus/bitxhub-kit/types.Address" json:"to,omitempty"`
	Timestamp       int64                                          `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	TransactionHash *github_com_meshplus_bitxhub_kit_types.Hash    `protobuf:"bytes,5,opt,name=transaction_hash,json=transactionHash,proto3,customtype=github.com/meshplus/bitxhub-kit/types.Hash" json:"transaction_hash,omitempty"`
	Payload         []byte                                         `protobuf:"bytes,6,opt,name=payload,proto3" json:"payload,omitempty"`
	IBTP            *IBTP                                          `protobuf:"bytes,7,opt,name=IBTP,proto3" json:"IBTP,omitempty"`
	Nonce           uint64                                         `protobuf:"varint,8,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Amount          uint64                                         `protobuf:"varint,9,opt,name=amount,proto3" json:"amount,omitempty"`
	Signature       []byte                                         `protobuf:"bytes,10,opt,name=signature,proto3" json:"signature,omitempty"`
	Extra           []byte                                         `protobuf:"bytes,11,opt,name=extra,proto3" json:"extra,omitempty"`
}

func (m *BxhTransaction) Reset() { *m = BxhTransaction{} }

func (m *BxhTransaction) String() string { return proto.CompactTextString(m) }

func (*BxhTransaction) ProtoMessage() {}

func (*BxhTransaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{0}
}

func (m *BxhTransaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *BxhTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BxhTransaction.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 *BxhTransaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BxhTransaction.Merge(m, src)
}

func (m *BxhTransaction) XXX_Size() int {
	return m.Size()
}

func (m *BxhTransaction) XXX_DiscardUnknown() {
	xxx_messageInfo_BxhTransaction.DiscardUnknown(m)
}

var xxx_messageInfo_BxhTransaction proto.InternalMessageInfo

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

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

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

func (m *BxhTransaction) GetIBTP() *IBTP {
	if m != nil {
		return m.IBTP
	}
	return nil
}

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

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

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

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

type TransactionData struct {
	Type    TransactionData_Type   `protobuf:"varint,1,opt,name=type,proto3,enum=pb.TransactionData_Type" json:"type,omitempty"`
	Amount  uint64                 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	VmType  TransactionData_VMType `protobuf:"varint,3,opt,name=vm_type,json=vmType,proto3,enum=pb.TransactionData_VMType" json:"vm_type,omitempty"`
	Payload []byte                 `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"`
	Extra   []byte                 `protobuf:"bytes,5,opt,name=extra,proto3" json:"extra,omitempty"`
}

func (m *TransactionData) Reset() { *m = TransactionData{} }

func (m *TransactionData) String() string { return proto.CompactTextString(m) }

func (*TransactionData) ProtoMessage() {}

func (*TransactionData) Descriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{1}
}

func (m *TransactionData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *TransactionData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransactionData.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 *TransactionData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionData.Merge(m, src)
}

func (m *TransactionData) XXX_Size() int {
	return m.Size()
}

func (m *TransactionData) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionData.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionData proto.InternalMessageInfo

func (m *TransactionData) GetType() TransactionData_Type {
	if m != nil {
		return m.Type
	}
	return TransactionData_NORMAL
}

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

func (m *TransactionData) GetVmType() TransactionData_VMType {
	if m != nil {
		return m.VmType
	}
	return TransactionData_BVM
}

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

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

type InvokePayload struct {
	Method string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
	Args   []*Arg `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
}

func (m *InvokePayload) Reset() { *m = InvokePayload{} }

func (m *InvokePayload) String() string { return proto.CompactTextString(m) }

func (*InvokePayload) ProtoMessage() {}

func (*InvokePayload) Descriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{2}
}

func (m *InvokePayload) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *InvokePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InvokePayload.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 *InvokePayload) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvokePayload.Merge(m, src)
}

func (m *InvokePayload) XXX_Size() int {
	return m.Size()
}

func (m *InvokePayload) XXX_DiscardUnknown() {
	xxx_messageInfo_InvokePayload.DiscardUnknown(m)
}

var xxx_messageInfo_InvokePayload proto.InternalMessageInfo

func (m *InvokePayload) GetMethod() string {
	if m != nil {
		return m.Method
	}
	return ""
}

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

type TransactionMeta struct {
	BlockHash   []byte `protobuf:"bytes,1,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
	BlockHeight uint64 `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Index       uint64 `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
}

func (m *TransactionMeta) Reset() { *m = TransactionMeta{} }

func (m *TransactionMeta) String() string { return proto.CompactTextString(m) }

func (*TransactionMeta) ProtoMessage() {}

func (*TransactionMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{3}
}

func (m *TransactionMeta) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *TransactionMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransactionMeta.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 *TransactionMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionMeta.Merge(m, src)
}

func (m *TransactionMeta) XXX_Size() int {
	return m.Size()
}

func (m *TransactionMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionMeta.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionMeta proto.InternalMessageInfo

func (m *TransactionMeta) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

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

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

type CrosschainTransactionExtra struct {
	Index  uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Status bool   `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"`
	Ret    []byte `protobuf:"bytes,3,opt,name=ret,proto3" json:"ret,omitempty"`
}

func (m *CrosschainTransactionExtra) Reset() { *m = CrosschainTransactionExtra{} }

func (m *CrosschainTransactionExtra) String() string { return proto.CompactTextString(m) }

func (*CrosschainTransactionExtra) ProtoMessage() {}

func (*CrosschainTransactionExtra) Descriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{4}
}

func (m *CrosschainTransactionExtra) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CrosschainTransactionExtra) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CrosschainTransactionExtra.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 *CrosschainTransactionExtra) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrosschainTransactionExtra.Merge(m, src)
}

func (m *CrosschainTransactionExtra) XXX_Size() int {
	return m.Size()
}

func (m *CrosschainTransactionExtra) XXX_DiscardUnknown() {
	xxx_messageInfo_CrosschainTransactionExtra.DiscardUnknown(m)
}

var xxx_messageInfo_CrosschainTransactionExtra proto.InternalMessageInfo

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

func (m *CrosschainTransactionExtra) GetStatus() bool {
	if m != nil {
		return m.Status
	}
	return false
}

func (m *CrosschainTransactionExtra) GetRet() []byte {
	if m != nil {
		return m.Ret
	}
	return nil
}

type TransactionTracingMeta struct {
	ReceiptHash []byte `protobuf:"bytes,1,opt,name=receipt_hash,json=receiptHash,proto3" json:"receipt_hash,omitempty"`
	ConfirmHash []byte `protobuf:"bytes,2,opt,name=confirm_hash,json=confirmHash,proto3" json:"confirm_hash,omitempty"`
}

func (m *TransactionTracingMeta) Reset() { *m = TransactionTracingMeta{} }

func (m *TransactionTracingMeta) String() string { return proto.CompactTextString(m) }

func (*TransactionTracingMeta) ProtoMessage() {}

func (*TransactionTracingMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{5}
}

func (m *TransactionTracingMeta) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *TransactionTracingMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransactionTracingMeta.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 *TransactionTracingMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionTracingMeta.Merge(m, src)
}

func (m *TransactionTracingMeta) XXX_Size() int {
	return m.Size()
}

func (m *TransactionTracingMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionTracingMeta.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionTracingMeta proto.InternalMessageInfo

func (m *TransactionTracingMeta) GetReceiptHash() []byte {
	if m != nil {
		return m.ReceiptHash
	}
	return nil
}

func (m *TransactionTracingMeta) GetConfirmHash() []byte {
	if m != nil {
		return m.ConfirmHash
	}
	return nil
}

type TransactionSlice struct {
	Height uint64            `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Txs    []*BxhTransaction `protobuf:"bytes,2,rep,name=txs,proto3" json:"txs,omitempty"`
}

func (m *TransactionSlice) Reset() { *m = TransactionSlice{} }

func (m *TransactionSlice) String() string { return proto.CompactTextString(m) }

func (*TransactionSlice) ProtoMessage() {}

func (*TransactionSlice) Descriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{6}
}

func (m *TransactionSlice) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *TransactionSlice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransactionSlice.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 *TransactionSlice) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionSlice.Merge(m, src)
}

func (m *TransactionSlice) XXX_Size() int {
	return m.Size()
}

func (m *TransactionSlice) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionSlice.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionSlice proto.InternalMessageInfo

func (m *TransactionSlice) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *TransactionSlice) GetTxs() []*BxhTransaction {
	if m != nil {
		return m.Txs
	}
	return nil
}

type AssetExchangeInfo struct {
	Id            string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SenderOnSrc   string `protobuf:"bytes,2,opt,name=sender_on_src,json=senderOnSrc,proto3" json:"sender_on_src,omitempty"`
	ReceiverOnSrc string `protobuf:"bytes,3,opt,name=receiver_on_src,json=receiverOnSrc,proto3" json:"receiver_on_src,omitempty"`
	AssetOnSrc    uint64 `protobuf:"varint,4,opt,name=asset_on_src,json=assetOnSrc,proto3" json:"asset_on_src,omitempty"`
	SenderOnDst   string `protobuf:"bytes,5,opt,name=sender_on_dst,json=senderOnDst,proto3" json:"sender_on_dst,omitempty"`
	ReceiverOnDst string `protobuf:"bytes,6,opt,name=receiver_on_dst,json=receiverOnDst,proto3" json:"receiver_on_dst,omitempty"`
	AssetOnDst    uint64 `protobuf:"varint,7,opt,name=asset_on_dst,json=assetOnDst,proto3" json:"asset_on_dst,omitempty"`
}

func (m *AssetExchangeInfo) Reset() { *m = AssetExchangeInfo{} }

func (m *AssetExchangeInfo) String() string { return proto.CompactTextString(m) }

func (*AssetExchangeInfo) ProtoMessage() {}

func (*AssetExchangeInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_3eb90b06bee49601, []int{7}
}

func (m *AssetExchangeInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *AssetExchangeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AssetExchangeInfo.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 *AssetExchangeInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AssetExchangeInfo.Merge(m, src)
}

func (m *AssetExchangeInfo) XXX_Size() int {
	return m.Size()
}

func (m *AssetExchangeInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_AssetExchangeInfo.DiscardUnknown(m)
}

var xxx_messageInfo_AssetExchangeInfo proto.InternalMessageInfo

func (m *AssetExchangeInfo) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *AssetExchangeInfo) GetSenderOnSrc() string {
	if m != nil {
		return m.SenderOnSrc
	}
	return ""
}

func (m *AssetExchangeInfo) GetReceiverOnSrc() string {
	if m != nil {
		return m.ReceiverOnSrc
	}
	return ""
}

func (m *AssetExchangeInfo) GetAssetOnSrc() uint64 {
	if m != nil {
		return m.AssetOnSrc
	}
	return 0
}

func (m *AssetExchangeInfo) GetSenderOnDst() string {
	if m != nil {
		return m.SenderOnDst
	}
	return ""
}

func (m *AssetExchangeInfo) GetReceiverOnDst() string {
	if m != nil {
		return m.ReceiverOnDst
	}
	return ""
}

func (m *AssetExchangeInfo) GetAssetOnDst() uint64 {
	if m != nil {
		return m.AssetOnDst
	}
	return 0
}

func init() {
	proto.RegisterEnum("pb.TransactionStatus", TransactionStatus_name, TransactionStatus_value)
	proto.RegisterEnum("pb.AssetExchangeStatus", AssetExchangeStatus_name, AssetExchangeStatus_value)
	proto.RegisterEnum("pb.TransactionData_Type", TransactionData_Type_name, TransactionData_Type_value)
	proto.RegisterEnum("pb.TransactionData_VMType", TransactionData_VMType_name, TransactionData_VMType_value)
	proto.RegisterType((*BxhTransaction)(nil), "pb.BxhTransaction")
	proto.RegisterType((*TransactionData)(nil), "pb.TransactionData")
	proto.RegisterType((*InvokePayload)(nil), "pb.InvokePayload")
	proto.RegisterType((*TransactionMeta)(nil), "pb.TransactionMeta")
	proto.RegisterType((*CrosschainTransactionExtra)(nil), "pb.CrosschainTransactionExtra")
	proto.RegisterType((*TransactionTracingMeta)(nil), "pb.TransactionTracingMeta")
	proto.RegisterType((*TransactionSlice)(nil), "pb.TransactionSlice")
	proto.RegisterType((*AssetExchangeInfo)(nil), "pb.AssetExchangeInfo")
}

func init() { proto.RegisterFile("bxh_transaction.proto", fileDescriptor_3eb90b06bee49601) }

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

func (m *BxhTransaction) 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 *BxhTransaction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BxhTransaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Extra) > 0 {
		i -= len(m.Extra)
		copy(dAtA[i:], m.Extra)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Extra)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x52
	}
	if m.Amount != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x48
	}
	if m.Nonce != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.Nonce))
		i--
		dAtA[i] = 0x40
	}
	if m.IBTP != nil {
		{
			size, err := m.IBTP.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBxhTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x32
	}
	if m.TransactionHash != nil {
		{
			size := m.TransactionHash.Size()
			i -= size
			if _, err := m.TransactionHash.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBxhTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Timestamp != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x20
	}
	if m.To != nil {
		{
			size := m.To.Size()
			i -= size
			if _, err := m.To.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBxhTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.From != nil {
		{
			size := m.From.Size()
			i -= size
			if _, err := m.From.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintBxhTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TransactionData) 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 *TransactionData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Extra) > 0 {
		i -= len(m.Extra)
		copy(dAtA[i:], m.Extra)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Extra)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x22
	}
	if m.VmType != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.VmType))
		i--
		dAtA[i] = 0x18
	}
	if m.Amount != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x10
	}
	if m.Type != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InvokePayload) 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 *InvokePayload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InvokePayload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBxhTransaction(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Method) > 0 {
		i -= len(m.Method)
		copy(dAtA[i:], m.Method)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Method)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TransactionMeta) 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 *TransactionMeta) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x18
	}
	if m.BlockHeight != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if len(m.BlockHash) > 0 {
		i -= len(m.BlockHash)
		copy(dAtA[i:], m.BlockHash)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.BlockHash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CrosschainTransactionExtra) 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 *CrosschainTransactionExtra) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CrosschainTransactionExtra) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ret) > 0 {
		i -= len(m.Ret)
		copy(dAtA[i:], m.Ret)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Ret)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Status {
		i--
		if m.Status {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Index != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TransactionTracingMeta) 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 *TransactionTracingMeta) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionTracingMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ConfirmHash) > 0 {
		i -= len(m.ConfirmHash)
		copy(dAtA[i:], m.ConfirmHash)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.ConfirmHash)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ReceiptHash) > 0 {
		i -= len(m.ReceiptHash)
		copy(dAtA[i:], m.ReceiptHash)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.ReceiptHash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TransactionSlice) 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 *TransactionSlice) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionSlice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Txs) > 0 {
		for iNdEx := len(m.Txs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Txs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBxhTransaction(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Height != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AssetExchangeInfo) 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 *AssetExchangeInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AssetExchangeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AssetOnDst != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.AssetOnDst))
		i--
		dAtA[i] = 0x38
	}
	if len(m.ReceiverOnDst) > 0 {
		i -= len(m.ReceiverOnDst)
		copy(dAtA[i:], m.ReceiverOnDst)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.ReceiverOnDst)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.SenderOnDst) > 0 {
		i -= len(m.SenderOnDst)
		copy(dAtA[i:], m.SenderOnDst)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.SenderOnDst)))
		i--
		dAtA[i] = 0x2a
	}
	if m.AssetOnSrc != 0 {
		i = encodeVarintBxhTransaction(dAtA, i, uint64(m.AssetOnSrc))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ReceiverOnSrc) > 0 {
		i -= len(m.ReceiverOnSrc)
		copy(dAtA[i:], m.ReceiverOnSrc)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.ReceiverOnSrc)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SenderOnSrc) > 0 {
		i -= len(m.SenderOnSrc)
		copy(dAtA[i:], m.SenderOnSrc)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.SenderOnSrc)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintBxhTransaction(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintBxhTransaction(dAtA []byte, offset int, v uint64) int {
	offset -= sovBxhTransaction(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

func (m *BxhTransaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if m.From != nil {
		l = m.From.Size()
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if m.To != nil {
		l = m.To.Size()
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovBxhTransaction(uint64(m.Timestamp))
	}
	if m.TransactionHash != nil {
		l = m.TransactionHash.Size()
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if m.IBTP != nil {
		l = m.IBTP.Size()
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if m.Nonce != 0 {
		n += 1 + sovBxhTransaction(uint64(m.Nonce))
	}
	if m.Amount != 0 {
		n += 1 + sovBxhTransaction(uint64(m.Amount))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	l = len(m.Extra)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	return n
}

func (m *TransactionData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovBxhTransaction(uint64(m.Type))
	}
	if m.Amount != 0 {
		n += 1 + sovBxhTransaction(uint64(m.Amount))
	}
	if m.VmType != 0 {
		n += 1 + sovBxhTransaction(uint64(m.VmType))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	l = len(m.Extra)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	return n
}

func (m *InvokePayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Method)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovBxhTransaction(uint64(l))
		}
	}
	return n
}

func (m *TransactionMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockHash)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovBxhTransaction(uint64(m.BlockHeight))
	}
	if m.Index != 0 {
		n += 1 + sovBxhTransaction(uint64(m.Index))
	}
	return n
}

func (m *CrosschainTransactionExtra) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovBxhTransaction(uint64(m.Index))
	}
	if m.Status {
		n += 2
	}
	l = len(m.Ret)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	return n
}

func (m *TransactionTracingMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ReceiptHash)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	l = len(m.ConfirmHash)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	return n
}

func (m *TransactionSlice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovBxhTransaction(uint64(m.Height))
	}
	if len(m.Txs) > 0 {
		for _, e := range m.Txs {
			l = e.Size()
			n += 1 + l + sovBxhTransaction(uint64(l))
		}
	}
	return n
}

func (m *AssetExchangeInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	l = len(m.SenderOnSrc)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	l = len(m.ReceiverOnSrc)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if m.AssetOnSrc != 0 {
		n += 1 + sovBxhTransaction(uint64(m.AssetOnSrc))
	}
	l = len(m.SenderOnDst)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	l = len(m.ReceiverOnDst)
	if l > 0 {
		n += 1 + l + sovBxhTransaction(uint64(l))
	}
	if m.AssetOnDst != 0 {
		n += 1 + sovBxhTransaction(uint64(m.AssetOnDst))
	}
	return n
}

func sovBxhTransaction(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}

func sozBxhTransaction(x uint64) (n int) {
	return sovBxhTransaction(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}

func (m *BxhTransaction) 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 ErrIntOverflowBxhTransaction
			}
			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: BxhTransaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BxhTransaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = append(m.Version[:0], dAtA[iNdEx:postIndex]...)
			if m.Version == nil {
				m.Version = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_meshplus_bitxhub_kit_types.Address
			m.From = &v
			if err := m.From.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_meshplus_bitxhub_kit_types.Address
			m.To = &v
			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_meshplus_bitxhub_kit_types.Hash
			m.TransactionHash = &v
			if err := m.TransactionHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			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 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IBTP", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IBTP == nil {
				m.IBTP = &IBTP{}
			}
			if err := m.IBTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			m.Amount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Extra = append(m.Extra[:0], dAtA[iNdEx:postIndex]...)
			if m.Extra == nil {
				m.Extra = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBxhTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *TransactionData) 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 ErrIntOverflowBxhTransaction
			}
			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: TransactionData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= TransactionData_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			m.Amount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VmType", wireType)
			}
			m.VmType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VmType |= TransactionData_VMType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			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 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Extra = append(m.Extra[:0], dAtA[iNdEx:postIndex]...)
			if m.Extra == nil {
				m.Extra = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBxhTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *InvokePayload) 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 ErrIntOverflowBxhTransaction
			}
			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: InvokePayload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InvokePayload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Method = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, &Arg{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBxhTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *TransactionMeta) 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 ErrIntOverflowBxhTransaction
			}
			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: TransactionMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionMeta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockHash = append(m.BlockHash[:0], dAtA[iNdEx:postIndex]...)
			if m.BlockHash == nil {
				m.BlockHash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBxhTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *CrosschainTransactionExtra) 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 ErrIntOverflowBxhTransaction
			}
			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: CrosschainTransactionExtra: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrosschainTransactionExtra: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Status = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ret", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ret = append(m.Ret[:0], dAtA[iNdEx:postIndex]...)
			if m.Ret == nil {
				m.Ret = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBxhTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *TransactionTracingMeta) 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 ErrIntOverflowBxhTransaction
			}
			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: TransactionTracingMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionTracingMeta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceiptHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReceiptHash = append(m.ReceiptHash[:0], dAtA[iNdEx:postIndex]...)
			if m.ReceiptHash == nil {
				m.ReceiptHash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfirmHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfirmHash = append(m.ConfirmHash[:0], dAtA[iNdEx:postIndex]...)
			if m.ConfirmHash == nil {
				m.ConfirmHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBxhTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *TransactionSlice) 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 ErrIntOverflowBxhTransaction
			}
			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: TransactionSlice: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionSlice: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Txs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Txs = append(m.Txs, &BxhTransaction{})
			if err := m.Txs[len(m.Txs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBxhTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *AssetExchangeInfo) 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 ErrIntOverflowBxhTransaction
			}
			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: AssetExchangeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AssetExchangeInfo: 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 stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderOnSrc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SenderOnSrc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceiverOnSrc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReceiverOnSrc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AssetOnSrc", wireType)
			}
			m.AssetOnSrc = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AssetOnSrc |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderOnDst", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SenderOnDst = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceiverOnDst", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReceiverOnDst = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AssetOnDst", wireType)
			}
			m.AssetOnDst = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBxhTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AssetOnDst |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBxhTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBxhTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func skipBxhTransaction(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, ErrIntOverflowBxhTransaction
			}
			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, ErrIntOverflowBxhTransaction
				}
				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, ErrIntOverflowBxhTransaction
				}
				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, ErrInvalidLengthBxhTransaction
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupBxhTransaction
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthBxhTransaction
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthBxhTransaction        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBxhTransaction          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBxhTransaction = fmt.Errorf("proto: unexpected end of group")
)