cross_chain_tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: zetachain/zetacore/crosschain/cross_chain_tx.proto

package types

import (
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	coin "github.com/zeta-chain/zetacore/pkg/coin"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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

type CctxStatus int32

const (
	CctxStatus_PendingInbound  CctxStatus = 0
	CctxStatus_PendingOutbound CctxStatus = 1
	CctxStatus_OutboundMined   CctxStatus = 3
	CctxStatus_PendingRevert   CctxStatus = 4
	CctxStatus_Reverted        CctxStatus = 5
	CctxStatus_Aborted         CctxStatus = 6
)

var CctxStatus_name = map[int32]string{
	0: "PendingInbound",
	1: "PendingOutbound",
	3: "OutboundMined",
	4: "PendingRevert",
	5: "Reverted",
	6: "Aborted",
}

var CctxStatus_value = map[string]int32{
	"PendingInbound":  0,
	"PendingOutbound": 1,
	"OutboundMined":   3,
	"PendingRevert":   4,
	"Reverted":        5,
	"Aborted":         6,
}

func (x CctxStatus) String() string {
	return proto.EnumName(CctxStatus_name, int32(x))
}

func (CctxStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d4c1966807fb5cb2, []int{0}
}

type TxFinalizationStatus int32

const (
	TxFinalizationStatus_NotFinalized TxFinalizationStatus = 0
	TxFinalizationStatus_Finalized    TxFinalizationStatus = 1
	TxFinalizationStatus_Executed     TxFinalizationStatus = 2
)

var TxFinalizationStatus_name = map[int32]string{
	0: "NotFinalized",
	1: "Finalized",
	2: "Executed",
}

var TxFinalizationStatus_value = map[string]int32{
	"NotFinalized": 0,
	"Finalized":    1,
	"Executed":     2,
}

func (x TxFinalizationStatus) String() string {
	return proto.EnumName(TxFinalizationStatus_name, int32(x))
}

func (TxFinalizationStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d4c1966807fb5cb2, []int{1}
}

type InboundParams struct {
	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	// the Connector.send()
	SenderChainId          int64                                   `protobuf:"varint,2,opt,name=sender_chain_id,json=senderChainId,proto3" json:"sender_chain_id,omitempty"`
	TxOrigin               string                                  `protobuf:"bytes,3,opt,name=tx_origin,json=txOrigin,proto3" json:"tx_origin,omitempty"`
	CoinType               coin.CoinType                           `protobuf:"varint,4,opt,name=coin_type,json=coinType,proto3,enum=zetachain.zetacore.pkg.coin.CoinType" json:"coin_type,omitempty"`
	Asset                  string                                  `protobuf:"bytes,5,opt,name=asset,proto3" json:"asset,omitempty"`
	Amount                 github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,6,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"amount"`
	ObservedHash           string                                  `protobuf:"bytes,7,opt,name=observed_hash,json=observedHash,proto3" json:"observed_hash,omitempty"`
	ObservedExternalHeight uint64                                  `protobuf:"varint,8,opt,name=observed_external_height,json=observedExternalHeight,proto3" json:"observed_external_height,omitempty"`
	BallotIndex            string                                  `protobuf:"bytes,9,opt,name=ballot_index,json=ballotIndex,proto3" json:"ballot_index,omitempty"`
	FinalizedZetaHeight    uint64                                  `protobuf:"varint,10,opt,name=finalized_zeta_height,json=finalizedZetaHeight,proto3" json:"finalized_zeta_height,omitempty"`
	TxFinalizationStatus   TxFinalizationStatus                    `protobuf:"varint,11,opt,name=tx_finalization_status,json=txFinalizationStatus,proto3,enum=zetachain.zetacore.crosschain.TxFinalizationStatus" json:"tx_finalization_status,omitempty"`
}

func (m *InboundParams) Reset()         { *m = InboundParams{} }
func (m *InboundParams) String() string { return proto.CompactTextString(m) }
func (*InboundParams) ProtoMessage()    {}
func (*InboundParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_d4c1966807fb5cb2, []int{0}
}
func (m *InboundParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InboundParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InboundParams.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 *InboundParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InboundParams.Merge(m, src)
}
func (m *InboundParams) XXX_Size() int {
	return m.Size()
}
func (m *InboundParams) XXX_DiscardUnknown() {
	xxx_messageInfo_InboundParams.DiscardUnknown(m)
}

var xxx_messageInfo_InboundParams proto.InternalMessageInfo

func (m *InboundParams) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *InboundParams) GetSenderChainId() int64 {
	if m != nil {
		return m.SenderChainId
	}
	return 0
}

func (m *InboundParams) GetTxOrigin() string {
	if m != nil {
		return m.TxOrigin
	}
	return ""
}

func (m *InboundParams) GetCoinType() coin.CoinType {
	if m != nil {
		return m.CoinType
	}
	return coin.CoinType_Zeta
}

func (m *InboundParams) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *InboundParams) GetObservedHash() string {
	if m != nil {
		return m.ObservedHash
	}
	return ""
}

func (m *InboundParams) GetObservedExternalHeight() uint64 {
	if m != nil {
		return m.ObservedExternalHeight
	}
	return 0
}

func (m *InboundParams) GetBallotIndex() string {
	if m != nil {
		return m.BallotIndex
	}
	return ""
}

func (m *InboundParams) GetFinalizedZetaHeight() uint64 {
	if m != nil {
		return m.FinalizedZetaHeight
	}
	return 0
}

func (m *InboundParams) GetTxFinalizationStatus() TxFinalizationStatus {
	if m != nil {
		return m.TxFinalizationStatus
	}
	return TxFinalizationStatus_NotFinalized
}

type ZetaAccounting struct {
	// aborted_zeta_amount stores the total aborted amount for cctx of coin-type
	// ZETA
	AbortedZetaAmount github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,1,opt,name=aborted_zeta_amount,json=abortedZetaAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"aborted_zeta_amount"`
}

func (m *ZetaAccounting) Reset()         { *m = ZetaAccounting{} }
func (m *ZetaAccounting) String() string { return proto.CompactTextString(m) }
func (*ZetaAccounting) ProtoMessage()    {}
func (*ZetaAccounting) Descriptor() ([]byte, []int) {
	return fileDescriptor_d4c1966807fb5cb2, []int{1}
}
func (m *ZetaAccounting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ZetaAccounting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ZetaAccounting.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 *ZetaAccounting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ZetaAccounting.Merge(m, src)
}
func (m *ZetaAccounting) XXX_Size() int {
	return m.Size()
}
func (m *ZetaAccounting) XXX_DiscardUnknown() {
	xxx_messageInfo_ZetaAccounting.DiscardUnknown(m)
}

var xxx_messageInfo_ZetaAccounting proto.InternalMessageInfo

type OutboundParams struct {
	Receiver        string                                  `protobuf:"bytes,1,opt,name=receiver,proto3" json:"receiver,omitempty"`
	ReceiverChainId int64                                   `protobuf:"varint,2,opt,name=receiver_chainId,json=receiverChainId,proto3" json:"receiver_chainId,omitempty"`
	CoinType        coin.CoinType                           `protobuf:"varint,3,opt,name=coin_type,json=coinType,proto3,enum=zetachain.zetacore.pkg.coin.CoinType" json:"coin_type,omitempty"`
	Amount          github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,4,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"amount"`
	TssNonce        uint64                                  `protobuf:"varint,5,opt,name=tss_nonce,json=tssNonce,proto3" json:"tss_nonce,omitempty"`
	GasLimit        uint64                                  `protobuf:"varint,6,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
	GasPrice        string                                  `protobuf:"bytes,7,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"`
	// the above are commands for zetaclients
	// the following fields are used when the outbound tx is mined
	Hash                   string                                 `protobuf:"bytes,8,opt,name=hash,proto3" json:"hash,omitempty"`
	BallotIndex            string                                 `protobuf:"bytes,9,opt,name=ballot_index,json=ballotIndex,proto3" json:"ballot_index,omitempty"`
	ObservedExternalHeight uint64                                 `protobuf:"varint,10,opt,name=observed_external_height,json=observedExternalHeight,proto3" json:"observed_external_height,omitempty"`
	GasUsed                uint64                                 `protobuf:"varint,20,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
	EffectiveGasPrice      github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,21,opt,name=effective_gas_price,json=effectiveGasPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"effective_gas_price"`
	EffectiveGasLimit      uint64                                 `protobuf:"varint,22,opt,name=effective_gas_limit,json=effectiveGasLimit,proto3" json:"effective_gas_limit,omitempty"`
	TssPubkey              string                                 `protobuf:"bytes,11,opt,name=tss_pubkey,json=tssPubkey,proto3" json:"tss_pubkey,omitempty"`
	TxFinalizationStatus   TxFinalizationStatus                   `protobuf:"varint,12,opt,name=tx_finalization_status,json=txFinalizationStatus,proto3,enum=zetachain.zetacore.crosschain.TxFinalizationStatus" json:"tx_finalization_status,omitempty"`
}

func (m *OutboundParams) Reset()         { *m = OutboundParams{} }
func (m *OutboundParams) String() string { return proto.CompactTextString(m) }
func (*OutboundParams) ProtoMessage()    {}
func (*OutboundParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_d4c1966807fb5cb2, []int{2}
}
func (m *OutboundParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutboundParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutboundParams.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 *OutboundParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutboundParams.Merge(m, src)
}
func (m *OutboundParams) XXX_Size() int {
	return m.Size()
}
func (m *OutboundParams) XXX_DiscardUnknown() {
	xxx_messageInfo_OutboundParams.DiscardUnknown(m)
}

var xxx_messageInfo_OutboundParams proto.InternalMessageInfo

func (m *OutboundParams) GetReceiver() string {
	if m != nil {
		return m.Receiver
	}
	return ""
}

func (m *OutboundParams) GetReceiverChainId() int64 {
	if m != nil {
		return m.ReceiverChainId
	}
	return 0
}

func (m *OutboundParams) GetCoinType() coin.CoinType {
	if m != nil {
		return m.CoinType
	}
	return coin.CoinType_Zeta
}

func (m *OutboundParams) GetTssNonce() uint64 {
	if m != nil {
		return m.TssNonce
	}
	return 0
}

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

func (m *OutboundParams) GetGasPrice() string {
	if m != nil {
		return m.GasPrice
	}
	return ""
}

func (m *OutboundParams) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *OutboundParams) GetBallotIndex() string {
	if m != nil {
		return m.BallotIndex
	}
	return ""
}

func (m *OutboundParams) GetObservedExternalHeight() uint64 {
	if m != nil {
		return m.ObservedExternalHeight
	}
	return 0
}

func (m *OutboundParams) GetGasUsed() uint64 {
	if m != nil {
		return m.GasUsed
	}
	return 0
}

func (m *OutboundParams) GetEffectiveGasLimit() uint64 {
	if m != nil {
		return m.EffectiveGasLimit
	}
	return 0
}

func (m *OutboundParams) GetTssPubkey() string {
	if m != nil {
		return m.TssPubkey
	}
	return ""
}

func (m *OutboundParams) GetTxFinalizationStatus() TxFinalizationStatus {
	if m != nil {
		return m.TxFinalizationStatus
	}
	return TxFinalizationStatus_NotFinalized
}

type Status struct {
	Status              CctxStatus `protobuf:"varint,1,opt,name=status,proto3,enum=zetachain.zetacore.crosschain.CctxStatus" json:"status,omitempty"`
	StatusMessage       string     `protobuf:"bytes,2,opt,name=status_message,json=statusMessage,proto3" json:"status_message,omitempty"`
	LastUpdateTimestamp int64      `protobuf:"varint,3,opt,name=lastUpdate_timestamp,json=lastUpdateTimestamp,proto3" json:"lastUpdate_timestamp,omitempty"`
	IsAbortRefunded     bool       `protobuf:"varint,4,opt,name=isAbortRefunded,proto3" json:"isAbortRefunded,omitempty"`
}

func (m *Status) Reset()         { *m = Status{} }
func (m *Status) String() string { return proto.CompactTextString(m) }
func (*Status) ProtoMessage()    {}
func (*Status) Descriptor() ([]byte, []int) {
	return fileDescriptor_d4c1966807fb5cb2, []int{3}
}
func (m *Status) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Status.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 *Status) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Status.Merge(m, src)
}
func (m *Status) XXX_Size() int {
	return m.Size()
}
func (m *Status) XXX_DiscardUnknown() {
	xxx_messageInfo_Status.DiscardUnknown(m)
}

var xxx_messageInfo_Status proto.InternalMessageInfo

func (m *Status) GetStatus() CctxStatus {
	if m != nil {
		return m.Status
	}
	return CctxStatus_PendingInbound
}

func (m *Status) GetStatusMessage() string {
	if m != nil {
		return m.StatusMessage
	}
	return ""
}

func (m *Status) GetLastUpdateTimestamp() int64 {
	if m != nil {
		return m.LastUpdateTimestamp
	}
	return 0
}

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

type CrossChainTx struct {
	Creator        string                                  `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	Index          string                                  `protobuf:"bytes,2,opt,name=index,proto3" json:"index,omitempty"`
	ZetaFees       github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,5,opt,name=zeta_fees,json=zetaFees,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"zeta_fees" yaml:"zeta_fees"`
	RelayedMessage string                                  `protobuf:"bytes,6,opt,name=relayed_message,json=relayedMessage,proto3" json:"relayed_message,omitempty"`
	CctxStatus     *Status                                 `protobuf:"bytes,8,opt,name=cctx_status,json=cctxStatus,proto3" json:"cctx_status,omitempty"`
	InboundParams  *InboundParams                          `protobuf:"bytes,9,opt,name=inbound_params,json=inboundParams,proto3" json:"inbound_params,omitempty"`
	OutboundParams []*OutboundParams                       `protobuf:"bytes,10,rep,name=outbound_params,json=outboundParams,proto3" json:"outbound_params,omitempty"`
}

func (m *CrossChainTx) Reset()         { *m = CrossChainTx{} }
func (m *CrossChainTx) String() string { return proto.CompactTextString(m) }
func (*CrossChainTx) ProtoMessage()    {}
func (*CrossChainTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_d4c1966807fb5cb2, []int{4}
}
func (m *CrossChainTx) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CrossChainTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CrossChainTx.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 *CrossChainTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossChainTx.Merge(m, src)
}
func (m *CrossChainTx) XXX_Size() int {
	return m.Size()
}
func (m *CrossChainTx) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossChainTx.DiscardUnknown(m)
}

var xxx_messageInfo_CrossChainTx proto.InternalMessageInfo

func (m *CrossChainTx) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *CrossChainTx) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

func (m *CrossChainTx) GetRelayedMessage() string {
	if m != nil {
		return m.RelayedMessage
	}
	return ""
}

func (m *CrossChainTx) GetCctxStatus() *Status {
	if m != nil {
		return m.CctxStatus
	}
	return nil
}

func (m *CrossChainTx) GetInboundParams() *InboundParams {
	if m != nil {
		return m.InboundParams
	}
	return nil
}

func (m *CrossChainTx) GetOutboundParams() []*OutboundParams {
	if m != nil {
		return m.OutboundParams
	}
	return nil
}

func init() {
	proto.RegisterEnum("zetachain.zetacore.crosschain.CctxStatus", CctxStatus_name, CctxStatus_value)
	proto.RegisterEnum("zetachain.zetacore.crosschain.TxFinalizationStatus", TxFinalizationStatus_name, TxFinalizationStatus_value)
	proto.RegisterType((*InboundParams)(nil), "zetachain.zetacore.crosschain.InboundParams")
	proto.RegisterType((*ZetaAccounting)(nil), "zetachain.zetacore.crosschain.ZetaAccounting")
	proto.RegisterType((*OutboundParams)(nil), "zetachain.zetacore.crosschain.OutboundParams")
	proto.RegisterType((*Status)(nil), "zetachain.zetacore.crosschain.Status")
	proto.RegisterType((*CrossChainTx)(nil), "zetachain.zetacore.crosschain.CrossChainTx")
}

func init() {
	proto.RegisterFile("zetachain/zetacore/crosschain/cross_chain_tx.proto", fileDescriptor_d4c1966807fb5cb2)
}

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

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

func (m *InboundParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TxFinalizationStatus != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.TxFinalizationStatus))
		i--
		dAtA[i] = 0x58
	}
	if m.FinalizedZetaHeight != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.FinalizedZetaHeight))
		i--
		dAtA[i] = 0x50
	}
	if len(m.BallotIndex) > 0 {
		i -= len(m.BallotIndex)
		copy(dAtA[i:], m.BallotIndex)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.BallotIndex)))
		i--
		dAtA[i] = 0x4a
	}
	if m.ObservedExternalHeight != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.ObservedExternalHeight))
		i--
		dAtA[i] = 0x40
	}
	if len(m.ObservedHash) > 0 {
		i -= len(m.ObservedHash)
		copy(dAtA[i:], m.ObservedHash)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.ObservedHash)))
		i--
		dAtA[i] = 0x3a
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintCrossChainTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if len(m.Asset) > 0 {
		i -= len(m.Asset)
		copy(dAtA[i:], m.Asset)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.Asset)))
		i--
		dAtA[i] = 0x2a
	}
	if m.CoinType != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.CoinType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.TxOrigin) > 0 {
		i -= len(m.TxOrigin)
		copy(dAtA[i:], m.TxOrigin)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.TxOrigin)))
		i--
		dAtA[i] = 0x1a
	}
	if m.SenderChainId != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.SenderChainId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ZetaAccounting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.AbortedZetaAmount.Size()
		i -= size
		if _, err := m.AbortedZetaAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintCrossChainTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *OutboundParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EffectiveGasLimit != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.EffectiveGasLimit))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb0
	}
	{
		size := m.EffectiveGasPrice.Size()
		i -= size
		if _, err := m.EffectiveGasPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintCrossChainTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xaa
	if m.GasUsed != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.GasUsed))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if m.TxFinalizationStatus != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.TxFinalizationStatus))
		i--
		dAtA[i] = 0x60
	}
	if len(m.TssPubkey) > 0 {
		i -= len(m.TssPubkey)
		copy(dAtA[i:], m.TssPubkey)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.TssPubkey)))
		i--
		dAtA[i] = 0x5a
	}
	if m.ObservedExternalHeight != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.ObservedExternalHeight))
		i--
		dAtA[i] = 0x50
	}
	if len(m.BallotIndex) > 0 {
		i -= len(m.BallotIndex)
		copy(dAtA[i:], m.BallotIndex)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.BallotIndex)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.GasPrice) > 0 {
		i -= len(m.GasPrice)
		copy(dAtA[i:], m.GasPrice)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.GasPrice)))
		i--
		dAtA[i] = 0x3a
	}
	if m.GasLimit != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.GasLimit))
		i--
		dAtA[i] = 0x30
	}
	if m.TssNonce != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.TssNonce))
		i--
		dAtA[i] = 0x28
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintCrossChainTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.CoinType != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.CoinType))
		i--
		dAtA[i] = 0x18
	}
	if m.ReceiverChainId != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.ReceiverChainId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Status) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsAbortRefunded {
		i--
		if m.IsAbortRefunded {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.LastUpdateTimestamp != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.LastUpdateTimestamp))
		i--
		dAtA[i] = 0x18
	}
	if len(m.StatusMessage) > 0 {
		i -= len(m.StatusMessage)
		copy(dAtA[i:], m.StatusMessage)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.StatusMessage)))
		i--
		dAtA[i] = 0x12
	}
	if m.Status != 0 {
		i = encodeVarintCrossChainTx(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CrossChainTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OutboundParams) > 0 {
		for iNdEx := len(m.OutboundParams) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OutboundParams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCrossChainTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if m.InboundParams != nil {
		{
			size, err := m.InboundParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCrossChainTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.CctxStatus != nil {
		{
			size, err := m.CctxStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCrossChainTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.RelayedMessage) > 0 {
		i -= len(m.RelayedMessage)
		copy(dAtA[i:], m.RelayedMessage)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.RelayedMessage)))
		i--
		dAtA[i] = 0x32
	}
	{
		size := m.ZetaFees.Size()
		i -= size
		if _, err := m.ZetaFees.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintCrossChainTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.Index) > 0 {
		i -= len(m.Index)
		copy(dAtA[i:], m.Index)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.Index)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintCrossChainTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintCrossChainTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovCrossChainTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *InboundParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.SenderChainId != 0 {
		n += 1 + sovCrossChainTx(uint64(m.SenderChainId))
	}
	l = len(m.TxOrigin)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.CoinType != 0 {
		n += 1 + sovCrossChainTx(uint64(m.CoinType))
	}
	l = len(m.Asset)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovCrossChainTx(uint64(l))
	l = len(m.ObservedHash)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.ObservedExternalHeight != 0 {
		n += 1 + sovCrossChainTx(uint64(m.ObservedExternalHeight))
	}
	l = len(m.BallotIndex)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.FinalizedZetaHeight != 0 {
		n += 1 + sovCrossChainTx(uint64(m.FinalizedZetaHeight))
	}
	if m.TxFinalizationStatus != 0 {
		n += 1 + sovCrossChainTx(uint64(m.TxFinalizationStatus))
	}
	return n
}

func (m *ZetaAccounting) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.AbortedZetaAmount.Size()
	n += 1 + l + sovCrossChainTx(uint64(l))
	return n
}

func (m *OutboundParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.ReceiverChainId != 0 {
		n += 1 + sovCrossChainTx(uint64(m.ReceiverChainId))
	}
	if m.CoinType != 0 {
		n += 1 + sovCrossChainTx(uint64(m.CoinType))
	}
	l = m.Amount.Size()
	n += 1 + l + sovCrossChainTx(uint64(l))
	if m.TssNonce != 0 {
		n += 1 + sovCrossChainTx(uint64(m.TssNonce))
	}
	if m.GasLimit != 0 {
		n += 1 + sovCrossChainTx(uint64(m.GasLimit))
	}
	l = len(m.GasPrice)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	l = len(m.BallotIndex)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.ObservedExternalHeight != 0 {
		n += 1 + sovCrossChainTx(uint64(m.ObservedExternalHeight))
	}
	l = len(m.TssPubkey)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.TxFinalizationStatus != 0 {
		n += 1 + sovCrossChainTx(uint64(m.TxFinalizationStatus))
	}
	if m.GasUsed != 0 {
		n += 2 + sovCrossChainTx(uint64(m.GasUsed))
	}
	l = m.EffectiveGasPrice.Size()
	n += 2 + l + sovCrossChainTx(uint64(l))
	if m.EffectiveGasLimit != 0 {
		n += 2 + sovCrossChainTx(uint64(m.EffectiveGasLimit))
	}
	return n
}

func (m *Status) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovCrossChainTx(uint64(m.Status))
	}
	l = len(m.StatusMessage)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.LastUpdateTimestamp != 0 {
		n += 1 + sovCrossChainTx(uint64(m.LastUpdateTimestamp))
	}
	if m.IsAbortRefunded {
		n += 2
	}
	return n
}

func (m *CrossChainTx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	l = len(m.Index)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	l = m.ZetaFees.Size()
	n += 1 + l + sovCrossChainTx(uint64(l))
	l = len(m.RelayedMessage)
	if l > 0 {
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.CctxStatus != nil {
		l = m.CctxStatus.Size()
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if m.InboundParams != nil {
		l = m.InboundParams.Size()
		n += 1 + l + sovCrossChainTx(uint64(l))
	}
	if len(m.OutboundParams) > 0 {
		for _, e := range m.OutboundParams {
			l = e.Size()
			n += 1 + l + sovCrossChainTx(uint64(l))
		}
	}
	return n
}

func sovCrossChainTx(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCrossChainTx(x uint64) (n int) {
	return sovCrossChainTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *InboundParams) 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 ErrIntOverflowCrossChainTx
			}
			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: InboundParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InboundParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderChainId", wireType)
			}
			m.SenderChainId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SenderChainId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxOrigin", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxOrigin = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoinType", wireType)
			}
			m.CoinType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CoinType |= coin.CoinType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Asset = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObservedHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedExternalHeight", wireType)
			}
			m.ObservedExternalHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedExternalHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BallotIndex", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BallotIndex = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinalizedZetaHeight", wireType)
			}
			m.FinalizedZetaHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FinalizedZetaHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxFinalizationStatus", wireType)
			}
			m.TxFinalizationStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TxFinalizationStatus |= TxFinalizationStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCrossChainTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ZetaAccounting) 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 ErrIntOverflowCrossChainTx
			}
			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: ZetaAccounting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ZetaAccounting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AbortedZetaAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AbortedZetaAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCrossChainTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutboundParams) 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 ErrIntOverflowCrossChainTx
			}
			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: OutboundParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutboundParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceiverChainId", wireType)
			}
			m.ReceiverChainId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReceiverChainId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoinType", wireType)
			}
			m.CoinType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CoinType |= coin.CoinType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TssNonce", wireType)
			}
			m.TssNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TssNonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType)
			}
			m.GasLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GasLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GasPrice = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BallotIndex", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BallotIndex = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedExternalHeight", wireType)
			}
			m.ObservedExternalHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedExternalHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TssPubkey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TssPubkey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxFinalizationStatus", wireType)
			}
			m.TxFinalizationStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TxFinalizationStatus |= TxFinalizationStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType)
			}
			m.GasUsed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GasUsed |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveGasPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EffectiveGasPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveGasLimit", wireType)
			}
			m.EffectiveGasLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EffectiveGasLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCrossChainTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Status) 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 ErrIntOverflowCrossChainTx
			}
			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: Status: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= CctxStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusMessage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StatusMessage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTimestamp", wireType)
			}
			m.LastUpdateTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastUpdateTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAbortRefunded", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsAbortRefunded = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCrossChainTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CrossChainTx) 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 ErrIntOverflowCrossChainTx
			}
			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: CrossChainTx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossChainTx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Index = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZetaFees", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ZetaFees.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayedMessage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				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 ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelayedMessage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CctxStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CctxStatus == nil {
				m.CctxStatus = &Status{}
			}
			if err := m.CctxStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InboundParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InboundParams == nil {
				m.InboundParams = &InboundParams{}
			}
			if err := m.InboundParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutboundParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCrossChainTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutboundParams = append(m.OutboundParams, &OutboundParams{})
			if err := m.OutboundParams[len(m.OutboundParams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCrossChainTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCrossChainTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthCrossChainTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCrossChainTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCrossChainTx = fmt.Errorf("proto: unexpected end of group")
)