pool/poolrpc/auctioneer.pb.go

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

package poolrpc

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

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

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

type ChannelType int32

const (
	// The channel supports static to_remote keys.
	ChannelType_TWEAKLESS ChannelType = 0
	// The channel uses an anchor-based commitment.
	ChannelType_ANCHORS ChannelType = 1
)

var ChannelType_name = map[int32]string{
	0: "TWEAKLESS",
	1: "ANCHORS",
}

var ChannelType_value = map[string]int32{
	"TWEAKLESS": 0,
	"ANCHORS":   1,
}

func (x ChannelType) String() string {
	return proto.EnumName(ChannelType_name, int32(x))
}

func (ChannelType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{0}
}

type AuctionAccountState int32

const (
	//
	//The account's funding transaction is not yet confirmed on-chain.
	AuctionAccountState_STATE_PENDING_OPEN AuctionAccountState = 0
	//
	//The account is fully open and confirmed on-chain.
	AuctionAccountState_STATE_OPEN AuctionAccountState = 1
	//
	//The account is still open but the CLTV expiry has passed and the trader can
	//close it without the auctioneer's key. Orders for accounts in this state
	//won't be accepted.
	AuctionAccountState_STATE_EXPIRED AuctionAccountState = 2
	//
	//The account was modified by a deposit or withdrawal and is currently waiting
	//for the modifying transaction to confirm.
	AuctionAccountState_STATE_PENDING_UPDATE AuctionAccountState = 3
	//
	//The account is closed. The auctioneer doesn't track whether the closing
	//transaction is already confirmed on-chain or not.
	AuctionAccountState_STATE_CLOSED AuctionAccountState = 4
	//
	//The account has recently participated in a batch and is not yet confirmed.
	AuctionAccountState_STATE_PENDING_BATCH AuctionAccountState = 5
)

var AuctionAccountState_name = map[int32]string{
	0: "STATE_PENDING_OPEN",
	1: "STATE_OPEN",
	2: "STATE_EXPIRED",
	3: "STATE_PENDING_UPDATE",
	4: "STATE_CLOSED",
	5: "STATE_PENDING_BATCH",
}

var AuctionAccountState_value = map[string]int32{
	"STATE_PENDING_OPEN":   0,
	"STATE_OPEN":           1,
	"STATE_EXPIRED":        2,
	"STATE_PENDING_UPDATE": 3,
	"STATE_CLOSED":         4,
	"STATE_PENDING_BATCH":  5,
}

func (x AuctionAccountState) String() string {
	return proto.EnumName(AuctionAccountState_name, int32(x))
}

func (AuctionAccountState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{1}
}

type NodeTier int32

const (
	// The default node tier. This value will be determined at run-time by the
	// current order version.
	NodeTier_TIER_DEFAULT NodeTier = 0
	// Tier 0, bid with this tier are opting out of the smaller "higher
	// quality" pool of nodes to match their bids. Nodes in this tier are
	// considered to have "no rating".
	NodeTier_TIER_0 NodeTier = 1
	// Tier 1, the "base" node tier. Nodes in this tier are shown to have a
	// higher degree of up time and route-ability compared to the rest of the
	// nodes in the network. This is the current default node tier when
	// submitting bid orders.
	NodeTier_TIER_1 NodeTier = 2
)

var NodeTier_name = map[int32]string{
	0: "TIER_DEFAULT",
	1: "TIER_0",
	2: "TIER_1",
}

var NodeTier_value = map[string]int32{
	"TIER_DEFAULT": 0,
	"TIER_0":       1,
	"TIER_1":       2,
}

func (x NodeTier) String() string {
	return proto.EnumName(NodeTier_name, int32(x))
}

func (NodeTier) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{2}
}

type OrderState int32

const (
	OrderState_ORDER_SUBMITTED        OrderState = 0
	OrderState_ORDER_CLEARED          OrderState = 1
	OrderState_ORDER_PARTIALLY_FILLED OrderState = 2
	OrderState_ORDER_EXECUTED         OrderState = 3
	OrderState_ORDER_CANCELED         OrderState = 4
	OrderState_ORDER_EXPIRED          OrderState = 5
	OrderState_ORDER_FAILED           OrderState = 6
)

var OrderState_name = map[int32]string{
	0: "ORDER_SUBMITTED",
	1: "ORDER_CLEARED",
	2: "ORDER_PARTIALLY_FILLED",
	3: "ORDER_EXECUTED",
	4: "ORDER_CANCELED",
	5: "ORDER_EXPIRED",
	6: "ORDER_FAILED",
}

var OrderState_value = map[string]int32{
	"ORDER_SUBMITTED":        0,
	"ORDER_CLEARED":          1,
	"ORDER_PARTIALLY_FILLED": 2,
	"ORDER_EXECUTED":         3,
	"ORDER_CANCELED":         4,
	"ORDER_EXPIRED":          5,
	"ORDER_FAILED":           6,
}

func (x OrderState) String() string {
	return proto.EnumName(OrderState_name, int32(x))
}

func (OrderState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{3}
}

type OrderMatchReject_RejectReason int32

const (
	// The reason cannot be mapped to a specific code.
	OrderMatchReject_UNKNOWN OrderMatchReject_RejectReason = 0
	//
	//The client didn't come up with the same result as the server and is
	//rejecting the batch because of that.
	OrderMatchReject_SERVER_MISBEHAVIOR OrderMatchReject_RejectReason = 1
	//
	//The client doesn't support the current batch verification version the
	//server is using.
	OrderMatchReject_BATCH_VERSION_MISMATCH OrderMatchReject_RejectReason = 2
	//
	//The client rejects some of the orders, not the full batch. When this
	//code is set, the rejected_orders map must be set.
	OrderMatchReject_PARTIAL_REJECT OrderMatchReject_RejectReason = 3
)

var OrderMatchReject_RejectReason_name = map[int32]string{
	0: "UNKNOWN",
	1: "SERVER_MISBEHAVIOR",
	2: "BATCH_VERSION_MISMATCH",
	3: "PARTIAL_REJECT",
}

var OrderMatchReject_RejectReason_value = map[string]int32{
	"UNKNOWN":                0,
	"SERVER_MISBEHAVIOR":     1,
	"BATCH_VERSION_MISMATCH": 2,
	"PARTIAL_REJECT":         3,
}

func (x OrderMatchReject_RejectReason) String() string {
	return proto.EnumName(OrderMatchReject_RejectReason_name, int32(x))
}

func (OrderMatchReject_RejectReason) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{12, 0}
}

type OrderReject_OrderRejectReason int32

const (
	//
	//The trader's client has a preference to only match orders with peers it
	//doesn't already have channels with. The order that is rejected with this
	//reason type comes from a peer that the trader already has channels with.
	OrderReject_DUPLICATE_PEER OrderReject_OrderRejectReason = 0
	//
	//The trader's client couldn't connect to the remote node of the matched
	//order or the channel funding could not be initialized for another
	//reason. This could also be the rejecting node's fault if their
	//connection is not stable. Using this code can have a negative impact on
	//the reputation score of both nodes, depending on the number of errors
	//recorded.
	OrderReject_CHANNEL_FUNDING_FAILED OrderReject_OrderRejectReason = 1
)

var OrderReject_OrderRejectReason_name = map[int32]string{
	0: "DUPLICATE_PEER",
	1: "CHANNEL_FUNDING_FAILED",
}

var OrderReject_OrderRejectReason_value = map[string]int32{
	"DUPLICATE_PEER":         0,
	"CHANNEL_FUNDING_FAILED": 1,
}

func (x OrderReject_OrderRejectReason) String() string {
	return proto.EnumName(OrderReject_OrderRejectReason_name, int32(x))
}

func (OrderReject_OrderRejectReason) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{13, 0}
}

type SubscribeError_Error int32

const (
	//
	//The error cannot be mapped to a specific code.
	SubscribeError_UNKNOWN SubscribeError_Error = 0
	//
	//The server is shutting down for maintenance. Traders should close the
	//long-lived stream/connection and try to connect again after some time.
	SubscribeError_SERVER_SHUTDOWN SubscribeError_Error = 1
	//
	//The account the trader tried to subscribe to does not exist in the
	//auctioneer's database.
	SubscribeError_ACCOUNT_DOES_NOT_EXIST SubscribeError_Error = 2
	//
	//The account the trader tried to subscribe to was never completed and a
	//reservation for it is still pending.
	SubscribeError_INCOMPLETE_ACCOUNT_RESERVATION SubscribeError_Error = 3
)

var SubscribeError_Error_name = map[int32]string{
	0: "UNKNOWN",
	1: "SERVER_SHUTDOWN",
	2: "ACCOUNT_DOES_NOT_EXIST",
	3: "INCOMPLETE_ACCOUNT_RESERVATION",
}

var SubscribeError_Error_value = map[string]int32{
	"UNKNOWN":                        0,
	"SERVER_SHUTDOWN":                1,
	"ACCOUNT_DOES_NOT_EXIST":         2,
	"INCOMPLETE_ACCOUNT_RESERVATION": 3,
}

func (x SubscribeError_Error) String() string {
	return proto.EnumName(SubscribeError_Error_name, int32(x))
}

func (SubscribeError_Error) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{23, 0}
}

type AccountDiff_AccountState int32

const (
	AccountDiff_OUTPUT_RECREATED              AccountDiff_AccountState = 0
	AccountDiff_OUTPUT_DUST_EXTENDED_OFFCHAIN AccountDiff_AccountState = 1
	AccountDiff_OUTPUT_DUST_ADDED_TO_FEES     AccountDiff_AccountState = 2
	AccountDiff_OUTPUT_FULLY_SPENT            AccountDiff_AccountState = 3
)

var AccountDiff_AccountState_name = map[int32]string{
	0: "OUTPUT_RECREATED",
	1: "OUTPUT_DUST_EXTENDED_OFFCHAIN",
	2: "OUTPUT_DUST_ADDED_TO_FEES",
	3: "OUTPUT_FULLY_SPENT",
}

var AccountDiff_AccountState_value = map[string]int32{
	"OUTPUT_RECREATED":              0,
	"OUTPUT_DUST_EXTENDED_OFFCHAIN": 1,
	"OUTPUT_DUST_ADDED_TO_FEES":     2,
	"OUTPUT_FULLY_SPENT":            3,
}

func (x AccountDiff_AccountState) String() string {
	return proto.EnumName(AccountDiff_AccountState_name, int32(x))
}

func (AccountDiff_AccountState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{28, 0}
}

type InvalidOrder_FailReason int32

const (
	InvalidOrder_INVALID_AMT InvalidOrder_FailReason = 0
)

var InvalidOrder_FailReason_name = map[int32]string{
	0: "INVALID_AMT",
}

var InvalidOrder_FailReason_value = map[string]int32{
	"INVALID_AMT": 0,
}

func (x InvalidOrder_FailReason) String() string {
	return proto.EnumName(InvalidOrder_FailReason_name, int32(x))
}

func (InvalidOrder_FailReason) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{33, 0}
}

type ReserveAccountRequest struct {
	//
	//The desired value of the account in satoshis.
	AccountValue uint64 `protobuf:"varint,1,opt,name=account_value,json=accountValue,proto3" json:"account_value,omitempty"`
	//
	//The block height at which the account should expire.
	AccountExpiry uint32 `protobuf:"varint,2,opt,name=account_expiry,json=accountExpiry,proto3" json:"account_expiry,omitempty"`
	//
	//The trader's account key.
	TraderKey            []byte   `protobuf:"bytes,3,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReserveAccountRequest) Reset()         { *m = ReserveAccountRequest{} }
func (m *ReserveAccountRequest) String() string { return proto.CompactTextString(m) }
func (*ReserveAccountRequest) ProtoMessage()    {}
func (*ReserveAccountRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{0}
}

func (m *ReserveAccountRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReserveAccountRequest.Unmarshal(m, b)
}
func (m *ReserveAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReserveAccountRequest.Marshal(b, m, deterministic)
}
func (m *ReserveAccountRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReserveAccountRequest.Merge(m, src)
}
func (m *ReserveAccountRequest) XXX_Size() int {
	return xxx_messageInfo_ReserveAccountRequest.Size(m)
}
func (m *ReserveAccountRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ReserveAccountRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ReserveAccountRequest proto.InternalMessageInfo

func (m *ReserveAccountRequest) GetAccountValue() uint64 {
	if m != nil {
		return m.AccountValue
	}
	return 0
}

func (m *ReserveAccountRequest) GetAccountExpiry() uint32 {
	if m != nil {
		return m.AccountExpiry
	}
	return 0
}

func (m *ReserveAccountRequest) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

type ReserveAccountResponse struct {
	//
	//The base key of the auctioneer. This key should be tweaked with the trader's
	//per-batch tweaked key to obtain the corresponding per-batch tweaked
	//auctioneer key.
	AuctioneerKey []byte `protobuf:"bytes,1,opt,name=auctioneer_key,json=auctioneerKey,proto3" json:"auctioneer_key,omitempty"`
	//
	//The initial per-batch key to be used for the account. For every cleared
	//batch that the account participates in, this key will be incremented by the
	//base point of its curve, resulting in a new key for both the trader and
	//auctioneer in every batch.
	InitialBatchKey      []byte   `protobuf:"bytes,2,opt,name=initial_batch_key,json=initialBatchKey,proto3" json:"initial_batch_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReserveAccountResponse) Reset()         { *m = ReserveAccountResponse{} }
func (m *ReserveAccountResponse) String() string { return proto.CompactTextString(m) }
func (*ReserveAccountResponse) ProtoMessage()    {}
func (*ReserveAccountResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{1}
}

func (m *ReserveAccountResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReserveAccountResponse.Unmarshal(m, b)
}
func (m *ReserveAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReserveAccountResponse.Marshal(b, m, deterministic)
}
func (m *ReserveAccountResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReserveAccountResponse.Merge(m, src)
}
func (m *ReserveAccountResponse) XXX_Size() int {
	return xxx_messageInfo_ReserveAccountResponse.Size(m)
}
func (m *ReserveAccountResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ReserveAccountResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ReserveAccountResponse proto.InternalMessageInfo

func (m *ReserveAccountResponse) GetAuctioneerKey() []byte {
	if m != nil {
		return m.AuctioneerKey
	}
	return nil
}

func (m *ReserveAccountResponse) GetInitialBatchKey() []byte {
	if m != nil {
		return m.InitialBatchKey
	}
	return nil
}

type ServerInitAccountRequest struct {
	//
	//Transaction output of the account. Has to be unspent and be a P2WSH of
	//the account script below. The amount must also exactly correspond to the
	//account value below.
	AccountPoint *OutPoint `protobuf:"bytes,1,opt,name=account_point,json=accountPoint,proto3" json:"account_point,omitempty"`
	//
	//The script used to create the account point.
	AccountScript []byte `protobuf:"bytes,2,opt,name=account_script,json=accountScript,proto3" json:"account_script,omitempty"`
	//
	//The value of the account in satoshis. Must match the amount of the
	//account_point output.
	AccountValue uint64 `protobuf:"varint,3,opt,name=account_value,json=accountValue,proto3" json:"account_value,omitempty"`
	//
	//The block height at which the account should expire.
	AccountExpiry uint32 `protobuf:"varint,4,opt,name=account_expiry,json=accountExpiry,proto3" json:"account_expiry,omitempty"`
	//
	//The trader's account key.
	TraderKey            []byte   `protobuf:"bytes,5,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerInitAccountRequest) Reset()         { *m = ServerInitAccountRequest{} }
func (m *ServerInitAccountRequest) String() string { return proto.CompactTextString(m) }
func (*ServerInitAccountRequest) ProtoMessage()    {}
func (*ServerInitAccountRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{2}
}

func (m *ServerInitAccountRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerInitAccountRequest.Unmarshal(m, b)
}
func (m *ServerInitAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerInitAccountRequest.Marshal(b, m, deterministic)
}
func (m *ServerInitAccountRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerInitAccountRequest.Merge(m, src)
}
func (m *ServerInitAccountRequest) XXX_Size() int {
	return xxx_messageInfo_ServerInitAccountRequest.Size(m)
}
func (m *ServerInitAccountRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerInitAccountRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServerInitAccountRequest proto.InternalMessageInfo

func (m *ServerInitAccountRequest) GetAccountPoint() *OutPoint {
	if m != nil {
		return m.AccountPoint
	}
	return nil
}

func (m *ServerInitAccountRequest) GetAccountScript() []byte {
	if m != nil {
		return m.AccountScript
	}
	return nil
}

func (m *ServerInitAccountRequest) GetAccountValue() uint64 {
	if m != nil {
		return m.AccountValue
	}
	return 0
}

func (m *ServerInitAccountRequest) GetAccountExpiry() uint32 {
	if m != nil {
		return m.AccountExpiry
	}
	return 0
}

func (m *ServerInitAccountRequest) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

type ServerInitAccountResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerInitAccountResponse) Reset()         { *m = ServerInitAccountResponse{} }
func (m *ServerInitAccountResponse) String() string { return proto.CompactTextString(m) }
func (*ServerInitAccountResponse) ProtoMessage()    {}
func (*ServerInitAccountResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{3}
}

func (m *ServerInitAccountResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerInitAccountResponse.Unmarshal(m, b)
}
func (m *ServerInitAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerInitAccountResponse.Marshal(b, m, deterministic)
}
func (m *ServerInitAccountResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerInitAccountResponse.Merge(m, src)
}
func (m *ServerInitAccountResponse) XXX_Size() int {
	return xxx_messageInfo_ServerInitAccountResponse.Size(m)
}
func (m *ServerInitAccountResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerInitAccountResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ServerInitAccountResponse proto.InternalMessageInfo

type ServerSubmitOrderRequest struct {
	// Types that are valid to be assigned to Details:
	//	*ServerSubmitOrderRequest_Ask
	//	*ServerSubmitOrderRequest_Bid
	Details              isServerSubmitOrderRequest_Details `protobuf_oneof:"details"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

func (m *ServerSubmitOrderRequest) Reset()         { *m = ServerSubmitOrderRequest{} }
func (m *ServerSubmitOrderRequest) String() string { return proto.CompactTextString(m) }
func (*ServerSubmitOrderRequest) ProtoMessage()    {}
func (*ServerSubmitOrderRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{4}
}

func (m *ServerSubmitOrderRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerSubmitOrderRequest.Unmarshal(m, b)
}
func (m *ServerSubmitOrderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerSubmitOrderRequest.Marshal(b, m, deterministic)
}
func (m *ServerSubmitOrderRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerSubmitOrderRequest.Merge(m, src)
}
func (m *ServerSubmitOrderRequest) XXX_Size() int {
	return xxx_messageInfo_ServerSubmitOrderRequest.Size(m)
}
func (m *ServerSubmitOrderRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerSubmitOrderRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServerSubmitOrderRequest proto.InternalMessageInfo

type isServerSubmitOrderRequest_Details interface {
	isServerSubmitOrderRequest_Details()
}

type ServerSubmitOrderRequest_Ask struct {
	Ask *ServerAsk `protobuf:"bytes,1,opt,name=ask,proto3,oneof"`
}

type ServerSubmitOrderRequest_Bid struct {
	Bid *ServerBid `protobuf:"bytes,2,opt,name=bid,proto3,oneof"`
}

func (*ServerSubmitOrderRequest_Ask) isServerSubmitOrderRequest_Details() {}

func (*ServerSubmitOrderRequest_Bid) isServerSubmitOrderRequest_Details() {}

func (m *ServerSubmitOrderRequest) GetDetails() isServerSubmitOrderRequest_Details {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *ServerSubmitOrderRequest) GetAsk() *ServerAsk {
	if x, ok := m.GetDetails().(*ServerSubmitOrderRequest_Ask); ok {
		return x.Ask
	}
	return nil
}

func (m *ServerSubmitOrderRequest) GetBid() *ServerBid {
	if x, ok := m.GetDetails().(*ServerSubmitOrderRequest_Bid); ok {
		return x.Bid
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ServerSubmitOrderRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ServerSubmitOrderRequest_Ask)(nil),
		(*ServerSubmitOrderRequest_Bid)(nil),
	}
}

type ServerSubmitOrderResponse struct {
	// Types that are valid to be assigned to Details:
	//	*ServerSubmitOrderResponse_InvalidOrder
	//	*ServerSubmitOrderResponse_Accepted
	Details              isServerSubmitOrderResponse_Details `protobuf_oneof:"details"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

func (m *ServerSubmitOrderResponse) Reset()         { *m = ServerSubmitOrderResponse{} }
func (m *ServerSubmitOrderResponse) String() string { return proto.CompactTextString(m) }
func (*ServerSubmitOrderResponse) ProtoMessage()    {}
func (*ServerSubmitOrderResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{5}
}

func (m *ServerSubmitOrderResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerSubmitOrderResponse.Unmarshal(m, b)
}
func (m *ServerSubmitOrderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerSubmitOrderResponse.Marshal(b, m, deterministic)
}
func (m *ServerSubmitOrderResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerSubmitOrderResponse.Merge(m, src)
}
func (m *ServerSubmitOrderResponse) XXX_Size() int {
	return xxx_messageInfo_ServerSubmitOrderResponse.Size(m)
}
func (m *ServerSubmitOrderResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerSubmitOrderResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ServerSubmitOrderResponse proto.InternalMessageInfo

type isServerSubmitOrderResponse_Details interface {
	isServerSubmitOrderResponse_Details()
}

type ServerSubmitOrderResponse_InvalidOrder struct {
	InvalidOrder *InvalidOrder `protobuf:"bytes,1,opt,name=invalid_order,json=invalidOrder,proto3,oneof"`
}

type ServerSubmitOrderResponse_Accepted struct {
	Accepted bool `protobuf:"varint,2,opt,name=accepted,proto3,oneof"`
}

func (*ServerSubmitOrderResponse_InvalidOrder) isServerSubmitOrderResponse_Details() {}

func (*ServerSubmitOrderResponse_Accepted) isServerSubmitOrderResponse_Details() {}

func (m *ServerSubmitOrderResponse) GetDetails() isServerSubmitOrderResponse_Details {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *ServerSubmitOrderResponse) GetInvalidOrder() *InvalidOrder {
	if x, ok := m.GetDetails().(*ServerSubmitOrderResponse_InvalidOrder); ok {
		return x.InvalidOrder
	}
	return nil
}

func (m *ServerSubmitOrderResponse) GetAccepted() bool {
	if x, ok := m.GetDetails().(*ServerSubmitOrderResponse_Accepted); ok {
		return x.Accepted
	}
	return false
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ServerSubmitOrderResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ServerSubmitOrderResponse_InvalidOrder)(nil),
		(*ServerSubmitOrderResponse_Accepted)(nil),
	}
}

type ServerCancelOrderRequest struct {
	//
	//The order's unique 32 byte identifier.
	OrderNonce           []byte   `protobuf:"bytes,1,opt,name=order_nonce,json=orderNonce,proto3" json:"order_nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerCancelOrderRequest) Reset()         { *m = ServerCancelOrderRequest{} }
func (m *ServerCancelOrderRequest) String() string { return proto.CompactTextString(m) }
func (*ServerCancelOrderRequest) ProtoMessage()    {}
func (*ServerCancelOrderRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{6}
}

func (m *ServerCancelOrderRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerCancelOrderRequest.Unmarshal(m, b)
}
func (m *ServerCancelOrderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerCancelOrderRequest.Marshal(b, m, deterministic)
}
func (m *ServerCancelOrderRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerCancelOrderRequest.Merge(m, src)
}
func (m *ServerCancelOrderRequest) XXX_Size() int {
	return xxx_messageInfo_ServerCancelOrderRequest.Size(m)
}
func (m *ServerCancelOrderRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerCancelOrderRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServerCancelOrderRequest proto.InternalMessageInfo

func (m *ServerCancelOrderRequest) GetOrderNonce() []byte {
	if m != nil {
		return m.OrderNonce
	}
	return nil
}

type ServerCancelOrderResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerCancelOrderResponse) Reset()         { *m = ServerCancelOrderResponse{} }
func (m *ServerCancelOrderResponse) String() string { return proto.CompactTextString(m) }
func (*ServerCancelOrderResponse) ProtoMessage()    {}
func (*ServerCancelOrderResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{7}
}

func (m *ServerCancelOrderResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerCancelOrderResponse.Unmarshal(m, b)
}
func (m *ServerCancelOrderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerCancelOrderResponse.Marshal(b, m, deterministic)
}
func (m *ServerCancelOrderResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerCancelOrderResponse.Merge(m, src)
}
func (m *ServerCancelOrderResponse) XXX_Size() int {
	return xxx_messageInfo_ServerCancelOrderResponse.Size(m)
}
func (m *ServerCancelOrderResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerCancelOrderResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ServerCancelOrderResponse proto.InternalMessageInfo

type ClientAuctionMessage struct {
	// Types that are valid to be assigned to Msg:
	//	*ClientAuctionMessage_Commit
	//	*ClientAuctionMessage_Subscribe
	//	*ClientAuctionMessage_Accept
	//	*ClientAuctionMessage_Reject
	//	*ClientAuctionMessage_Sign
	//	*ClientAuctionMessage_Recover
	Msg                  isClientAuctionMessage_Msg `protobuf_oneof:"msg"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *ClientAuctionMessage) Reset()         { *m = ClientAuctionMessage{} }
func (m *ClientAuctionMessage) String() string { return proto.CompactTextString(m) }
func (*ClientAuctionMessage) ProtoMessage()    {}
func (*ClientAuctionMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{8}
}

func (m *ClientAuctionMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientAuctionMessage.Unmarshal(m, b)
}
func (m *ClientAuctionMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientAuctionMessage.Marshal(b, m, deterministic)
}
func (m *ClientAuctionMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientAuctionMessage.Merge(m, src)
}
func (m *ClientAuctionMessage) XXX_Size() int {
	return xxx_messageInfo_ClientAuctionMessage.Size(m)
}
func (m *ClientAuctionMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientAuctionMessage.DiscardUnknown(m)
}

var xxx_messageInfo_ClientAuctionMessage proto.InternalMessageInfo

type isClientAuctionMessage_Msg interface {
	isClientAuctionMessage_Msg()
}

type ClientAuctionMessage_Commit struct {
	Commit *AccountCommitment `protobuf:"bytes,1,opt,name=commit,proto3,oneof"`
}

type ClientAuctionMessage_Subscribe struct {
	Subscribe *AccountSubscription `protobuf:"bytes,2,opt,name=subscribe,proto3,oneof"`
}

type ClientAuctionMessage_Accept struct {
	Accept *OrderMatchAccept `protobuf:"bytes,3,opt,name=accept,proto3,oneof"`
}

type ClientAuctionMessage_Reject struct {
	Reject *OrderMatchReject `protobuf:"bytes,4,opt,name=reject,proto3,oneof"`
}

type ClientAuctionMessage_Sign struct {
	Sign *OrderMatchSign `protobuf:"bytes,5,opt,name=sign,proto3,oneof"`
}

type ClientAuctionMessage_Recover struct {
	Recover *AccountRecovery `protobuf:"bytes,6,opt,name=recover,proto3,oneof"`
}

func (*ClientAuctionMessage_Commit) isClientAuctionMessage_Msg() {}

func (*ClientAuctionMessage_Subscribe) isClientAuctionMessage_Msg() {}

func (*ClientAuctionMessage_Accept) isClientAuctionMessage_Msg() {}

func (*ClientAuctionMessage_Reject) isClientAuctionMessage_Msg() {}

func (*ClientAuctionMessage_Sign) isClientAuctionMessage_Msg() {}

func (*ClientAuctionMessage_Recover) isClientAuctionMessage_Msg() {}

func (m *ClientAuctionMessage) GetMsg() isClientAuctionMessage_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *ClientAuctionMessage) GetCommit() *AccountCommitment {
	if x, ok := m.GetMsg().(*ClientAuctionMessage_Commit); ok {
		return x.Commit
	}
	return nil
}

func (m *ClientAuctionMessage) GetSubscribe() *AccountSubscription {
	if x, ok := m.GetMsg().(*ClientAuctionMessage_Subscribe); ok {
		return x.Subscribe
	}
	return nil
}

func (m *ClientAuctionMessage) GetAccept() *OrderMatchAccept {
	if x, ok := m.GetMsg().(*ClientAuctionMessage_Accept); ok {
		return x.Accept
	}
	return nil
}

func (m *ClientAuctionMessage) GetReject() *OrderMatchReject {
	if x, ok := m.GetMsg().(*ClientAuctionMessage_Reject); ok {
		return x.Reject
	}
	return nil
}

func (m *ClientAuctionMessage) GetSign() *OrderMatchSign {
	if x, ok := m.GetMsg().(*ClientAuctionMessage_Sign); ok {
		return x.Sign
	}
	return nil
}

func (m *ClientAuctionMessage) GetRecover() *AccountRecovery {
	if x, ok := m.GetMsg().(*ClientAuctionMessage_Recover); ok {
		return x.Recover
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ClientAuctionMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ClientAuctionMessage_Commit)(nil),
		(*ClientAuctionMessage_Subscribe)(nil),
		(*ClientAuctionMessage_Accept)(nil),
		(*ClientAuctionMessage_Reject)(nil),
		(*ClientAuctionMessage_Sign)(nil),
		(*ClientAuctionMessage_Recover)(nil),
	}
}

type AccountCommitment struct {
	//
	//The SHA256 hash of the trader's account key and a 32 byte random nonce.
	//commit_hash = SHA256(accountPubKey || nonce)
	CommitHash []byte `protobuf:"bytes,1,opt,name=commit_hash,json=commitHash,proto3" json:"commit_hash,omitempty"`
	//
	//The batch verification protocol version the client is using. Clients that
	//don't use the latest version will be declined to connect and participate in
	//an auction. The user should then be informed that a software update is
	//required.
	BatchVersion         uint32   `protobuf:"varint,2,opt,name=batch_version,json=batchVersion,proto3" json:"batch_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccountCommitment) Reset()         { *m = AccountCommitment{} }
func (m *AccountCommitment) String() string { return proto.CompactTextString(m) }
func (*AccountCommitment) ProtoMessage()    {}
func (*AccountCommitment) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{9}
}

func (m *AccountCommitment) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccountCommitment.Unmarshal(m, b)
}
func (m *AccountCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccountCommitment.Marshal(b, m, deterministic)
}
func (m *AccountCommitment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountCommitment.Merge(m, src)
}
func (m *AccountCommitment) XXX_Size() int {
	return xxx_messageInfo_AccountCommitment.Size(m)
}
func (m *AccountCommitment) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountCommitment.DiscardUnknown(m)
}

var xxx_messageInfo_AccountCommitment proto.InternalMessageInfo

func (m *AccountCommitment) GetCommitHash() []byte {
	if m != nil {
		return m.CommitHash
	}
	return nil
}

func (m *AccountCommitment) GetBatchVersion() uint32 {
	if m != nil {
		return m.BatchVersion
	}
	return 0
}

type AccountSubscription struct {
	//
	//The trader's account key of the account to subscribe to.
	TraderKey []byte `protobuf:"bytes,1,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	//
	//The random 32 byte nonce the trader used to create the commitment hash.
	CommitNonce []byte `protobuf:"bytes,2,opt,name=commit_nonce,json=commitNonce,proto3" json:"commit_nonce,omitempty"`
	//
	//The signature over the auth_hash which is the hash of the commitment and
	//challenge. The signature is created with the trader's account key they
	//committed to.
	//auth_hash = SHA256(SHA256(accountPubKey || nonce) || challenge)
	AuthSig              []byte   `protobuf:"bytes,3,opt,name=auth_sig,json=authSig,proto3" json:"auth_sig,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccountSubscription) Reset()         { *m = AccountSubscription{} }
func (m *AccountSubscription) String() string { return proto.CompactTextString(m) }
func (*AccountSubscription) ProtoMessage()    {}
func (*AccountSubscription) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{10}
}

func (m *AccountSubscription) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccountSubscription.Unmarshal(m, b)
}
func (m *AccountSubscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccountSubscription.Marshal(b, m, deterministic)
}
func (m *AccountSubscription) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountSubscription.Merge(m, src)
}
func (m *AccountSubscription) XXX_Size() int {
	return xxx_messageInfo_AccountSubscription.Size(m)
}
func (m *AccountSubscription) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountSubscription.DiscardUnknown(m)
}

var xxx_messageInfo_AccountSubscription proto.InternalMessageInfo

func (m *AccountSubscription) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

func (m *AccountSubscription) GetCommitNonce() []byte {
	if m != nil {
		return m.CommitNonce
	}
	return nil
}

func (m *AccountSubscription) GetAuthSig() []byte {
	if m != nil {
		return m.AuthSig
	}
	return nil
}

type OrderMatchAccept struct {
	//
	//The batch ID this acceptance message refers to. Must be set to avoid out-of-
	//order responses from disrupting the batching process.
	BatchId              []byte   `protobuf:"bytes,1,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OrderMatchAccept) Reset()         { *m = OrderMatchAccept{} }
func (m *OrderMatchAccept) String() string { return proto.CompactTextString(m) }
func (*OrderMatchAccept) ProtoMessage()    {}
func (*OrderMatchAccept) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{11}
}

func (m *OrderMatchAccept) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrderMatchAccept.Unmarshal(m, b)
}
func (m *OrderMatchAccept) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrderMatchAccept.Marshal(b, m, deterministic)
}
func (m *OrderMatchAccept) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderMatchAccept.Merge(m, src)
}
func (m *OrderMatchAccept) XXX_Size() int {
	return xxx_messageInfo_OrderMatchAccept.Size(m)
}
func (m *OrderMatchAccept) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderMatchAccept.DiscardUnknown(m)
}

var xxx_messageInfo_OrderMatchAccept proto.InternalMessageInfo

func (m *OrderMatchAccept) GetBatchId() []byte {
	if m != nil {
		return m.BatchId
	}
	return nil
}

type OrderMatchReject struct {
	//
	//The ID of the batch to reject.
	BatchId []byte `protobuf:"bytes,1,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	//
	//The reason/error string for the rejection.
	Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	//
	//The reason as a code.
	ReasonCode OrderMatchReject_RejectReason `protobuf:"varint,3,opt,name=reason_code,json=reasonCode,proto3,enum=poolrpc.OrderMatchReject_RejectReason" json:"reason_code,omitempty"`
	//
	//The map of order nonces the trader was matched with but doesn't accept. The
	//map contains the _other_ trader's order nonces and the reason for rejecting
	//them. This can be a subset of the whole list of orders presented as matches
	//if the trader only wants to reject some of them. This map is only
	//considered by the auctioneer if the main reason_code is set to
	//PARTIAL_REJECT. Otherwise it is assumed that the whole batch was faulty for
	//some reason and that the trader rejects all orders contained. The auctioneer
	//will only accept a certain number of these partial rejects before a trader's
	//account is removed completely from the current batch. Abusing this
	//functionality can also lead to a ban of the trader.
	//
	//The order nonces are hex encoded strings because the protobuf map doesn't
	//allow raw bytes to be the map key type.
	RejectedOrders       map[string]*OrderReject `protobuf:"bytes,4,rep,name=rejected_orders,json=rejectedOrders,proto3" json:"rejected_orders,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *OrderMatchReject) Reset()         { *m = OrderMatchReject{} }
func (m *OrderMatchReject) String() string { return proto.CompactTextString(m) }
func (*OrderMatchReject) ProtoMessage()    {}
func (*OrderMatchReject) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{12}
}

func (m *OrderMatchReject) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrderMatchReject.Unmarshal(m, b)
}
func (m *OrderMatchReject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrderMatchReject.Marshal(b, m, deterministic)
}
func (m *OrderMatchReject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderMatchReject.Merge(m, src)
}
func (m *OrderMatchReject) XXX_Size() int {
	return xxx_messageInfo_OrderMatchReject.Size(m)
}
func (m *OrderMatchReject) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderMatchReject.DiscardUnknown(m)
}

var xxx_messageInfo_OrderMatchReject proto.InternalMessageInfo

func (m *OrderMatchReject) GetBatchId() []byte {
	if m != nil {
		return m.BatchId
	}
	return nil
}

func (m *OrderMatchReject) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *OrderMatchReject) GetReasonCode() OrderMatchReject_RejectReason {
	if m != nil {
		return m.ReasonCode
	}
	return OrderMatchReject_UNKNOWN
}

func (m *OrderMatchReject) GetRejectedOrders() map[string]*OrderReject {
	if m != nil {
		return m.RejectedOrders
	}
	return nil
}

type OrderReject struct {
	//
	//The reason/error string for the rejection.
	Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"`
	//
	//The reason as a code.
	ReasonCode           OrderReject_OrderRejectReason `protobuf:"varint,2,opt,name=reason_code,json=reasonCode,proto3,enum=poolrpc.OrderReject_OrderRejectReason" json:"reason_code,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *OrderReject) Reset()         { *m = OrderReject{} }
func (m *OrderReject) String() string { return proto.CompactTextString(m) }
func (*OrderReject) ProtoMessage()    {}
func (*OrderReject) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{13}
}

func (m *OrderReject) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrderReject.Unmarshal(m, b)
}
func (m *OrderReject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrderReject.Marshal(b, m, deterministic)
}
func (m *OrderReject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderReject.Merge(m, src)
}
func (m *OrderReject) XXX_Size() int {
	return xxx_messageInfo_OrderReject.Size(m)
}
func (m *OrderReject) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderReject.DiscardUnknown(m)
}

var xxx_messageInfo_OrderReject proto.InternalMessageInfo

func (m *OrderReject) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *OrderReject) GetReasonCode() OrderReject_OrderRejectReason {
	if m != nil {
		return m.ReasonCode
	}
	return OrderReject_DUPLICATE_PEER
}

type ChannelInfo struct {
	// The identifying type of the channel.
	Type ChannelType `protobuf:"varint,1,opt,name=type,proto3,enum=poolrpc.ChannelType" json:"type,omitempty"`
	// The node's identifying public key.
	LocalNodeKey []byte `protobuf:"bytes,2,opt,name=local_node_key,json=localNodeKey,proto3" json:"local_node_key,omitempty"`
	// The remote node's identifying public key.
	RemoteNodeKey []byte `protobuf:"bytes,3,opt,name=remote_node_key,json=remoteNodeKey,proto3" json:"remote_node_key,omitempty"`
	//
	//The node's base public key used within the non-delayed pay-to-self output on
	//the commitment transaction.
	LocalPaymentBasePoint []byte `protobuf:"bytes,4,opt,name=local_payment_base_point,json=localPaymentBasePoint,proto3" json:"local_payment_base_point,omitempty"`
	//
	//RemotePaymentBasePoint is the remote node's base public key used within the
	//non-delayed pay-to-self output on the commitment transaction.
	RemotePaymentBasePoint []byte   `protobuf:"bytes,5,opt,name=remote_payment_base_point,json=remotePaymentBasePoint,proto3" json:"remote_payment_base_point,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *ChannelInfo) Reset()         { *m = ChannelInfo{} }
func (m *ChannelInfo) String() string { return proto.CompactTextString(m) }
func (*ChannelInfo) ProtoMessage()    {}
func (*ChannelInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{14}
}

func (m *ChannelInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelInfo.Unmarshal(m, b)
}
func (m *ChannelInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelInfo.Marshal(b, m, deterministic)
}
func (m *ChannelInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelInfo.Merge(m, src)
}
func (m *ChannelInfo) XXX_Size() int {
	return xxx_messageInfo_ChannelInfo.Size(m)
}
func (m *ChannelInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelInfo proto.InternalMessageInfo

func (m *ChannelInfo) GetType() ChannelType {
	if m != nil {
		return m.Type
	}
	return ChannelType_TWEAKLESS
}

func (m *ChannelInfo) GetLocalNodeKey() []byte {
	if m != nil {
		return m.LocalNodeKey
	}
	return nil
}

func (m *ChannelInfo) GetRemoteNodeKey() []byte {
	if m != nil {
		return m.RemoteNodeKey
	}
	return nil
}

func (m *ChannelInfo) GetLocalPaymentBasePoint() []byte {
	if m != nil {
		return m.LocalPaymentBasePoint
	}
	return nil
}

func (m *ChannelInfo) GetRemotePaymentBasePoint() []byte {
	if m != nil {
		return m.RemotePaymentBasePoint
	}
	return nil
}

type OrderMatchSign struct {
	//
	//The ID of the batch that the signatures are meant for.
	BatchId []byte `protobuf:"bytes,1,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	//
	//A map with the signatures to spend the accounts being spent in a batch
	//transaction. The map key corresponds to the trader's account key of the
	//account in the batch transaction. The account key/ID has to be hex encoded
	//into a string because protobuf doesn't allow bytes as a map key data type.
	AccountSigs map[string][]byte `protobuf:"bytes,2,rep,name=account_sigs,json=accountSigs,proto3" json:"account_sigs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	//
	//The information for each channel created as part of a batch that's submitted
	//to the auctioneer to ensure they can properly enforce a channel's service
	//lifetime. Entries are indexed by the string representation of a channel's
	//outpoint.
	ChannelInfos         map[string]*ChannelInfo `protobuf:"bytes,3,rep,name=channel_infos,json=channelInfos,proto3" json:"channel_infos,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *OrderMatchSign) Reset()         { *m = OrderMatchSign{} }
func (m *OrderMatchSign) String() string { return proto.CompactTextString(m) }
func (*OrderMatchSign) ProtoMessage()    {}
func (*OrderMatchSign) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{15}
}

func (m *OrderMatchSign) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrderMatchSign.Unmarshal(m, b)
}
func (m *OrderMatchSign) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrderMatchSign.Marshal(b, m, deterministic)
}
func (m *OrderMatchSign) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderMatchSign.Merge(m, src)
}
func (m *OrderMatchSign) XXX_Size() int {
	return xxx_messageInfo_OrderMatchSign.Size(m)
}
func (m *OrderMatchSign) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderMatchSign.DiscardUnknown(m)
}

var xxx_messageInfo_OrderMatchSign proto.InternalMessageInfo

func (m *OrderMatchSign) GetBatchId() []byte {
	if m != nil {
		return m.BatchId
	}
	return nil
}

func (m *OrderMatchSign) GetAccountSigs() map[string][]byte {
	if m != nil {
		return m.AccountSigs
	}
	return nil
}

func (m *OrderMatchSign) GetChannelInfos() map[string]*ChannelInfo {
	if m != nil {
		return m.ChannelInfos
	}
	return nil
}

type AccountRecovery struct {
	//
	//The trader's account key of the account to recover.
	TraderKey            []byte   `protobuf:"bytes,1,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccountRecovery) Reset()         { *m = AccountRecovery{} }
func (m *AccountRecovery) String() string { return proto.CompactTextString(m) }
func (*AccountRecovery) ProtoMessage()    {}
func (*AccountRecovery) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{16}
}

func (m *AccountRecovery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccountRecovery.Unmarshal(m, b)
}
func (m *AccountRecovery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccountRecovery.Marshal(b, m, deterministic)
}
func (m *AccountRecovery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountRecovery.Merge(m, src)
}
func (m *AccountRecovery) XXX_Size() int {
	return xxx_messageInfo_AccountRecovery.Size(m)
}
func (m *AccountRecovery) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountRecovery.DiscardUnknown(m)
}

var xxx_messageInfo_AccountRecovery proto.InternalMessageInfo

func (m *AccountRecovery) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

type ServerAuctionMessage struct {
	// Types that are valid to be assigned to Msg:
	//	*ServerAuctionMessage_Challenge
	//	*ServerAuctionMessage_Success
	//	*ServerAuctionMessage_Error
	//	*ServerAuctionMessage_Prepare
	//	*ServerAuctionMessage_Sign
	//	*ServerAuctionMessage_Finalize
	//	*ServerAuctionMessage_Account
	Msg                  isServerAuctionMessage_Msg `protobuf_oneof:"msg"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *ServerAuctionMessage) Reset()         { *m = ServerAuctionMessage{} }
func (m *ServerAuctionMessage) String() string { return proto.CompactTextString(m) }
func (*ServerAuctionMessage) ProtoMessage()    {}
func (*ServerAuctionMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{17}
}

func (m *ServerAuctionMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerAuctionMessage.Unmarshal(m, b)
}
func (m *ServerAuctionMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerAuctionMessage.Marshal(b, m, deterministic)
}
func (m *ServerAuctionMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerAuctionMessage.Merge(m, src)
}
func (m *ServerAuctionMessage) XXX_Size() int {
	return xxx_messageInfo_ServerAuctionMessage.Size(m)
}
func (m *ServerAuctionMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerAuctionMessage.DiscardUnknown(m)
}

var xxx_messageInfo_ServerAuctionMessage proto.InternalMessageInfo

type isServerAuctionMessage_Msg interface {
	isServerAuctionMessage_Msg()
}

type ServerAuctionMessage_Challenge struct {
	Challenge *ServerChallenge `protobuf:"bytes,1,opt,name=challenge,proto3,oneof"`
}

type ServerAuctionMessage_Success struct {
	Success *SubscribeSuccess `protobuf:"bytes,2,opt,name=success,proto3,oneof"`
}

type ServerAuctionMessage_Error struct {
	Error *SubscribeError `protobuf:"bytes,3,opt,name=error,proto3,oneof"`
}

type ServerAuctionMessage_Prepare struct {
	Prepare *OrderMatchPrepare `protobuf:"bytes,4,opt,name=prepare,proto3,oneof"`
}

type ServerAuctionMessage_Sign struct {
	Sign *OrderMatchSignBegin `protobuf:"bytes,5,opt,name=sign,proto3,oneof"`
}

type ServerAuctionMessage_Finalize struct {
	Finalize *OrderMatchFinalize `protobuf:"bytes,6,opt,name=finalize,proto3,oneof"`
}

type ServerAuctionMessage_Account struct {
	Account *AuctionAccount `protobuf:"bytes,7,opt,name=account,proto3,oneof"`
}

func (*ServerAuctionMessage_Challenge) isServerAuctionMessage_Msg() {}

func (*ServerAuctionMessage_Success) isServerAuctionMessage_Msg() {}

func (*ServerAuctionMessage_Error) isServerAuctionMessage_Msg() {}

func (*ServerAuctionMessage_Prepare) isServerAuctionMessage_Msg() {}

func (*ServerAuctionMessage_Sign) isServerAuctionMessage_Msg() {}

func (*ServerAuctionMessage_Finalize) isServerAuctionMessage_Msg() {}

func (*ServerAuctionMessage_Account) isServerAuctionMessage_Msg() {}

func (m *ServerAuctionMessage) GetMsg() isServerAuctionMessage_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *ServerAuctionMessage) GetChallenge() *ServerChallenge {
	if x, ok := m.GetMsg().(*ServerAuctionMessage_Challenge); ok {
		return x.Challenge
	}
	return nil
}

func (m *ServerAuctionMessage) GetSuccess() *SubscribeSuccess {
	if x, ok := m.GetMsg().(*ServerAuctionMessage_Success); ok {
		return x.Success
	}
	return nil
}

func (m *ServerAuctionMessage) GetError() *SubscribeError {
	if x, ok := m.GetMsg().(*ServerAuctionMessage_Error); ok {
		return x.Error
	}
	return nil
}

func (m *ServerAuctionMessage) GetPrepare() *OrderMatchPrepare {
	if x, ok := m.GetMsg().(*ServerAuctionMessage_Prepare); ok {
		return x.Prepare
	}
	return nil
}

func (m *ServerAuctionMessage) GetSign() *OrderMatchSignBegin {
	if x, ok := m.GetMsg().(*ServerAuctionMessage_Sign); ok {
		return x.Sign
	}
	return nil
}

func (m *ServerAuctionMessage) GetFinalize() *OrderMatchFinalize {
	if x, ok := m.GetMsg().(*ServerAuctionMessage_Finalize); ok {
		return x.Finalize
	}
	return nil
}

func (m *ServerAuctionMessage) GetAccount() *AuctionAccount {
	if x, ok := m.GetMsg().(*ServerAuctionMessage_Account); ok {
		return x.Account
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ServerAuctionMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ServerAuctionMessage_Challenge)(nil),
		(*ServerAuctionMessage_Success)(nil),
		(*ServerAuctionMessage_Error)(nil),
		(*ServerAuctionMessage_Prepare)(nil),
		(*ServerAuctionMessage_Sign)(nil),
		(*ServerAuctionMessage_Finalize)(nil),
		(*ServerAuctionMessage_Account)(nil),
	}
}

type ServerChallenge struct {
	//
	//The unique challenge for each stream that has to be signed with the trader's
	//account key for each account subscription.
	Challenge []byte `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"`
	//
	//The commit hash the challenge was created for.
	CommitHash           []byte   `protobuf:"bytes,2,opt,name=commit_hash,json=commitHash,proto3" json:"commit_hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerChallenge) Reset()         { *m = ServerChallenge{} }
func (m *ServerChallenge) String() string { return proto.CompactTextString(m) }
func (*ServerChallenge) ProtoMessage()    {}
func (*ServerChallenge) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{18}
}

func (m *ServerChallenge) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerChallenge.Unmarshal(m, b)
}
func (m *ServerChallenge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerChallenge.Marshal(b, m, deterministic)
}
func (m *ServerChallenge) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerChallenge.Merge(m, src)
}
func (m *ServerChallenge) XXX_Size() int {
	return xxx_messageInfo_ServerChallenge.Size(m)
}
func (m *ServerChallenge) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerChallenge.DiscardUnknown(m)
}

var xxx_messageInfo_ServerChallenge proto.InternalMessageInfo

func (m *ServerChallenge) GetChallenge() []byte {
	if m != nil {
		return m.Challenge
	}
	return nil
}

func (m *ServerChallenge) GetCommitHash() []byte {
	if m != nil {
		return m.CommitHash
	}
	return nil
}

type SubscribeSuccess struct {
	//
	//The trader's account key this message is referring to.
	TraderKey            []byte   `protobuf:"bytes,1,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SubscribeSuccess) Reset()         { *m = SubscribeSuccess{} }
func (m *SubscribeSuccess) String() string { return proto.CompactTextString(m) }
func (*SubscribeSuccess) ProtoMessage()    {}
func (*SubscribeSuccess) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{19}
}

func (m *SubscribeSuccess) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubscribeSuccess.Unmarshal(m, b)
}
func (m *SubscribeSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubscribeSuccess.Marshal(b, m, deterministic)
}
func (m *SubscribeSuccess) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubscribeSuccess.Merge(m, src)
}
func (m *SubscribeSuccess) XXX_Size() int {
	return xxx_messageInfo_SubscribeSuccess.Size(m)
}
func (m *SubscribeSuccess) XXX_DiscardUnknown() {
	xxx_messageInfo_SubscribeSuccess.DiscardUnknown(m)
}

var xxx_messageInfo_SubscribeSuccess proto.InternalMessageInfo

func (m *SubscribeSuccess) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

type OrderMatchPrepare struct {
	//
	//Maps a user's own order_nonce to the opposite order type they were matched
	//with. The order_nonce is a 32 byte hex encoded string because bytes is not
	//allowed as a map key data type in protobuf.
	MatchedOrders map[string]*MatchedOrder `protobuf:"bytes,1,rep,name=matched_orders,json=matchedOrders,proto3" json:"matched_orders,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	//
	//The uniform clearing price rate in parts per billion that was used for this
	//batch.
	ClearingPriceRate uint32 `protobuf:"varint,2,opt,name=clearing_price_rate,json=clearingPriceRate,proto3" json:"clearing_price_rate,omitempty"`
	//
	//A list of the user's own accounts that are being spent by the matched
	//orders. The list contains the differences that would be applied by the
	//server when executing the orders.
	ChargedAccounts []*AccountDiff `protobuf:"bytes,3,rep,name=charged_accounts,json=chargedAccounts,proto3" json:"charged_accounts,omitempty"`
	//
	//The fee parameters used to calculate the execution fees.
	ExecutionFee *ExecutionFee `protobuf:"bytes,4,opt,name=execution_fee,json=executionFee,proto3" json:"execution_fee,omitempty"`
	//
	//The batch transaction with all non-witness data.
	BatchTransaction []byte `protobuf:"bytes,5,opt,name=batch_transaction,json=batchTransaction,proto3" json:"batch_transaction,omitempty"`
	//
	//Fee rate of the batch transaction, expressed in satoshis per 1000 weight
	//units (sat/kW).
	FeeRateSatPerKw uint64 `protobuf:"varint,6,opt,name=fee_rate_sat_per_kw,json=feeRateSatPerKw,proto3" json:"fee_rate_sat_per_kw,omitempty"`
	//
	//Fee rebate in satoshis, offered if another batch participant wants to pay
	//more fees for a faster confirmation.
	FeeRebateSat uint64 `protobuf:"varint,7,opt,name=fee_rebate_sat,json=feeRebateSat,proto3" json:"fee_rebate_sat,omitempty"`
	//
	//The 32 byte unique identifier of this batch.
	BatchId []byte `protobuf:"bytes,8,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	//
	//The batch verification protocol version the server is using. Clients that
	//don't support this version MUST return an `OrderMatchAccept` message with
	//an empty list of orders so the batch can continue. The user should then be
	//informed that a software update is required.
	BatchVersion         uint32   `protobuf:"varint,9,opt,name=batch_version,json=batchVersion,proto3" json:"batch_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OrderMatchPrepare) Reset()         { *m = OrderMatchPrepare{} }
func (m *OrderMatchPrepare) String() string { return proto.CompactTextString(m) }
func (*OrderMatchPrepare) ProtoMessage()    {}
func (*OrderMatchPrepare) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{20}
}

func (m *OrderMatchPrepare) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrderMatchPrepare.Unmarshal(m, b)
}
func (m *OrderMatchPrepare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrderMatchPrepare.Marshal(b, m, deterministic)
}
func (m *OrderMatchPrepare) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderMatchPrepare.Merge(m, src)
}
func (m *OrderMatchPrepare) XXX_Size() int {
	return xxx_messageInfo_OrderMatchPrepare.Size(m)
}
func (m *OrderMatchPrepare) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderMatchPrepare.DiscardUnknown(m)
}

var xxx_messageInfo_OrderMatchPrepare proto.InternalMessageInfo

func (m *OrderMatchPrepare) GetMatchedOrders() map[string]*MatchedOrder {
	if m != nil {
		return m.MatchedOrders
	}
	return nil
}

func (m *OrderMatchPrepare) GetClearingPriceRate() uint32 {
	if m != nil {
		return m.ClearingPriceRate
	}
	return 0
}

func (m *OrderMatchPrepare) GetChargedAccounts() []*AccountDiff {
	if m != nil {
		return m.ChargedAccounts
	}
	return nil
}

func (m *OrderMatchPrepare) GetExecutionFee() *ExecutionFee {
	if m != nil {
		return m.ExecutionFee
	}
	return nil
}

func (m *OrderMatchPrepare) GetBatchTransaction() []byte {
	if m != nil {
		return m.BatchTransaction
	}
	return nil
}

func (m *OrderMatchPrepare) GetFeeRateSatPerKw() uint64 {
	if m != nil {
		return m.FeeRateSatPerKw
	}
	return 0
}

func (m *OrderMatchPrepare) GetFeeRebateSat() uint64 {
	if m != nil {
		return m.FeeRebateSat
	}
	return 0
}

func (m *OrderMatchPrepare) GetBatchId() []byte {
	if m != nil {
		return m.BatchId
	}
	return nil
}

func (m *OrderMatchPrepare) GetBatchVersion() uint32 {
	if m != nil {
		return m.BatchVersion
	}
	return 0
}

type OrderMatchSignBegin struct {
	//
	//The 32 byte unique identifier of this batch.
	BatchId              []byte   `protobuf:"bytes,1,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OrderMatchSignBegin) Reset()         { *m = OrderMatchSignBegin{} }
func (m *OrderMatchSignBegin) String() string { return proto.CompactTextString(m) }
func (*OrderMatchSignBegin) ProtoMessage()    {}
func (*OrderMatchSignBegin) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{21}
}

func (m *OrderMatchSignBegin) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrderMatchSignBegin.Unmarshal(m, b)
}
func (m *OrderMatchSignBegin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrderMatchSignBegin.Marshal(b, m, deterministic)
}
func (m *OrderMatchSignBegin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderMatchSignBegin.Merge(m, src)
}
func (m *OrderMatchSignBegin) XXX_Size() int {
	return xxx_messageInfo_OrderMatchSignBegin.Size(m)
}
func (m *OrderMatchSignBegin) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderMatchSignBegin.DiscardUnknown(m)
}

var xxx_messageInfo_OrderMatchSignBegin proto.InternalMessageInfo

func (m *OrderMatchSignBegin) GetBatchId() []byte {
	if m != nil {
		return m.BatchId
	}
	return nil
}

type OrderMatchFinalize struct {
	//
	//The unique identifier of the finalized batch.
	BatchId []byte `protobuf:"bytes,1,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	//
	//The final transaction ID of the published batch transaction.
	BatchTxid []byte `protobuf:"bytes,2,opt,name=batch_txid,json=batchTxid,proto3" json:"batch_txid,omitempty"`
	//
	//The current block height at the time the batch transaction was published to
	//the network.
	HeightHint           uint32   `protobuf:"varint,3,opt,name=height_hint,json=heightHint,proto3" json:"height_hint,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OrderMatchFinalize) Reset()         { *m = OrderMatchFinalize{} }
func (m *OrderMatchFinalize) String() string { return proto.CompactTextString(m) }
func (*OrderMatchFinalize) ProtoMessage()    {}
func (*OrderMatchFinalize) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{22}
}

func (m *OrderMatchFinalize) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OrderMatchFinalize.Unmarshal(m, b)
}
func (m *OrderMatchFinalize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OrderMatchFinalize.Marshal(b, m, deterministic)
}
func (m *OrderMatchFinalize) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderMatchFinalize.Merge(m, src)
}
func (m *OrderMatchFinalize) XXX_Size() int {
	return xxx_messageInfo_OrderMatchFinalize.Size(m)
}
func (m *OrderMatchFinalize) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderMatchFinalize.DiscardUnknown(m)
}

var xxx_messageInfo_OrderMatchFinalize proto.InternalMessageInfo

func (m *OrderMatchFinalize) GetBatchId() []byte {
	if m != nil {
		return m.BatchId
	}
	return nil
}

func (m *OrderMatchFinalize) GetBatchTxid() []byte {
	if m != nil {
		return m.BatchTxid
	}
	return nil
}

func (m *OrderMatchFinalize) GetHeightHint() uint32 {
	if m != nil {
		return m.HeightHint
	}
	return 0
}

type SubscribeError struct {
	//
	//The string representation of the subscription error.
	Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	//
	//The error code of the subscription error.
	ErrorCode SubscribeError_Error `protobuf:"varint,2,opt,name=error_code,json=errorCode,proto3,enum=poolrpc.SubscribeError_Error" json:"error_code,omitempty"`
	//
	//The trader's account key this error is referring to. This is not set if
	//the error code is SERVER_SHUTDOWN as that error is only sent once per
	//connection and not per individual subscription.
	TraderKey []byte `protobuf:"bytes,3,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	//
	//The auctioneer's partial account information as it was stored when creating
	//the reservation. This is only set if the error code is
	//INCOMPLETE_ACCOUNT_RESERVATION. Only the fields value, expiry, trader_key,
	//auctioneer_key, batch_key and height_hint will be set in that
	//case.
	AccountReservation   *AuctionAccount `protobuf:"bytes,4,opt,name=account_reservation,json=accountReservation,proto3" json:"account_reservation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *SubscribeError) Reset()         { *m = SubscribeError{} }
func (m *SubscribeError) String() string { return proto.CompactTextString(m) }
func (*SubscribeError) ProtoMessage()    {}
func (*SubscribeError) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{23}
}

func (m *SubscribeError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubscribeError.Unmarshal(m, b)
}
func (m *SubscribeError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubscribeError.Marshal(b, m, deterministic)
}
func (m *SubscribeError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubscribeError.Merge(m, src)
}
func (m *SubscribeError) XXX_Size() int {
	return xxx_messageInfo_SubscribeError.Size(m)
}
func (m *SubscribeError) XXX_DiscardUnknown() {
	xxx_messageInfo_SubscribeError.DiscardUnknown(m)
}

var xxx_messageInfo_SubscribeError proto.InternalMessageInfo

func (m *SubscribeError) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func (m *SubscribeError) GetErrorCode() SubscribeError_Error {
	if m != nil {
		return m.ErrorCode
	}
	return SubscribeError_UNKNOWN
}

func (m *SubscribeError) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

func (m *SubscribeError) GetAccountReservation() *AuctionAccount {
	if m != nil {
		return m.AccountReservation
	}
	return nil
}

type AuctionAccount struct {
	//
	//The value of the account in satoshis. Must match the amount of the
	//account_point output.
	Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	//
	//The block height at which the account should expire.
	Expiry uint32 `protobuf:"varint,2,opt,name=expiry,proto3" json:"expiry,omitempty"`
	//
	//The trader's account key.
	TraderKey []byte `protobuf:"bytes,3,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	//
	//The long term auctioneer's account key.
	AuctioneerKey []byte `protobuf:"bytes,4,opt,name=auctioneer_key,json=auctioneerKey,proto3" json:"auctioneer_key,omitempty"`
	//
	//The current batch key used to create the account output.
	BatchKey []byte `protobuf:"bytes,5,opt,name=batch_key,json=batchKey,proto3" json:"batch_key,omitempty"`
	//
	//The current state of the account as the auctioneer sees it.
	State AuctionAccountState `protobuf:"varint,6,opt,name=state,proto3,enum=poolrpc.AuctionAccountState" json:"state,omitempty"`
	//
	//The block height of the last change to the account's output. Can be used to
	//scan the chain for the output's spend state more efficiently.
	HeightHint uint32 `protobuf:"varint,7,opt,name=height_hint,json=heightHint,proto3" json:"height_hint,omitempty"`
	//
	//Transaction output of the account. Depending on the state of the account,
	//this output might have been spent.
	Outpoint *OutPoint `protobuf:"bytes,8,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	//
	//The latest transaction of an account. This is only known by the auctioneer
	//after the account has met its initial funding confirmation.
	LatestTx             []byte   `protobuf:"bytes,9,opt,name=latest_tx,json=latestTx,proto3" json:"latest_tx,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AuctionAccount) Reset()         { *m = AuctionAccount{} }
func (m *AuctionAccount) String() string { return proto.CompactTextString(m) }
func (*AuctionAccount) ProtoMessage()    {}
func (*AuctionAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{24}
}

func (m *AuctionAccount) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AuctionAccount.Unmarshal(m, b)
}
func (m *AuctionAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AuctionAccount.Marshal(b, m, deterministic)
}
func (m *AuctionAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AuctionAccount.Merge(m, src)
}
func (m *AuctionAccount) XXX_Size() int {
	return xxx_messageInfo_AuctionAccount.Size(m)
}
func (m *AuctionAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_AuctionAccount.DiscardUnknown(m)
}

var xxx_messageInfo_AuctionAccount proto.InternalMessageInfo

func (m *AuctionAccount) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *AuctionAccount) GetExpiry() uint32 {
	if m != nil {
		return m.Expiry
	}
	return 0
}

func (m *AuctionAccount) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

func (m *AuctionAccount) GetAuctioneerKey() []byte {
	if m != nil {
		return m.AuctioneerKey
	}
	return nil
}

func (m *AuctionAccount) GetBatchKey() []byte {
	if m != nil {
		return m.BatchKey
	}
	return nil
}

func (m *AuctionAccount) GetState() AuctionAccountState {
	if m != nil {
		return m.State
	}
	return AuctionAccountState_STATE_PENDING_OPEN
}

func (m *AuctionAccount) GetHeightHint() uint32 {
	if m != nil {
		return m.HeightHint
	}
	return 0
}

func (m *AuctionAccount) GetOutpoint() *OutPoint {
	if m != nil {
		return m.Outpoint
	}
	return nil
}

func (m *AuctionAccount) GetLatestTx() []byte {
	if m != nil {
		return m.LatestTx
	}
	return nil
}

type MatchedOrder struct {
	//
	//The bids the trader's own order was matched against. This list is empty if
	//the trader's order was a bid order itself.
	MatchedBids []*MatchedBid `protobuf:"bytes,1,rep,name=matched_bids,json=matchedBids,proto3" json:"matched_bids,omitempty"`
	//
	//The asks the trader's own order was matched against. This list is empty if
	//the trader's order was an ask order itself.
	MatchedAsks          []*MatchedAsk `protobuf:"bytes,2,rep,name=matched_asks,json=matchedAsks,proto3" json:"matched_asks,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *MatchedOrder) Reset()         { *m = MatchedOrder{} }
func (m *MatchedOrder) String() string { return proto.CompactTextString(m) }
func (*MatchedOrder) ProtoMessage()    {}
func (*MatchedOrder) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{25}
}

func (m *MatchedOrder) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchedOrder.Unmarshal(m, b)
}
func (m *MatchedOrder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchedOrder.Marshal(b, m, deterministic)
}
func (m *MatchedOrder) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchedOrder.Merge(m, src)
}
func (m *MatchedOrder) XXX_Size() int {
	return xxx_messageInfo_MatchedOrder.Size(m)
}
func (m *MatchedOrder) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchedOrder.DiscardUnknown(m)
}

var xxx_messageInfo_MatchedOrder proto.InternalMessageInfo

func (m *MatchedOrder) GetMatchedBids() []*MatchedBid {
	if m != nil {
		return m.MatchedBids
	}
	return nil
}

func (m *MatchedOrder) GetMatchedAsks() []*MatchedAsk {
	if m != nil {
		return m.MatchedAsks
	}
	return nil
}

type MatchedAsk struct {
	//
	//The ask order that was matched against.
	Ask *ServerAsk `protobuf:"bytes,1,opt,name=ask,proto3" json:"ask,omitempty"`
	//
	//The number of units that were filled from/by this matched order.
	UnitsFilled          uint32   `protobuf:"varint,2,opt,name=units_filled,json=unitsFilled,proto3" json:"units_filled,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchedAsk) Reset()         { *m = MatchedAsk{} }
func (m *MatchedAsk) String() string { return proto.CompactTextString(m) }
func (*MatchedAsk) ProtoMessage()    {}
func (*MatchedAsk) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{26}
}

func (m *MatchedAsk) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchedAsk.Unmarshal(m, b)
}
func (m *MatchedAsk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchedAsk.Marshal(b, m, deterministic)
}
func (m *MatchedAsk) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchedAsk.Merge(m, src)
}
func (m *MatchedAsk) XXX_Size() int {
	return xxx_messageInfo_MatchedAsk.Size(m)
}
func (m *MatchedAsk) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchedAsk.DiscardUnknown(m)
}

var xxx_messageInfo_MatchedAsk proto.InternalMessageInfo

func (m *MatchedAsk) GetAsk() *ServerAsk {
	if m != nil {
		return m.Ask
	}
	return nil
}

func (m *MatchedAsk) GetUnitsFilled() uint32 {
	if m != nil {
		return m.UnitsFilled
	}
	return 0
}

type MatchedBid struct {
	//
	//The ask order that was matched against.
	Bid *ServerBid `protobuf:"bytes,1,opt,name=bid,proto3" json:"bid,omitempty"`
	//
	//The number of units that were filled from/by this matched order.
	UnitsFilled          uint32   `protobuf:"varint,2,opt,name=units_filled,json=unitsFilled,proto3" json:"units_filled,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchedBid) Reset()         { *m = MatchedBid{} }
func (m *MatchedBid) String() string { return proto.CompactTextString(m) }
func (*MatchedBid) ProtoMessage()    {}
func (*MatchedBid) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{27}
}

func (m *MatchedBid) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchedBid.Unmarshal(m, b)
}
func (m *MatchedBid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchedBid.Marshal(b, m, deterministic)
}
func (m *MatchedBid) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchedBid.Merge(m, src)
}
func (m *MatchedBid) XXX_Size() int {
	return xxx_messageInfo_MatchedBid.Size(m)
}
func (m *MatchedBid) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchedBid.DiscardUnknown(m)
}

var xxx_messageInfo_MatchedBid proto.InternalMessageInfo

func (m *MatchedBid) GetBid() *ServerBid {
	if m != nil {
		return m.Bid
	}
	return nil
}

func (m *MatchedBid) GetUnitsFilled() uint32 {
	if m != nil {
		return m.UnitsFilled
	}
	return 0
}

type AccountDiff struct {
	//
	//The final balance of the account after the executed batch.
	EndingBalance uint64 `protobuf:"varint,1,opt,name=ending_balance,json=endingBalance,proto3" json:"ending_balance,omitempty"`
	//
	//Depending on the amount of the final balance of the account, the remainder
	//is either sent to a new on-chain output, extended off-chain or fully
	//consumed by the batch and its fees.
	EndingState AccountDiff_AccountState `protobuf:"varint,2,opt,name=ending_state,json=endingState,proto3,enum=poolrpc.AccountDiff_AccountState" json:"ending_state,omitempty"`
	//
	//If the account was re-created on-chain then the new account's index in the
	//transaction is set here. If the account was fully spent or the remainder was
	//extended off-chain then no new account outpoint is created and -1 is
	//returned here.
	OutpointIndex int32 `protobuf:"varint,3,opt,name=outpoint_index,json=outpointIndex,proto3" json:"outpoint_index,omitempty"`
	//
	//The trader's account key this diff is referring to.
	TraderKey            []byte   `protobuf:"bytes,4,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccountDiff) Reset()         { *m = AccountDiff{} }
func (m *AccountDiff) String() string { return proto.CompactTextString(m) }
func (*AccountDiff) ProtoMessage()    {}
func (*AccountDiff) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{28}
}

func (m *AccountDiff) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccountDiff.Unmarshal(m, b)
}
func (m *AccountDiff) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccountDiff.Marshal(b, m, deterministic)
}
func (m *AccountDiff) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountDiff.Merge(m, src)
}
func (m *AccountDiff) XXX_Size() int {
	return xxx_messageInfo_AccountDiff.Size(m)
}
func (m *AccountDiff) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountDiff.DiscardUnknown(m)
}

var xxx_messageInfo_AccountDiff proto.InternalMessageInfo

func (m *AccountDiff) GetEndingBalance() uint64 {
	if m != nil {
		return m.EndingBalance
	}
	return 0
}

func (m *AccountDiff) GetEndingState() AccountDiff_AccountState {
	if m != nil {
		return m.EndingState
	}
	return AccountDiff_OUTPUT_RECREATED
}

func (m *AccountDiff) GetOutpointIndex() int32 {
	if m != nil {
		return m.OutpointIndex
	}
	return 0
}

func (m *AccountDiff) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

type ServerOrder struct {
	//
	//The trader's account key of the account to use for the order.
	TraderKey []byte `protobuf:"bytes,1,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	//
	//Fixed order rate in parts per billion.
	RateFixed uint32 `protobuf:"varint,2,opt,name=rate_fixed,json=rateFixed,proto3" json:"rate_fixed,omitempty"`
	//
	//Order amount in satoshis.
	Amt        uint64 `protobuf:"varint,3,opt,name=amt,proto3" json:"amt,omitempty"`
	MinChanAmt uint64 `protobuf:"varint,4,opt,name=min_chan_amt,json=minChanAmt,proto3" json:"min_chan_amt,omitempty"`
	//
	//Order nonce of 32 byte length, acts as unique order identifier.
	OrderNonce []byte `protobuf:"bytes,6,opt,name=order_nonce,json=orderNonce,proto3" json:"order_nonce,omitempty"`
	//
	//Signature of the order's digest, signed with the user's account key. The
	//signature must be fixed-size LN wire format encoded. Version 0 includes the
	//fields version, rate_fixed, amt, max_batch_fee_rate_sat_per_kw and
	//lease_duration_blocks in the order digest.
	OrderSig []byte `protobuf:"bytes,7,opt,name=order_sig,json=orderSig,proto3" json:"order_sig,omitempty"`
	//
	//The multi signature key of the node creating the order, will be used for the
	//target channel's funding TX 2-of-2 multi signature output.
	MultiSigKey []byte `protobuf:"bytes,8,opt,name=multi_sig_key,json=multiSigKey,proto3" json:"multi_sig_key,omitempty"`
	//
	//The pubkey of the node creating the order.
	NodePub []byte `protobuf:"bytes,9,opt,name=node_pub,json=nodePub,proto3" json:"node_pub,omitempty"`
	//
	//The network addresses of the node creating the order.
	NodeAddr []*NodeAddress `protobuf:"bytes,10,rep,name=node_addr,json=nodeAddr,proto3" json:"node_addr,omitempty"`
	//
	//The type of the channel that should be opened.
	ChanType uint32 `protobuf:"varint,12,opt,name=chan_type,json=chanType,proto3" json:"chan_type,omitempty"`
	//
	//Maximum fee rate the trader is willing to pay for the batch transaction,
	//expressed in satoshis per 1000 weight units (sat/kW).
	MaxBatchFeeRateSatPerKw uint64   `protobuf:"varint,13,opt,name=max_batch_fee_rate_sat_per_kw,json=maxBatchFeeRateSatPerKw,proto3" json:"max_batch_fee_rate_sat_per_kw,omitempty"`
	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
	XXX_unrecognized        []byte   `json:"-"`
	XXX_sizecache           int32    `json:"-"`
}

func (m *ServerOrder) Reset()         { *m = ServerOrder{} }
func (m *ServerOrder) String() string { return proto.CompactTextString(m) }
func (*ServerOrder) ProtoMessage()    {}
func (*ServerOrder) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{29}
}

func (m *ServerOrder) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerOrder.Unmarshal(m, b)
}
func (m *ServerOrder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerOrder.Marshal(b, m, deterministic)
}
func (m *ServerOrder) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerOrder.Merge(m, src)
}
func (m *ServerOrder) XXX_Size() int {
	return xxx_messageInfo_ServerOrder.Size(m)
}
func (m *ServerOrder) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerOrder.DiscardUnknown(m)
}

var xxx_messageInfo_ServerOrder proto.InternalMessageInfo

func (m *ServerOrder) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

func (m *ServerOrder) GetRateFixed() uint32 {
	if m != nil {
		return m.RateFixed
	}
	return 0
}

func (m *ServerOrder) GetAmt() uint64 {
	if m != nil {
		return m.Amt
	}
	return 0
}

func (m *ServerOrder) GetMinChanAmt() uint64 {
	if m != nil {
		return m.MinChanAmt
	}
	return 0
}

func (m *ServerOrder) GetOrderNonce() []byte {
	if m != nil {
		return m.OrderNonce
	}
	return nil
}

func (m *ServerOrder) GetOrderSig() []byte {
	if m != nil {
		return m.OrderSig
	}
	return nil
}

func (m *ServerOrder) GetMultiSigKey() []byte {
	if m != nil {
		return m.MultiSigKey
	}
	return nil
}

func (m *ServerOrder) GetNodePub() []byte {
	if m != nil {
		return m.NodePub
	}
	return nil
}

func (m *ServerOrder) GetNodeAddr() []*NodeAddress {
	if m != nil {
		return m.NodeAddr
	}
	return nil
}

func (m *ServerOrder) GetChanType() uint32 {
	if m != nil {
		return m.ChanType
	}
	return 0
}

func (m *ServerOrder) GetMaxBatchFeeRateSatPerKw() uint64 {
	if m != nil {
		return m.MaxBatchFeeRateSatPerKw
	}
	return 0
}

type ServerBid struct {
	//
	//The common fields shared between both ask and bid order types.
	Details *ServerOrder `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
	//
	//Required number of blocks that a channel opened as a result of this bid
	//should be kept open.
	LeaseDurationBlocks uint32 `protobuf:"varint,2,opt,name=lease_duration_blocks,json=leaseDurationBlocks,proto3" json:"lease_duration_blocks,omitempty"`
	//
	//The version of the order format that is used. Will be increased once new
	//features are added.
	Version uint32 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
	//
	//The minium node tier this order should be matched with. Only asks backed by
	//a node this tier or higher will be eligible for matching with this bid.
	MinNodeTier          NodeTier `protobuf:"varint,5,opt,name=min_node_tier,json=minNodeTier,proto3,enum=poolrpc.NodeTier" json:"min_node_tier,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerBid) Reset()         { *m = ServerBid{} }
func (m *ServerBid) String() string { return proto.CompactTextString(m) }
func (*ServerBid) ProtoMessage()    {}
func (*ServerBid) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{30}
}

func (m *ServerBid) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerBid.Unmarshal(m, b)
}
func (m *ServerBid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerBid.Marshal(b, m, deterministic)
}
func (m *ServerBid) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerBid.Merge(m, src)
}
func (m *ServerBid) XXX_Size() int {
	return xxx_messageInfo_ServerBid.Size(m)
}
func (m *ServerBid) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerBid.DiscardUnknown(m)
}

var xxx_messageInfo_ServerBid proto.InternalMessageInfo

func (m *ServerBid) GetDetails() *ServerOrder {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *ServerBid) GetLeaseDurationBlocks() uint32 {
	if m != nil {
		return m.LeaseDurationBlocks
	}
	return 0
}

func (m *ServerBid) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *ServerBid) GetMinNodeTier() NodeTier {
	if m != nil {
		return m.MinNodeTier
	}
	return NodeTier_TIER_DEFAULT
}

type ServerAsk struct {
	//
	//The common fields shared between both ask and bid order types.
	Details *ServerOrder `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
	//
	//The number of blocks the liquidity provider is willing to provide the
	//channel funds for.
	LeaseDurationBlocks uint32 `protobuf:"varint,4,opt,name=lease_duration_blocks,json=leaseDurationBlocks,proto3" json:"lease_duration_blocks,omitempty"`
	//
	//The version of the order format that is used. Will be increased once new
	//features are added.
	Version              uint32   `protobuf:"varint,5,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerAsk) Reset()         { *m = ServerAsk{} }
func (m *ServerAsk) String() string { return proto.CompactTextString(m) }
func (*ServerAsk) ProtoMessage()    {}
func (*ServerAsk) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{31}
}

func (m *ServerAsk) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerAsk.Unmarshal(m, b)
}
func (m *ServerAsk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerAsk.Marshal(b, m, deterministic)
}
func (m *ServerAsk) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerAsk.Merge(m, src)
}
func (m *ServerAsk) XXX_Size() int {
	return xxx_messageInfo_ServerAsk.Size(m)
}
func (m *ServerAsk) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerAsk.DiscardUnknown(m)
}

var xxx_messageInfo_ServerAsk proto.InternalMessageInfo

func (m *ServerAsk) GetDetails() *ServerOrder {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *ServerAsk) GetLeaseDurationBlocks() uint32 {
	if m != nil {
		return m.LeaseDurationBlocks
	}
	return 0
}

func (m *ServerAsk) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

type CancelOrder struct {
	OrderNonce           []byte   `protobuf:"bytes,1,opt,name=order_nonce,json=orderNonce,proto3" json:"order_nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CancelOrder) Reset()         { *m = CancelOrder{} }
func (m *CancelOrder) String() string { return proto.CompactTextString(m) }
func (*CancelOrder) ProtoMessage()    {}
func (*CancelOrder) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{32}
}

func (m *CancelOrder) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CancelOrder.Unmarshal(m, b)
}
func (m *CancelOrder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CancelOrder.Marshal(b, m, deterministic)
}
func (m *CancelOrder) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CancelOrder.Merge(m, src)
}
func (m *CancelOrder) XXX_Size() int {
	return xxx_messageInfo_CancelOrder.Size(m)
}
func (m *CancelOrder) XXX_DiscardUnknown() {
	xxx_messageInfo_CancelOrder.DiscardUnknown(m)
}

var xxx_messageInfo_CancelOrder proto.InternalMessageInfo

func (m *CancelOrder) GetOrderNonce() []byte {
	if m != nil {
		return m.OrderNonce
	}
	return nil
}

type InvalidOrder struct {
	OrderNonce           []byte                  `protobuf:"bytes,1,opt,name=order_nonce,json=orderNonce,proto3" json:"order_nonce,omitempty"`
	FailReason           InvalidOrder_FailReason `protobuf:"varint,2,opt,name=fail_reason,json=failReason,proto3,enum=poolrpc.InvalidOrder_FailReason" json:"fail_reason,omitempty"`
	FailString           string                  `protobuf:"bytes,3,opt,name=fail_string,json=failString,proto3" json:"fail_string,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *InvalidOrder) Reset()         { *m = InvalidOrder{} }
func (m *InvalidOrder) String() string { return proto.CompactTextString(m) }
func (*InvalidOrder) ProtoMessage()    {}
func (*InvalidOrder) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{33}
}

func (m *InvalidOrder) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InvalidOrder.Unmarshal(m, b)
}
func (m *InvalidOrder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InvalidOrder.Marshal(b, m, deterministic)
}
func (m *InvalidOrder) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InvalidOrder.Merge(m, src)
}
func (m *InvalidOrder) XXX_Size() int {
	return xxx_messageInfo_InvalidOrder.Size(m)
}
func (m *InvalidOrder) XXX_DiscardUnknown() {
	xxx_messageInfo_InvalidOrder.DiscardUnknown(m)
}

var xxx_messageInfo_InvalidOrder proto.InternalMessageInfo

func (m *InvalidOrder) GetOrderNonce() []byte {
	if m != nil {
		return m.OrderNonce
	}
	return nil
}

func (m *InvalidOrder) GetFailReason() InvalidOrder_FailReason {
	if m != nil {
		return m.FailReason
	}
	return InvalidOrder_INVALID_AMT
}

func (m *InvalidOrder) GetFailString() string {
	if m != nil {
		return m.FailString
	}
	return ""
}

type ServerInput struct {
	// The outpoint that the input corresponds to.
	Outpoint             *OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *ServerInput) Reset()         { *m = ServerInput{} }
func (m *ServerInput) String() string { return proto.CompactTextString(m) }
func (*ServerInput) ProtoMessage()    {}
func (*ServerInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{34}
}

func (m *ServerInput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerInput.Unmarshal(m, b)
}
func (m *ServerInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerInput.Marshal(b, m, deterministic)
}
func (m *ServerInput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerInput.Merge(m, src)
}
func (m *ServerInput) XXX_Size() int {
	return xxx_messageInfo_ServerInput.Size(m)
}
func (m *ServerInput) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerInput.DiscardUnknown(m)
}

var xxx_messageInfo_ServerInput proto.InternalMessageInfo

func (m *ServerInput) GetOutpoint() *OutPoint {
	if m != nil {
		return m.Outpoint
	}
	return nil
}

type ServerOutput struct {
	// The value, in satoshis, of the output.
	Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	// The script of the output to send the value to.
	Script               []byte   `protobuf:"bytes,2,opt,name=script,proto3" json:"script,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerOutput) Reset()         { *m = ServerOutput{} }
func (m *ServerOutput) String() string { return proto.CompactTextString(m) }
func (*ServerOutput) ProtoMessage()    {}
func (*ServerOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{35}
}

func (m *ServerOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerOutput.Unmarshal(m, b)
}
func (m *ServerOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerOutput.Marshal(b, m, deterministic)
}
func (m *ServerOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerOutput.Merge(m, src)
}
func (m *ServerOutput) XXX_Size() int {
	return xxx_messageInfo_ServerOutput.Size(m)
}
func (m *ServerOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerOutput.DiscardUnknown(m)
}

var xxx_messageInfo_ServerOutput proto.InternalMessageInfo

func (m *ServerOutput) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *ServerOutput) GetScript() []byte {
	if m != nil {
		return m.Script
	}
	return nil
}

type ServerModifyAccountRequest struct {
	//
	//The trader's account key of the account to be modified.
	TraderKey []byte `protobuf:"bytes,1,opt,name=trader_key,json=traderKey,proto3" json:"trader_key,omitempty"`
	//
	//An additional set of inputs that can be included in the spending transaction
	//of an account. These can be used to deposit more funds into an account.
	//These must be under control of the backing lnd node's wallet.
	NewInputs []*ServerInput `protobuf:"bytes,2,rep,name=new_inputs,json=newInputs,proto3" json:"new_inputs,omitempty"`
	//
	//An additional set of outputs that can be included in the spending
	//transaction of an account. These can be used to withdraw funds from an
	//account.
	NewOutputs []*ServerOutput `protobuf:"bytes,3,rep,name=new_outputs,json=newOutputs,proto3" json:"new_outputs,omitempty"`
	// The new parameters to apply for the account.
	NewParams            *ServerModifyAccountRequest_NewAccountParameters `protobuf:"bytes,4,opt,name=new_params,json=newParams,proto3" json:"new_params,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                         `json:"-"`
	XXX_unrecognized     []byte                                           `json:"-"`
	XXX_sizecache        int32                                            `json:"-"`
}

func (m *ServerModifyAccountRequest) Reset()         { *m = ServerModifyAccountRequest{} }
func (m *ServerModifyAccountRequest) String() string { return proto.CompactTextString(m) }
func (*ServerModifyAccountRequest) ProtoMessage()    {}
func (*ServerModifyAccountRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{36}
}

func (m *ServerModifyAccountRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerModifyAccountRequest.Unmarshal(m, b)
}
func (m *ServerModifyAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerModifyAccountRequest.Marshal(b, m, deterministic)
}
func (m *ServerModifyAccountRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerModifyAccountRequest.Merge(m, src)
}
func (m *ServerModifyAccountRequest) XXX_Size() int {
	return xxx_messageInfo_ServerModifyAccountRequest.Size(m)
}
func (m *ServerModifyAccountRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerModifyAccountRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServerModifyAccountRequest proto.InternalMessageInfo

func (m *ServerModifyAccountRequest) GetTraderKey() []byte {
	if m != nil {
		return m.TraderKey
	}
	return nil
}

func (m *ServerModifyAccountRequest) GetNewInputs() []*ServerInput {
	if m != nil {
		return m.NewInputs
	}
	return nil
}

func (m *ServerModifyAccountRequest) GetNewOutputs() []*ServerOutput {
	if m != nil {
		return m.NewOutputs
	}
	return nil
}

func (m *ServerModifyAccountRequest) GetNewParams() *ServerModifyAccountRequest_NewAccountParameters {
	if m != nil {
		return m.NewParams
	}
	return nil
}

type ServerModifyAccountRequest_NewAccountParameters struct {
	// The new value of the account.
	Value                uint64   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerModifyAccountRequest_NewAccountParameters) Reset() {
	*m = ServerModifyAccountRequest_NewAccountParameters{}
}
func (m *ServerModifyAccountRequest_NewAccountParameters) String() string {
	return proto.CompactTextString(m)
}
func (*ServerModifyAccountRequest_NewAccountParameters) ProtoMessage() {}
func (*ServerModifyAccountRequest_NewAccountParameters) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{36, 0}
}

func (m *ServerModifyAccountRequest_NewAccountParameters) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerModifyAccountRequest_NewAccountParameters.Unmarshal(m, b)
}
func (m *ServerModifyAccountRequest_NewAccountParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerModifyAccountRequest_NewAccountParameters.Marshal(b, m, deterministic)
}
func (m *ServerModifyAccountRequest_NewAccountParameters) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerModifyAccountRequest_NewAccountParameters.Merge(m, src)
}
func (m *ServerModifyAccountRequest_NewAccountParameters) XXX_Size() int {
	return xxx_messageInfo_ServerModifyAccountRequest_NewAccountParameters.Size(m)
}
func (m *ServerModifyAccountRequest_NewAccountParameters) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerModifyAccountRequest_NewAccountParameters.DiscardUnknown(m)
}

var xxx_messageInfo_ServerModifyAccountRequest_NewAccountParameters proto.InternalMessageInfo

func (m *ServerModifyAccountRequest_NewAccountParameters) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type ServerModifyAccountResponse struct {
	//
	//The auctioneer's signature that allows a trader to broadcast a transaction
	//spending from an account output.
	AccountSig           []byte   `protobuf:"bytes,1,opt,name=account_sig,json=accountSig,proto3" json:"account_sig,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerModifyAccountResponse) Reset()         { *m = ServerModifyAccountResponse{} }
func (m *ServerModifyAccountResponse) String() string { return proto.CompactTextString(m) }
func (*ServerModifyAccountResponse) ProtoMessage()    {}
func (*ServerModifyAccountResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{37}
}

func (m *ServerModifyAccountResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerModifyAccountResponse.Unmarshal(m, b)
}
func (m *ServerModifyAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerModifyAccountResponse.Marshal(b, m, deterministic)
}
func (m *ServerModifyAccountResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerModifyAccountResponse.Merge(m, src)
}
func (m *ServerModifyAccountResponse) XXX_Size() int {
	return xxx_messageInfo_ServerModifyAccountResponse.Size(m)
}
func (m *ServerModifyAccountResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerModifyAccountResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ServerModifyAccountResponse proto.InternalMessageInfo

func (m *ServerModifyAccountResponse) GetAccountSig() []byte {
	if m != nil {
		return m.AccountSig
	}
	return nil
}

type ServerOrderStateRequest struct {
	OrderNonce           []byte   `protobuf:"bytes,1,opt,name=order_nonce,json=orderNonce,proto3" json:"order_nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerOrderStateRequest) Reset()         { *m = ServerOrderStateRequest{} }
func (m *ServerOrderStateRequest) String() string { return proto.CompactTextString(m) }
func (*ServerOrderStateRequest) ProtoMessage()    {}
func (*ServerOrderStateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{38}
}

func (m *ServerOrderStateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerOrderStateRequest.Unmarshal(m, b)
}
func (m *ServerOrderStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerOrderStateRequest.Marshal(b, m, deterministic)
}
func (m *ServerOrderStateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerOrderStateRequest.Merge(m, src)
}
func (m *ServerOrderStateRequest) XXX_Size() int {
	return xxx_messageInfo_ServerOrderStateRequest.Size(m)
}
func (m *ServerOrderStateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerOrderStateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServerOrderStateRequest proto.InternalMessageInfo

func (m *ServerOrderStateRequest) GetOrderNonce() []byte {
	if m != nil {
		return m.OrderNonce
	}
	return nil
}

type ServerOrderStateResponse struct {
	//
	//The state the order currently is in.
	State OrderState `protobuf:"varint,1,opt,name=state,proto3,enum=poolrpc.OrderState" json:"state,omitempty"`
	//
	//The number of currently unfilled units of this order. This will be equal to
	//the total amount of units until the order has reached the state PARTIAL_FILL
	//or EXECUTED.
	UnitsUnfulfilled     uint32   `protobuf:"varint,2,opt,name=units_unfulfilled,json=unitsUnfulfilled,proto3" json:"units_unfulfilled,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerOrderStateResponse) Reset()         { *m = ServerOrderStateResponse{} }
func (m *ServerOrderStateResponse) String() string { return proto.CompactTextString(m) }
func (*ServerOrderStateResponse) ProtoMessage()    {}
func (*ServerOrderStateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{39}
}

func (m *ServerOrderStateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerOrderStateResponse.Unmarshal(m, b)
}
func (m *ServerOrderStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerOrderStateResponse.Marshal(b, m, deterministic)
}
func (m *ServerOrderStateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerOrderStateResponse.Merge(m, src)
}
func (m *ServerOrderStateResponse) XXX_Size() int {
	return xxx_messageInfo_ServerOrderStateResponse.Size(m)
}
func (m *ServerOrderStateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerOrderStateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ServerOrderStateResponse proto.InternalMessageInfo

func (m *ServerOrderStateResponse) GetState() OrderState {
	if m != nil {
		return m.State
	}
	return OrderState_ORDER_SUBMITTED
}

func (m *ServerOrderStateResponse) GetUnitsUnfulfilled() uint32 {
	if m != nil {
		return m.UnitsUnfulfilled
	}
	return 0
}

type TermsRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TermsRequest) Reset()         { *m = TermsRequest{} }
func (m *TermsRequest) String() string { return proto.CompactTextString(m) }
func (*TermsRequest) ProtoMessage()    {}
func (*TermsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{40}
}

func (m *TermsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TermsRequest.Unmarshal(m, b)
}
func (m *TermsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TermsRequest.Marshal(b, m, deterministic)
}
func (m *TermsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TermsRequest.Merge(m, src)
}
func (m *TermsRequest) XXX_Size() int {
	return xxx_messageInfo_TermsRequest.Size(m)
}
func (m *TermsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TermsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TermsRequest proto.InternalMessageInfo

type TermsResponse struct {
	//
	//The maximum account size in satoshis currently allowed by the auctioneer.
	MaxAccountValue uint64 `protobuf:"varint,1,opt,name=max_account_value,json=maxAccountValue,proto3" json:"max_account_value,omitempty"`
	//
	//The maximum order duration in blocks currently allowed by the auctioneer.
	MaxOrderDurationBlocks uint32 `protobuf:"varint,2,opt,name=max_order_duration_blocks,json=maxOrderDurationBlocks,proto3" json:"max_order_duration_blocks,omitempty"` // Deprecated: Do not use.
	//
	//The execution fee charged per matched order.
	ExecutionFee *ExecutionFee `protobuf:"bytes,3,opt,name=execution_fee,json=executionFee,proto3" json:"execution_fee,omitempty"`
	//
	//The set of lease durations the market is currently accepting. If a duration
	//is mapped to false, then this means the durations are being accepted, but
	//the market may be paused (not clearing batches). This might happen if a new
	//duration is added, and the auction wishes to build of sufficient market
	//thickness before starting to clear batches.
	LeaseDurations       map[uint32]bool `protobuf:"bytes,4,rep,name=lease_durations,json=leaseDurations,proto3" json:"lease_durations,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *TermsResponse) Reset()         { *m = TermsResponse{} }
func (m *TermsResponse) String() string { return proto.CompactTextString(m) }
func (*TermsResponse) ProtoMessage()    {}
func (*TermsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{41}
}

func (m *TermsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TermsResponse.Unmarshal(m, b)
}
func (m *TermsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TermsResponse.Marshal(b, m, deterministic)
}
func (m *TermsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TermsResponse.Merge(m, src)
}
func (m *TermsResponse) XXX_Size() int {
	return xxx_messageInfo_TermsResponse.Size(m)
}
func (m *TermsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TermsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TermsResponse proto.InternalMessageInfo

func (m *TermsResponse) GetMaxAccountValue() uint64 {
	if m != nil {
		return m.MaxAccountValue
	}
	return 0
}

// Deprecated: Do not use.
func (m *TermsResponse) GetMaxOrderDurationBlocks() uint32 {
	if m != nil {
		return m.MaxOrderDurationBlocks
	}
	return 0
}

func (m *TermsResponse) GetExecutionFee() *ExecutionFee {
	if m != nil {
		return m.ExecutionFee
	}
	return nil
}

func (m *TermsResponse) GetLeaseDurations() map[uint32]bool {
	if m != nil {
		return m.LeaseDurations
	}
	return nil
}

type RelevantBatchRequest struct {
	// The unique identifier of the batch.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	//
	//The set of accounts the trader is interested in retrieving information
	//for within the batch. Each account is identified by its trader key.
	Accounts             [][]byte `protobuf:"bytes,2,rep,name=accounts,proto3" json:"accounts,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RelevantBatchRequest) Reset()         { *m = RelevantBatchRequest{} }
func (m *RelevantBatchRequest) String() string { return proto.CompactTextString(m) }
func (*RelevantBatchRequest) ProtoMessage()    {}
func (*RelevantBatchRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{42}
}

func (m *RelevantBatchRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelevantBatchRequest.Unmarshal(m, b)
}
func (m *RelevantBatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelevantBatchRequest.Marshal(b, m, deterministic)
}
func (m *RelevantBatchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelevantBatchRequest.Merge(m, src)
}
func (m *RelevantBatchRequest) XXX_Size() int {
	return xxx_messageInfo_RelevantBatchRequest.Size(m)
}
func (m *RelevantBatchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RelevantBatchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RelevantBatchRequest proto.InternalMessageInfo

func (m *RelevantBatchRequest) GetId() []byte {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *RelevantBatchRequest) GetAccounts() [][]byte {
	if m != nil {
		return m.Accounts
	}
	return nil
}

type RelevantBatch struct {
	// The version of the batch.
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// The unique identifier of the batch.
	Id []byte `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	//
	//The set of modifications that should be applied to the requested accounts as
	//a result of this batch.
	ChargedAccounts []*AccountDiff `protobuf:"bytes,3,rep,name=charged_accounts,json=chargedAccounts,proto3" json:"charged_accounts,omitempty"`
	//
	//The set of orders that were matched against the orders belonging to the
	//requested accounts.
	MatchedOrders map[string]*MatchedOrder `protobuf:"bytes,4,rep,name=matched_orders,json=matchedOrders,proto3" json:"matched_orders,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// The uniform clearing price rate in parts per billion of the batch.
	ClearingPriceRate uint32 `protobuf:"varint,5,opt,name=clearing_price_rate,json=clearingPriceRate,proto3" json:"clearing_price_rate,omitempty"`
	// The fee parameters used to calculate the execution fees.
	ExecutionFee *ExecutionFee `protobuf:"bytes,6,opt,name=execution_fee,json=executionFee,proto3" json:"execution_fee,omitempty"`
	// The batch transaction including all witness data.
	Transaction []byte `protobuf:"bytes,7,opt,name=transaction,proto3" json:"transaction,omitempty"`
	//
	//Fee rate of the batch transaction, expressed in satoshis per 1000 weight
	//units (sat/kW).
	FeeRateSatPerKw      uint64   `protobuf:"varint,8,opt,name=fee_rate_sat_per_kw,json=feeRateSatPerKw,proto3" json:"fee_rate_sat_per_kw,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RelevantBatch) Reset()         { *m = RelevantBatch{} }
func (m *RelevantBatch) String() string { return proto.CompactTextString(m) }
func (*RelevantBatch) ProtoMessage()    {}
func (*RelevantBatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{43}
}

func (m *RelevantBatch) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelevantBatch.Unmarshal(m, b)
}
func (m *RelevantBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelevantBatch.Marshal(b, m, deterministic)
}
func (m *RelevantBatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelevantBatch.Merge(m, src)
}
func (m *RelevantBatch) XXX_Size() int {
	return xxx_messageInfo_RelevantBatch.Size(m)
}
func (m *RelevantBatch) XXX_DiscardUnknown() {
	xxx_messageInfo_RelevantBatch.DiscardUnknown(m)
}

var xxx_messageInfo_RelevantBatch proto.InternalMessageInfo

func (m *RelevantBatch) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *RelevantBatch) GetId() []byte {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *RelevantBatch) GetChargedAccounts() []*AccountDiff {
	if m != nil {
		return m.ChargedAccounts
	}
	return nil
}

func (m *RelevantBatch) GetMatchedOrders() map[string]*MatchedOrder {
	if m != nil {
		return m.MatchedOrders
	}
	return nil
}

func (m *RelevantBatch) GetClearingPriceRate() uint32 {
	if m != nil {
		return m.ClearingPriceRate
	}
	return 0
}

func (m *RelevantBatch) GetExecutionFee() *ExecutionFee {
	if m != nil {
		return m.ExecutionFee
	}
	return nil
}

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

func (m *RelevantBatch) GetFeeRateSatPerKw() uint64 {
	if m != nil {
		return m.FeeRateSatPerKw
	}
	return 0
}

type ExecutionFee struct {
	//
	//The base fee in satoshis charged per order, regardless of the matched size.
	BaseFee uint64 `protobuf:"varint,1,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"`
	//
	//The fee rate in parts per million.
	FeeRate              uint64   `protobuf:"varint,2,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExecutionFee) Reset()         { *m = ExecutionFee{} }
func (m *ExecutionFee) String() string { return proto.CompactTextString(m) }
func (*ExecutionFee) ProtoMessage()    {}
func (*ExecutionFee) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{44}
}

func (m *ExecutionFee) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecutionFee.Unmarshal(m, b)
}
func (m *ExecutionFee) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecutionFee.Marshal(b, m, deterministic)
}
func (m *ExecutionFee) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecutionFee.Merge(m, src)
}
func (m *ExecutionFee) XXX_Size() int {
	return xxx_messageInfo_ExecutionFee.Size(m)
}
func (m *ExecutionFee) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecutionFee.DiscardUnknown(m)
}

var xxx_messageInfo_ExecutionFee proto.InternalMessageInfo

func (m *ExecutionFee) GetBaseFee() uint64 {
	if m != nil {
		return m.BaseFee
	}
	return 0
}

func (m *ExecutionFee) GetFeeRate() uint64 {
	if m != nil {
		return m.FeeRate
	}
	return 0
}

type NodeAddress struct {
	Network              string   `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"`
	Addr                 string   `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NodeAddress) Reset()         { *m = NodeAddress{} }
func (m *NodeAddress) String() string { return proto.CompactTextString(m) }
func (*NodeAddress) ProtoMessage()    {}
func (*NodeAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{45}
}

func (m *NodeAddress) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeAddress.Unmarshal(m, b)
}
func (m *NodeAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeAddress.Marshal(b, m, deterministic)
}
func (m *NodeAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeAddress.Merge(m, src)
}
func (m *NodeAddress) XXX_Size() int {
	return xxx_messageInfo_NodeAddress.Size(m)
}
func (m *NodeAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeAddress.DiscardUnknown(m)
}

var xxx_messageInfo_NodeAddress proto.InternalMessageInfo

func (m *NodeAddress) GetNetwork() string {
	if m != nil {
		return m.Network
	}
	return ""
}

func (m *NodeAddress) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

type OutPoint struct {
	//
	//Raw bytes representing the transaction id.
	Txid []byte `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`
	//
	//The index of the output on the transaction.
	OutputIndex          uint32   `protobuf:"varint,2,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OutPoint) Reset()         { *m = OutPoint{} }
func (m *OutPoint) String() string { return proto.CompactTextString(m) }
func (*OutPoint) ProtoMessage()    {}
func (*OutPoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{46}
}

func (m *OutPoint) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OutPoint.Unmarshal(m, b)
}
func (m *OutPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OutPoint.Marshal(b, m, deterministic)
}
func (m *OutPoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutPoint.Merge(m, src)
}
func (m *OutPoint) XXX_Size() int {
	return xxx_messageInfo_OutPoint.Size(m)
}
func (m *OutPoint) XXX_DiscardUnknown() {
	xxx_messageInfo_OutPoint.DiscardUnknown(m)
}

var xxx_messageInfo_OutPoint proto.InternalMessageInfo

func (m *OutPoint) GetTxid() []byte {
	if m != nil {
		return m.Txid
	}
	return nil
}

func (m *OutPoint) GetOutputIndex() uint32 {
	if m != nil {
		return m.OutputIndex
	}
	return 0
}

type AskSnapshot struct {
	// The version of the order.
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// The period of time the channel will survive for.
	LeaseDurationBlocks uint32 `protobuf:"varint,2,opt,name=lease_duration_blocks,json=leaseDurationBlocks,proto3" json:"lease_duration_blocks,omitempty"`
	// The true bid price of the order in parts per billion.
	RateFixed uint32 `protobuf:"varint,3,opt,name=rate_fixed,json=rateFixed,proto3" json:"rate_fixed,omitempty"`
	// The channel type to be created.
	ChanType             uint32   `protobuf:"varint,4,opt,name=chan_type,json=chanType,proto3" json:"chan_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AskSnapshot) Reset()         { *m = AskSnapshot{} }
func (m *AskSnapshot) String() string { return proto.CompactTextString(m) }
func (*AskSnapshot) ProtoMessage()    {}
func (*AskSnapshot) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{47}
}

func (m *AskSnapshot) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AskSnapshot.Unmarshal(m, b)
}
func (m *AskSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AskSnapshot.Marshal(b, m, deterministic)
}
func (m *AskSnapshot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AskSnapshot.Merge(m, src)
}
func (m *AskSnapshot) XXX_Size() int {
	return xxx_messageInfo_AskSnapshot.Size(m)
}
func (m *AskSnapshot) XXX_DiscardUnknown() {
	xxx_messageInfo_AskSnapshot.DiscardUnknown(m)
}

var xxx_messageInfo_AskSnapshot proto.InternalMessageInfo

func (m *AskSnapshot) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *AskSnapshot) GetLeaseDurationBlocks() uint32 {
	if m != nil {
		return m.LeaseDurationBlocks
	}
	return 0
}

func (m *AskSnapshot) GetRateFixed() uint32 {
	if m != nil {
		return m.RateFixed
	}
	return 0
}

func (m *AskSnapshot) GetChanType() uint32 {
	if m != nil {
		return m.ChanType
	}
	return 0
}

type BidSnapshot struct {
	// The version of the order.
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// The period of time the matched channel should be allocated for.
	LeaseDurationBlocks uint32 `protobuf:"varint,2,opt,name=lease_duration_blocks,json=leaseDurationBlocks,proto3" json:"lease_duration_blocks,omitempty"`
	// The true bid price of the order in parts per billion.
	RateFixed uint32 `protobuf:"varint,3,opt,name=rate_fixed,json=rateFixed,proto3" json:"rate_fixed,omitempty"`
	// The channel type to be created.
	ChanType             uint32   `protobuf:"varint,4,opt,name=chan_type,json=chanType,proto3" json:"chan_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BidSnapshot) Reset()         { *m = BidSnapshot{} }
func (m *BidSnapshot) String() string { return proto.CompactTextString(m) }
func (*BidSnapshot) ProtoMessage()    {}
func (*BidSnapshot) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{48}
}

func (m *BidSnapshot) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BidSnapshot.Unmarshal(m, b)
}
func (m *BidSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BidSnapshot.Marshal(b, m, deterministic)
}
func (m *BidSnapshot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BidSnapshot.Merge(m, src)
}
func (m *BidSnapshot) XXX_Size() int {
	return xxx_messageInfo_BidSnapshot.Size(m)
}
func (m *BidSnapshot) XXX_DiscardUnknown() {
	xxx_messageInfo_BidSnapshot.DiscardUnknown(m)
}

var xxx_messageInfo_BidSnapshot proto.InternalMessageInfo

func (m *BidSnapshot) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *BidSnapshot) GetLeaseDurationBlocks() uint32 {
	if m != nil {
		return m.LeaseDurationBlocks
	}
	return 0
}

func (m *BidSnapshot) GetRateFixed() uint32 {
	if m != nil {
		return m.RateFixed
	}
	return 0
}

func (m *BidSnapshot) GetChanType() uint32 {
	if m != nil {
		return m.ChanType
	}
	return 0
}

type MatchedOrderSnapshot struct {
	// The full ask order that was matched.
	Ask *AskSnapshot `protobuf:"bytes,1,opt,name=ask,proto3" json:"ask,omitempty"`
	// The full bid order that was matched.
	Bid *BidSnapshot `protobuf:"bytes,2,opt,name=bid,proto3" json:"bid,omitempty"`
	// The fixed rate premium that was matched, expressed in parts-ber-billion.
	MatchingRate uint32 `protobuf:"varint,3,opt,name=matching_rate,json=matchingRate,proto3" json:"matching_rate,omitempty"`
	// The total number of satoshis that were bought.
	TotalSatsCleared uint64 `protobuf:"varint,4,opt,name=total_sats_cleared,json=totalSatsCleared,proto3" json:"total_sats_cleared,omitempty"`
	// The total number of units that were matched.
	UnitsMatched         uint32   `protobuf:"varint,5,opt,name=units_matched,json=unitsMatched,proto3" json:"units_matched,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchedOrderSnapshot) Reset()         { *m = MatchedOrderSnapshot{} }
func (m *MatchedOrderSnapshot) String() string { return proto.CompactTextString(m) }
func (*MatchedOrderSnapshot) ProtoMessage()    {}
func (*MatchedOrderSnapshot) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{49}
}

func (m *MatchedOrderSnapshot) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchedOrderSnapshot.Unmarshal(m, b)
}
func (m *MatchedOrderSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchedOrderSnapshot.Marshal(b, m, deterministic)
}
func (m *MatchedOrderSnapshot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchedOrderSnapshot.Merge(m, src)
}
func (m *MatchedOrderSnapshot) XXX_Size() int {
	return xxx_messageInfo_MatchedOrderSnapshot.Size(m)
}
func (m *MatchedOrderSnapshot) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchedOrderSnapshot.DiscardUnknown(m)
}

var xxx_messageInfo_MatchedOrderSnapshot proto.InternalMessageInfo

func (m *MatchedOrderSnapshot) GetAsk() *AskSnapshot {
	if m != nil {
		return m.Ask
	}
	return nil
}

func (m *MatchedOrderSnapshot) GetBid() *BidSnapshot {
	if m != nil {
		return m.Bid
	}
	return nil
}

func (m *MatchedOrderSnapshot) GetMatchingRate() uint32 {
	if m != nil {
		return m.MatchingRate
	}
	return 0
}

func (m *MatchedOrderSnapshot) GetTotalSatsCleared() uint64 {
	if m != nil {
		return m.TotalSatsCleared
	}
	return 0
}

func (m *MatchedOrderSnapshot) GetUnitsMatched() uint32 {
	if m != nil {
		return m.UnitsMatched
	}
	return 0
}

type BatchSnapshotRequest struct {
	// The unique identifier of the batch encoded as a compressed pubkey.
	BatchId              []byte   `protobuf:"bytes,1,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BatchSnapshotRequest) Reset()         { *m = BatchSnapshotRequest{} }
func (m *BatchSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*BatchSnapshotRequest) ProtoMessage()    {}
func (*BatchSnapshotRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{50}
}

func (m *BatchSnapshotRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BatchSnapshotRequest.Unmarshal(m, b)
}
func (m *BatchSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BatchSnapshotRequest.Marshal(b, m, deterministic)
}
func (m *BatchSnapshotRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BatchSnapshotRequest.Merge(m, src)
}
func (m *BatchSnapshotRequest) XXX_Size() int {
	return xxx_messageInfo_BatchSnapshotRequest.Size(m)
}
func (m *BatchSnapshotRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BatchSnapshotRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BatchSnapshotRequest proto.InternalMessageInfo

func (m *BatchSnapshotRequest) GetBatchId() []byte {
	if m != nil {
		return m.BatchId
	}
	return nil
}

type BatchSnapshotResponse struct {
	// The version of the batch.
	Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// The unique identifier of the batch.
	BatchId []byte `protobuf:"bytes,2,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	// The unique identifier of the prior batch.
	PrevBatchId []byte `protobuf:"bytes,3,opt,name=prev_batch_id,json=prevBatchId,proto3" json:"prev_batch_id,omitempty"`
	// The uniform clearing price rate in parts per billion of the batch.
	ClearingPriceRate uint32 `protobuf:"varint,4,opt,name=clearing_price_rate,json=clearingPriceRate,proto3" json:"clearing_price_rate,omitempty"`
	// The set of all orders matched in the batch.
	MatchedOrders []*MatchedOrderSnapshot `protobuf:"bytes,5,rep,name=matched_orders,json=matchedOrders,proto3" json:"matched_orders,omitempty"`
	// The txid of the batch transaction.
	BatchTxId string `protobuf:"bytes,7,opt,name=batch_tx_id,json=batchTxId,proto3" json:"batch_tx_id,omitempty"`
	// The batch transaction including all witness data.
	BatchTx              []byte   `protobuf:"bytes,6,opt,name=batch_tx,json=batchTx,proto3" json:"batch_tx,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BatchSnapshotResponse) Reset()         { *m = BatchSnapshotResponse{} }
func (m *BatchSnapshotResponse) String() string { return proto.CompactTextString(m) }
func (*BatchSnapshotResponse) ProtoMessage()    {}
func (*BatchSnapshotResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{51}
}

func (m *BatchSnapshotResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BatchSnapshotResponse.Unmarshal(m, b)
}
func (m *BatchSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BatchSnapshotResponse.Marshal(b, m, deterministic)
}
func (m *BatchSnapshotResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BatchSnapshotResponse.Merge(m, src)
}
func (m *BatchSnapshotResponse) XXX_Size() int {
	return xxx_messageInfo_BatchSnapshotResponse.Size(m)
}
func (m *BatchSnapshotResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BatchSnapshotResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BatchSnapshotResponse proto.InternalMessageInfo

func (m *BatchSnapshotResponse) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *BatchSnapshotResponse) GetBatchId() []byte {
	if m != nil {
		return m.BatchId
	}
	return nil
}

func (m *BatchSnapshotResponse) GetPrevBatchId() []byte {
	if m != nil {
		return m.PrevBatchId
	}
	return nil
}

func (m *BatchSnapshotResponse) GetClearingPriceRate() uint32 {
	if m != nil {
		return m.ClearingPriceRate
	}
	return 0
}

func (m *BatchSnapshotResponse) GetMatchedOrders() []*MatchedOrderSnapshot {
	if m != nil {
		return m.MatchedOrders
	}
	return nil
}

func (m *BatchSnapshotResponse) GetBatchTxId() string {
	if m != nil {
		return m.BatchTxId
	}
	return ""
}

func (m *BatchSnapshotResponse) GetBatchTx() []byte {
	if m != nil {
		return m.BatchTx
	}
	return nil
}

type ServerNodeRatingRequest struct {
	// The target node to obtain ratings information for.
	NodePubkeys          [][]byte `protobuf:"bytes,1,rep,name=node_pubkeys,json=nodePubkeys,proto3" json:"node_pubkeys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServerNodeRatingRequest) Reset()         { *m = ServerNodeRatingRequest{} }
func (m *ServerNodeRatingRequest) String() string { return proto.CompactTextString(m) }
func (*ServerNodeRatingRequest) ProtoMessage()    {}
func (*ServerNodeRatingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{52}
}

func (m *ServerNodeRatingRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerNodeRatingRequest.Unmarshal(m, b)
}
func (m *ServerNodeRatingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerNodeRatingRequest.Marshal(b, m, deterministic)
}
func (m *ServerNodeRatingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerNodeRatingRequest.Merge(m, src)
}
func (m *ServerNodeRatingRequest) XXX_Size() int {
	return xxx_messageInfo_ServerNodeRatingRequest.Size(m)
}
func (m *ServerNodeRatingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerNodeRatingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServerNodeRatingRequest proto.InternalMessageInfo

func (m *ServerNodeRatingRequest) GetNodePubkeys() [][]byte {
	if m != nil {
		return m.NodePubkeys
	}
	return nil
}

type NodeRating struct {
	// The pubkey for the node these ratings belong to.
	NodePubkey []byte `protobuf:"bytes,1,opt,name=node_pubkey,json=nodePubkey,proto3" json:"node_pubkey,omitempty"`
	// The tier of the target node.
	NodeTier             NodeTier `protobuf:"varint,2,opt,name=node_tier,json=nodeTier,proto3,enum=poolrpc.NodeTier" json:"node_tier,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NodeRating) Reset()         { *m = NodeRating{} }
func (m *NodeRating) String() string { return proto.CompactTextString(m) }
func (*NodeRating) ProtoMessage()    {}
func (*NodeRating) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{53}
}

func (m *NodeRating) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeRating.Unmarshal(m, b)
}
func (m *NodeRating) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeRating.Marshal(b, m, deterministic)
}
func (m *NodeRating) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeRating.Merge(m, src)
}
func (m *NodeRating) XXX_Size() int {
	return xxx_messageInfo_NodeRating.Size(m)
}
func (m *NodeRating) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeRating.DiscardUnknown(m)
}

var xxx_messageInfo_NodeRating proto.InternalMessageInfo

func (m *NodeRating) GetNodePubkey() []byte {
	if m != nil {
		return m.NodePubkey
	}
	return nil
}

func (m *NodeRating) GetNodeTier() NodeTier {
	if m != nil {
		return m.NodeTier
	}
	return NodeTier_TIER_DEFAULT
}

type ServerNodeRatingResponse struct {
	// A series of node ratings for each of the queried nodes.
	NodeRatings          []*NodeRating `protobuf:"bytes,1,rep,name=node_ratings,json=nodeRatings,proto3" json:"node_ratings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *ServerNodeRatingResponse) Reset()         { *m = ServerNodeRatingResponse{} }
func (m *ServerNodeRatingResponse) String() string { return proto.CompactTextString(m) }
func (*ServerNodeRatingResponse) ProtoMessage()    {}
func (*ServerNodeRatingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f3883418d94ca37f, []int{54}
}

func (m *ServerNodeRatingResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServerNodeRatingResponse.Unmarshal(m, b)
}
func (m *ServerNodeRatingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServerNodeRatingResponse.Marshal(b, m, deterministic)
}
func (m *ServerNodeRatingResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServerNodeRatingResponse.Merge(m, src)
}
func (m *ServerNodeRatingResponse) XXX_Size() int {
	return xxx_messageInfo_ServerNodeRatingResponse.Size(m)
}
func (m *ServerNodeRatingResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ServerNodeRatingResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ServerNodeRatingResponse proto.InternalMessageInfo

func (m *ServerNodeRatingResponse) GetNodeRatings() []*NodeRating {
	if m != nil {
		return m.NodeRatings
	}
	return nil
}

func init() {
	proto.RegisterEnum("poolrpc.ChannelType", ChannelType_name, ChannelType_value)
	proto.RegisterEnum("poolrpc.AuctionAccountState", AuctionAccountState_name, AuctionAccountState_value)
	proto.RegisterEnum("poolrpc.NodeTier", NodeTier_name, NodeTier_value)
	proto.RegisterEnum("poolrpc.OrderState", OrderState_name, OrderState_value)
	proto.RegisterEnum("poolrpc.OrderMatchReject_RejectReason", OrderMatchReject_RejectReason_name, OrderMatchReject_RejectReason_value)
	proto.RegisterEnum("poolrpc.OrderReject_OrderRejectReason", OrderReject_OrderRejectReason_name, OrderReject_OrderRejectReason_value)
	proto.RegisterEnum("poolrpc.SubscribeError_Error", SubscribeError_Error_name, SubscribeError_Error_value)
	proto.RegisterEnum("poolrpc.AccountDiff_AccountState", AccountDiff_AccountState_name, AccountDiff_AccountState_value)
	proto.RegisterEnum("poolrpc.InvalidOrder_FailReason", InvalidOrder_FailReason_name, InvalidOrder_FailReason_value)
	proto.RegisterType((*ReserveAccountRequest)(nil), "poolrpc.ReserveAccountRequest")
	proto.RegisterType((*ReserveAccountResponse)(nil), "poolrpc.ReserveAccountResponse")
	proto.RegisterType((*ServerInitAccountRequest)(nil), "poolrpc.ServerInitAccountRequest")
	proto.RegisterType((*ServerInitAccountResponse)(nil), "poolrpc.ServerInitAccountResponse")
	proto.RegisterType((*ServerSubmitOrderRequest)(nil), "poolrpc.ServerSubmitOrderRequest")
	proto.RegisterType((*ServerSubmitOrderResponse)(nil), "poolrpc.ServerSubmitOrderResponse")
	proto.RegisterType((*ServerCancelOrderRequest)(nil), "poolrpc.ServerCancelOrderRequest")
	proto.RegisterType((*ServerCancelOrderResponse)(nil), "poolrpc.ServerCancelOrderResponse")
	proto.RegisterType((*ClientAuctionMessage)(nil), "poolrpc.ClientAuctionMessage")
	proto.RegisterType((*AccountCommitment)(nil), "poolrpc.AccountCommitment")
	proto.RegisterType((*AccountSubscription)(nil), "poolrpc.AccountSubscription")
	proto.RegisterType((*OrderMatchAccept)(nil), "poolrpc.OrderMatchAccept")
	proto.RegisterType((*OrderMatchReject)(nil), "poolrpc.OrderMatchReject")
	proto.RegisterMapType((map[string]*OrderReject)(nil), "poolrpc.OrderMatchReject.RejectedOrdersEntry")
	proto.RegisterType((*OrderReject)(nil), "poolrpc.OrderReject")
	proto.RegisterType((*ChannelInfo)(nil), "poolrpc.ChannelInfo")
	proto.RegisterType((*OrderMatchSign)(nil), "poolrpc.OrderMatchSign")
	proto.RegisterMapType((map[string][]byte)(nil), "poolrpc.OrderMatchSign.AccountSigsEntry")
	proto.RegisterMapType((map[string]*ChannelInfo)(nil), "poolrpc.OrderMatchSign.ChannelInfosEntry")
	proto.RegisterType((*AccountRecovery)(nil), "poolrpc.AccountRecovery")
	proto.RegisterType((*ServerAuctionMessage)(nil), "poolrpc.ServerAuctionMessage")
	proto.RegisterType((*ServerChallenge)(nil), "poolrpc.ServerChallenge")
	proto.RegisterType((*SubscribeSuccess)(nil), "poolrpc.SubscribeSuccess")
	proto.RegisterType((*OrderMatchPrepare)(nil), "poolrpc.OrderMatchPrepare")
	proto.RegisterMapType((map[string]*MatchedOrder)(nil), "poolrpc.OrderMatchPrepare.MatchedOrdersEntry")
	proto.RegisterType((*OrderMatchSignBegin)(nil), "poolrpc.OrderMatchSignBegin")
	proto.RegisterType((*OrderMatchFinalize)(nil), "poolrpc.OrderMatchFinalize")
	proto.RegisterType((*SubscribeError)(nil), "poolrpc.SubscribeError")
	proto.RegisterType((*AuctionAccount)(nil), "poolrpc.AuctionAccount")
	proto.RegisterType((*MatchedOrder)(nil), "poolrpc.MatchedOrder")
	proto.RegisterType((*MatchedAsk)(nil), "poolrpc.MatchedAsk")
	proto.RegisterType((*MatchedBid)(nil), "poolrpc.MatchedBid")
	proto.RegisterType((*AccountDiff)(nil), "poolrpc.AccountDiff")
	proto.RegisterType((*ServerOrder)(nil), "poolrpc.ServerOrder")
	proto.RegisterType((*ServerBid)(nil), "poolrpc.ServerBid")
	proto.RegisterType((*ServerAsk)(nil), "poolrpc.ServerAsk")
	proto.RegisterType((*CancelOrder)(nil), "poolrpc.CancelOrder")
	proto.RegisterType((*InvalidOrder)(nil), "poolrpc.InvalidOrder")
	proto.RegisterType((*ServerInput)(nil), "poolrpc.ServerInput")
	proto.RegisterType((*ServerOutput)(nil), "poolrpc.ServerOutput")
	proto.RegisterType((*ServerModifyAccountRequest)(nil), "poolrpc.ServerModifyAccountRequest")
	proto.RegisterType((*ServerModifyAccountRequest_NewAccountParameters)(nil), "poolrpc.ServerModifyAccountRequest.NewAccountParameters")
	proto.RegisterType((*ServerModifyAccountResponse)(nil), "poolrpc.ServerModifyAccountResponse")
	proto.RegisterType((*ServerOrderStateRequest)(nil), "poolrpc.ServerOrderStateRequest")
	proto.RegisterType((*ServerOrderStateResponse)(nil), "poolrpc.ServerOrderStateResponse")
	proto.RegisterType((*TermsRequest)(nil), "poolrpc.TermsRequest")
	proto.RegisterType((*TermsResponse)(nil), "poolrpc.TermsResponse")
	proto.RegisterMapType((map[uint32]bool)(nil), "poolrpc.TermsResponse.LeaseDurationsEntry")
	proto.RegisterType((*RelevantBatchRequest)(nil), "poolrpc.RelevantBatchRequest")
	proto.RegisterType((*RelevantBatch)(nil), "poolrpc.RelevantBatch")
	proto.RegisterMapType((map[string]*MatchedOrder)(nil), "poolrpc.RelevantBatch.MatchedOrdersEntry")
	proto.RegisterType((*ExecutionFee)(nil), "poolrpc.ExecutionFee")
	proto.RegisterType((*NodeAddress)(nil), "poolrpc.NodeAddress")
	proto.RegisterType((*OutPoint)(nil), "poolrpc.OutPoint")
	proto.RegisterType((*AskSnapshot)(nil), "poolrpc.AskSnapshot")
	proto.RegisterType((*BidSnapshot)(nil), "poolrpc.BidSnapshot")
	proto.RegisterType((*MatchedOrderSnapshot)(nil), "poolrpc.MatchedOrderSnapshot")
	proto.RegisterType((*BatchSnapshotRequest)(nil), "poolrpc.BatchSnapshotRequest")
	proto.RegisterType((*BatchSnapshotResponse)(nil), "poolrpc.BatchSnapshotResponse")
	proto.RegisterType((*ServerNodeRatingRequest)(nil), "poolrpc.ServerNodeRatingRequest")
	proto.RegisterType((*NodeRating)(nil), "poolrpc.NodeRating")
	proto.RegisterType((*ServerNodeRatingResponse)(nil), "poolrpc.ServerNodeRatingResponse")
}

func init() { proto.RegisterFile("auctioneer.proto", fileDescriptor_f3883418d94ca37f) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ChannelAuctioneerClient is the client API for ChannelAuctioneer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ChannelAuctioneerClient interface {
	ReserveAccount(ctx context.Context, in *ReserveAccountRequest, opts ...grpc.CallOption) (*ReserveAccountResponse, error)
	InitAccount(ctx context.Context, in *ServerInitAccountRequest, opts ...grpc.CallOption) (*ServerInitAccountResponse, error)
	ModifyAccount(ctx context.Context, in *ServerModifyAccountRequest, opts ...grpc.CallOption) (*ServerModifyAccountResponse, error)
	SubmitOrder(ctx context.Context, in *ServerSubmitOrderRequest, opts ...grpc.CallOption) (*ServerSubmitOrderResponse, error)
	CancelOrder(ctx context.Context, in *ServerCancelOrderRequest, opts ...grpc.CallOption) (*ServerCancelOrderResponse, error)
	OrderState(ctx context.Context, in *ServerOrderStateRequest, opts ...grpc.CallOption) (*ServerOrderStateResponse, error)
	SubscribeBatchAuction(ctx context.Context, opts ...grpc.CallOption) (ChannelAuctioneer_SubscribeBatchAuctionClient, error)
	Terms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error)
	RelevantBatchSnapshot(ctx context.Context, in *RelevantBatchRequest, opts ...grpc.CallOption) (*RelevantBatch, error)
	BatchSnapshot(ctx context.Context, in *BatchSnapshotRequest, opts ...grpc.CallOption) (*BatchSnapshotResponse, error)
	NodeRating(ctx context.Context, in *ServerNodeRatingRequest, opts ...grpc.CallOption) (*ServerNodeRatingResponse, error)
}

type channelAuctioneerClient struct {
	cc *grpc.ClientConn
}

func NewChannelAuctioneerClient(cc *grpc.ClientConn) ChannelAuctioneerClient {
	return &channelAuctioneerClient{cc}
}

func (c *channelAuctioneerClient) ReserveAccount(ctx context.Context, in *ReserveAccountRequest, opts ...grpc.CallOption) (*ReserveAccountResponse, error) {
	out := new(ReserveAccountResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/ReserveAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) InitAccount(ctx context.Context, in *ServerInitAccountRequest, opts ...grpc.CallOption) (*ServerInitAccountResponse, error) {
	out := new(ServerInitAccountResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/InitAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) ModifyAccount(ctx context.Context, in *ServerModifyAccountRequest, opts ...grpc.CallOption) (*ServerModifyAccountResponse, error) {
	out := new(ServerModifyAccountResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/ModifyAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) SubmitOrder(ctx context.Context, in *ServerSubmitOrderRequest, opts ...grpc.CallOption) (*ServerSubmitOrderResponse, error) {
	out := new(ServerSubmitOrderResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/SubmitOrder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) CancelOrder(ctx context.Context, in *ServerCancelOrderRequest, opts ...grpc.CallOption) (*ServerCancelOrderResponse, error) {
	out := new(ServerCancelOrderResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/CancelOrder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) OrderState(ctx context.Context, in *ServerOrderStateRequest, opts ...grpc.CallOption) (*ServerOrderStateResponse, error) {
	out := new(ServerOrderStateResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/OrderState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) SubscribeBatchAuction(ctx context.Context, opts ...grpc.CallOption) (ChannelAuctioneer_SubscribeBatchAuctionClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ChannelAuctioneer_serviceDesc.Streams[0], "/poolrpc.ChannelAuctioneer/SubscribeBatchAuction", opts...)
	if err != nil {
		return nil, err
	}
	x := &channelAuctioneerSubscribeBatchAuctionClient{stream}
	return x, nil
}

type ChannelAuctioneer_SubscribeBatchAuctionClient interface {
	Send(*ClientAuctionMessage) error
	Recv() (*ServerAuctionMessage, error)
	grpc.ClientStream
}

type channelAuctioneerSubscribeBatchAuctionClient struct {
	grpc.ClientStream
}

func (x *channelAuctioneerSubscribeBatchAuctionClient) Send(m *ClientAuctionMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *channelAuctioneerSubscribeBatchAuctionClient) Recv() (*ServerAuctionMessage, error) {
	m := new(ServerAuctionMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *channelAuctioneerClient) Terms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) {
	out := new(TermsResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/Terms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) RelevantBatchSnapshot(ctx context.Context, in *RelevantBatchRequest, opts ...grpc.CallOption) (*RelevantBatch, error) {
	out := new(RelevantBatch)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/RelevantBatchSnapshot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) BatchSnapshot(ctx context.Context, in *BatchSnapshotRequest, opts ...grpc.CallOption) (*BatchSnapshotResponse, error) {
	out := new(BatchSnapshotResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/BatchSnapshot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelAuctioneerClient) NodeRating(ctx context.Context, in *ServerNodeRatingRequest, opts ...grpc.CallOption) (*ServerNodeRatingResponse, error) {
	out := new(ServerNodeRatingResponse)
	err := c.cc.Invoke(ctx, "/poolrpc.ChannelAuctioneer/NodeRating", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ChannelAuctioneerServer is the server API for ChannelAuctioneer service.
type ChannelAuctioneerServer interface {
	ReserveAccount(context.Context, *ReserveAccountRequest) (*ReserveAccountResponse, error)
	InitAccount(context.Context, *ServerInitAccountRequest) (*ServerInitAccountResponse, error)
	ModifyAccount(context.Context, *ServerModifyAccountRequest) (*ServerModifyAccountResponse, error)
	SubmitOrder(context.Context, *ServerSubmitOrderRequest) (*ServerSubmitOrderResponse, error)
	CancelOrder(context.Context, *ServerCancelOrderRequest) (*ServerCancelOrderResponse, error)
	OrderState(context.Context, *ServerOrderStateRequest) (*ServerOrderStateResponse, error)
	SubscribeBatchAuction(ChannelAuctioneer_SubscribeBatchAuctionServer) error
	Terms(context.Context, *TermsRequest) (*TermsResponse, error)
	RelevantBatchSnapshot(context.Context, *RelevantBatchRequest) (*RelevantBatch, error)
	BatchSnapshot(context.Context, *BatchSnapshotRequest) (*BatchSnapshotResponse, error)
	NodeRating(context.Context, *ServerNodeRatingRequest) (*ServerNodeRatingResponse, error)
}

// UnimplementedChannelAuctioneerServer can be embedded to have forward compatible implementations.
type UnimplementedChannelAuctioneerServer struct {
}

func (*UnimplementedChannelAuctioneerServer) ReserveAccount(ctx context.Context, req *ReserveAccountRequest) (*ReserveAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReserveAccount not implemented")
}
func (*UnimplementedChannelAuctioneerServer) InitAccount(ctx context.Context, req *ServerInitAccountRequest) (*ServerInitAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitAccount not implemented")
}
func (*UnimplementedChannelAuctioneerServer) ModifyAccount(ctx context.Context, req *ServerModifyAccountRequest) (*ServerModifyAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifyAccount not implemented")
}
func (*UnimplementedChannelAuctioneerServer) SubmitOrder(ctx context.Context, req *ServerSubmitOrderRequest) (*ServerSubmitOrderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitOrder not implemented")
}
func (*UnimplementedChannelAuctioneerServer) CancelOrder(ctx context.Context, req *ServerCancelOrderRequest) (*ServerCancelOrderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelOrder not implemented")
}
func (*UnimplementedChannelAuctioneerServer) OrderState(ctx context.Context, req *ServerOrderStateRequest) (*ServerOrderStateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OrderState not implemented")
}
func (*UnimplementedChannelAuctioneerServer) SubscribeBatchAuction(srv ChannelAuctioneer_SubscribeBatchAuctionServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeBatchAuction not implemented")
}
func (*UnimplementedChannelAuctioneerServer) Terms(ctx context.Context, req *TermsRequest) (*TermsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Terms not implemented")
}
func (*UnimplementedChannelAuctioneerServer) RelevantBatchSnapshot(ctx context.Context, req *RelevantBatchRequest) (*RelevantBatch, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RelevantBatchSnapshot not implemented")
}
func (*UnimplementedChannelAuctioneerServer) BatchSnapshot(ctx context.Context, req *BatchSnapshotRequest) (*BatchSnapshotResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchSnapshot not implemented")
}
func (*UnimplementedChannelAuctioneerServer) NodeRating(ctx context.Context, req *ServerNodeRatingRequest) (*ServerNodeRatingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NodeRating not implemented")
}

func RegisterChannelAuctioneerServer(s *grpc.Server, srv ChannelAuctioneerServer) {
	s.RegisterService(&_ChannelAuctioneer_serviceDesc, srv)
}

func _ChannelAuctioneer_ReserveAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReserveAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).ReserveAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/ReserveAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).ReserveAccount(ctx, req.(*ReserveAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_InitAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerInitAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).InitAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/InitAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).InitAccount(ctx, req.(*ServerInitAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_ModifyAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerModifyAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).ModifyAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/ModifyAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).ModifyAccount(ctx, req.(*ServerModifyAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_SubmitOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerSubmitOrderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).SubmitOrder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/SubmitOrder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).SubmitOrder(ctx, req.(*ServerSubmitOrderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_CancelOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerCancelOrderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).CancelOrder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/CancelOrder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).CancelOrder(ctx, req.(*ServerCancelOrderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_OrderState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerOrderStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).OrderState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/OrderState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).OrderState(ctx, req.(*ServerOrderStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_SubscribeBatchAuction_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ChannelAuctioneerServer).SubscribeBatchAuction(&channelAuctioneerSubscribeBatchAuctionServer{stream})
}

type ChannelAuctioneer_SubscribeBatchAuctionServer interface {
	Send(*ServerAuctionMessage) error
	Recv() (*ClientAuctionMessage, error)
	grpc.ServerStream
}

type channelAuctioneerSubscribeBatchAuctionServer struct {
	grpc.ServerStream
}

func (x *channelAuctioneerSubscribeBatchAuctionServer) Send(m *ServerAuctionMessage) error {
	return x.ServerStream.SendMsg(m)
}

func (x *channelAuctioneerSubscribeBatchAuctionServer) Recv() (*ClientAuctionMessage, error) {
	m := new(ClientAuctionMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ChannelAuctioneer_Terms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TermsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).Terms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/Terms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).Terms(ctx, req.(*TermsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_RelevantBatchSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RelevantBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).RelevantBatchSnapshot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/RelevantBatchSnapshot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).RelevantBatchSnapshot(ctx, req.(*RelevantBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_BatchSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchSnapshotRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).BatchSnapshot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/BatchSnapshot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).BatchSnapshot(ctx, req.(*BatchSnapshotRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChannelAuctioneer_NodeRating_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerNodeRatingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelAuctioneerServer).NodeRating(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/poolrpc.ChannelAuctioneer/NodeRating",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelAuctioneerServer).NodeRating(ctx, req.(*ServerNodeRatingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ChannelAuctioneer_serviceDesc = grpc.ServiceDesc{
	ServiceName: "poolrpc.ChannelAuctioneer",
	HandlerType: (*ChannelAuctioneerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ReserveAccount",
			Handler:    _ChannelAuctioneer_ReserveAccount_Handler,
		},
		{
			MethodName: "InitAccount",
			Handler:    _ChannelAuctioneer_InitAccount_Handler,
		},
		{
			MethodName: "ModifyAccount",
			Handler:    _ChannelAuctioneer_ModifyAccount_Handler,
		},
		{
			MethodName: "SubmitOrder",
			Handler:    _ChannelAuctioneer_SubmitOrder_Handler,
		},
		{
			MethodName: "CancelOrder",
			Handler:    _ChannelAuctioneer_CancelOrder_Handler,
		},
		{
			MethodName: "OrderState",
			Handler:    _ChannelAuctioneer_OrderState_Handler,
		},
		{
			MethodName: "Terms",
			Handler:    _ChannelAuctioneer_Terms_Handler,
		},
		{
			MethodName: "RelevantBatchSnapshot",
			Handler:    _ChannelAuctioneer_RelevantBatchSnapshot_Handler,
		},
		{
			MethodName: "BatchSnapshot",
			Handler:    _ChannelAuctioneer_BatchSnapshot_Handler,
		},
		{
			MethodName: "NodeRating",
			Handler:    _ChannelAuctioneer_NodeRating_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SubscribeBatchAuction",
			Handler:       _ChannelAuctioneer_SubscribeBatchAuction_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "auctioneer.proto",
}