frdrpc

type BitcoinPrice struct {
	// The price of 1 BTC, expressed in USD.
	Price string `protobuf:"bytes,1,opt,name=price,proto3" json:"price,omitempty"`
	// The timestamp for this price price provided.
	PriceTimestamp       uint64   `protobuf:"varint,2,opt,name=price_timestamp,json=priceTimestamp,proto3" json:"price_timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ChannelInsight struct {
	// The outpoint of the channel's funding transaction.
	ChanPoint string `protobuf:"bytes,1,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"`
	//
	//The amount of time in seconds that we have monitored the channel peer's
	//uptime for.
	MonitoredSeconds uint64 `protobuf:"varint,2,opt,name=monitored_seconds,json=monitoredSeconds,proto3" json:"monitored_seconds,omitempty"`
	//
	//The amount of time in seconds that the channel peer has been online over
	//the period it has been monitored for.
	UptimeSeconds uint64 `protobuf:"varint,3,opt,name=uptime_seconds,json=uptimeSeconds,proto3" json:"uptime_seconds,omitempty"`
	//
	//The volume, in millisatoshis, that has been forwarded with this channel as
	//the incoming channel.
	VolumeIncomingMsat int64 `protobuf:"varint,4,opt,name=volume_incoming_msat,json=volumeIncomingMsat,proto3" json:"volume_incoming_msat,omitempty"`
	//
	//The volume, in millisatoshis, that has been forwarded with this channel as
	//the outgoing channel.
	VolumeOutgoingMsat int64 `protobuf:"varint,5,opt,name=volume_outgoing_msat,json=volumeOutgoingMsat,proto3" json:"volume_outgoing_msat,omitempty"`
	//
	//The total fees earned by this channel for its participation in forwards,
	//expressed in millisatoshis. Note that we attribute fees evenly across
	//incoming and outgoing channels.
	FeesEarnedMsat int64 `protobuf:"varint,6,opt,name=fees_earned_msat,json=feesEarnedMsat,proto3" json:"fees_earned_msat,omitempty"`
	// The number of confirmations the funding transaction has.
	Confirmations uint32 `protobuf:"varint,7,opt,name=confirmations,proto3" json:"confirmations,omitempty"`
	// True if the channel is private.
	Private              bool     `protobuf:"varint,8,opt,name=private,proto3" json:"private,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

type ChannelInsightsResponse struct {
	// Insights for the set of currently open channels.
	ChannelInsights      []*ChannelInsight `protobuf:"bytes,1,rep,name=channel_insights,json=channelInsights,proto3" json:"channel_insights,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

type CloseRecommendationRequest struct {
	//
	//The minimum amount of time in seconds that a channel should have been
	//monitored by lnd to be eligible for close. This value is in place to
	//protect against closing of newer channels.
	MinimumMonitored int64 `protobuf:"varint,1,opt,name=minimum_monitored,json=minimumMonitored,proto3" json:"minimum_monitored,omitempty"`
	//
	//The data point base close recommendations on. Available options are:
	//Uptime: ratio of channel peer's uptime to the period they have been
	//monitored to.
	//Revenue: the revenue that the channel has produced per block that its
	//funding transaction has been confirmed for.
	Metric               CloseRecommendationRequest_Metric `protobuf:"varint,2,opt,name=metric,proto3,enum=frdrpc.CloseRecommendationRequest_Metric" json:"metric,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

type CloseRecommendationRequest_Metric int32

type CloseRecommendationsResponse struct {
	//
	//The total number of channels, before filtering out channels that are
	//not eligible for close recommendations.
	TotalChannels int32 `protobuf:"varint,1,opt,name=total_channels,json=totalChannels,proto3" json:"total_channels,omitempty"`
	//
	//The number of channels that were considered for close recommendations.
	ConsideredChannels int32 `protobuf:"varint,2,opt,name=considered_channels,json=consideredChannels,proto3" json:"considered_channels,omitempty"`
	//
	//A set of channel close recommendations. The absence of a channel in this
	//set implies that it was not considered for close because it did not meet
	//the criteria for close recommendations (it is private, or has not been
	//monitored for long enough).
	Recommendations      []*Recommendation `protobuf:"bytes,3,rep,name=recommendations,proto3" json:"recommendations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

type CloseReportRequest struct {
	//
	//The funding outpoint of the channel the report should be created for,
	//formatted txid:outpoint.
	ChannelPoint         string   `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type CloseReportResponse struct {
	// The funding outpoint of the channel.
	ChannelPoint string `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"`
	// True if we opened the channel, false if the remote peer did.
	ChannelInitiator bool `protobuf:"varint,2,opt,name=channel_initiator,json=channelInitiator,proto3" json:"channel_initiator,omitempty"`
	// The type of close that resolved this channel.
	CloseType string `protobuf:"bytes,3,opt,name=close_type,json=closeType,proto3" json:"close_type,omitempty"`
	// The transaction id of the close transaction that confirmed on chain.
	CloseTxid string `protobuf:"bytes,4,opt,name=close_txid,json=closeTxid,proto3" json:"close_txid,omitempty"`
	//
	//The fee we paid on chain to open this channel in satoshis, note that this
	//field will be zero if the remote party paid.
	OpenFee string `protobuf:"bytes,5,opt,name=open_fee,json=openFee,proto3" json:"open_fee,omitempty"`
	//
	//The fee we paid on chain for the close transaction in staoshis, note that
	//this field will be zero if the remote party paid.
	CloseFee             string   `protobuf:"bytes,6,opt,name=close_fee,json=closeFee,proto3" json:"close_fee,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Config struct {
	// Lnd is a client which can be used to query lnd.
	Lnd lndclient.LndServices

	// RPCListen is the address:port that the gRPC server should listen on.
	RPCListen string

	// RESTListen is the address:port that the REST server should listen on.
	RESTListen string

	// CORSOrigin specifies the CORS header that should be set on REST
	// responses. No header is added if the value is empty.
	CORSOrigin string

	// BitcoinClient is set if the client opted to connect to a bitcoin
	// backend, if not, it will be nil.
	BitcoinClient chain.BitcoinClient

	// TLSServerConfig is the configuration to serve a secure connection
	// over TLS.
	TLSServerConfig *tls.Config

	// RestClientConfig is the client configuration to connect to a TLS
	// server started with the TLS config above. This is used for the REST
	// proxy that connects internally to the gRPC server and therefore is a
	// TLS client.
	RestClientConfig *credentials.TransportCredentials

	// FaradayDir is the main directory faraday uses. The macaroon database
	// will be created there.
	FaradayDir string

	// MacaroonPath is the full path to the default faraday macaroon file
	// that is created automatically. This path normally is within
	// FaradayDir unless otherwise specified by the user.
	MacaroonPath string
}

type EntryType int32

type ExchangeRate struct {
	// timestamp is the timestamp of the original request made.
	Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	//
	//Price is the bitcoin price approximation for the timestamp queried. Note
	//that this value has its own timestamp because we are not guaranteed to get
	//price points for the exact timestamp that was queried.
	BtcPrice             *BitcoinPrice `protobuf:"bytes,2,opt,name=btc_price,json=btcPrice,proto3" json:"btc_price,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

type ExchangeRateRequest struct {
	// A set of timestamps for which we want the bitcoin price.
	Timestamps []uint64 `protobuf:"varint,3,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"`
	// The level of granularity at which we want the bitcoin price to be quoted.
	Granularity          Granularity `protobuf:"varint,4,opt,name=granularity,proto3,enum=frdrpc.Granularity" json:"granularity,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

type ExchangeRateResponse struct {
	// Rates contains a set of exchange rates for the set of timestamps
	Rates                []*ExchangeRate `protobuf:"bytes,2,rep,name=rates,proto3" json:"rates,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

type FaradayServerClient interface {
	//* frcli: `outliers`
	//Get close recommendations for currently open channels based on whether it is
	//an outlier.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/outliers/REVENUE?rec_request.minimum_monitored=123
	OutlierRecommendations(ctx context.Context, in *OutlierRecommendationsRequest, opts ...grpc.CallOption) (*CloseRecommendationsResponse, error)
	//* frcli: `threshold`
	//Get close recommendations for currently open channels based whether they are
	//below a set threshold.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/threshold/UPTIME?rec_request.minimum_monitored=123
	ThresholdRecommendations(ctx context.Context, in *ThresholdRecommendationsRequest, opts ...grpc.CallOption) (*CloseRecommendationsResponse, error)
	//* frcli: `revenue`
	//Get a pairwise revenue report for a channel.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/revenue
	RevenueReport(ctx context.Context, in *RevenueReportRequest, opts ...grpc.CallOption) (*RevenueReportResponse, error)
	//* frcli: `insights`
	//List currently open channel with routing and uptime information.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/insights
	ChannelInsights(ctx context.Context, in *ChannelInsightsRequest, opts ...grpc.CallOption) (*ChannelInsightsResponse, error)
	//* frcli:
	//Get fiat prices for btc.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/exchangerate
	ExchangeRate(ctx context.Context, in *ExchangeRateRequest, opts ...grpc.CallOption) (*ExchangeRateResponse, error)
	//*
	//Get a report of your node's activity over a period.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/nodeaudit
	NodeAudit(ctx context.Context, in *NodeAuditRequest, opts ...grpc.CallOption) (*NodeAuditResponse, error)
	//*
	//Get a channel close report for a specific channel.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/closereport
	CloseReport(ctx context.Context, in *CloseReportRequest, opts ...grpc.CallOption) (*CloseReportResponse, error)
}

type FaradayServerServer interface {
	//* frcli: `outliers`
	//Get close recommendations for currently open channels based on whether it is
	//an outlier.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/outliers/REVENUE?rec_request.minimum_monitored=123
	OutlierRecommendations(context.Context, *OutlierRecommendationsRequest) (*CloseRecommendationsResponse, error)
	//* frcli: `threshold`
	//Get close recommendations for currently open channels based whether they are
	//below a set threshold.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/threshold/UPTIME?rec_request.minimum_monitored=123
	ThresholdRecommendations(context.Context, *ThresholdRecommendationsRequest) (*CloseRecommendationsResponse, error)
	//* frcli: `revenue`
	//Get a pairwise revenue report for a channel.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/revenue
	RevenueReport(context.Context, *RevenueReportRequest) (*RevenueReportResponse, error)
	//* frcli: `insights`
	//List currently open channel with routing and uptime information.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/insights
	ChannelInsights(context.Context, *ChannelInsightsRequest) (*ChannelInsightsResponse, error)
	//* frcli:
	//Get fiat prices for btc.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/exchangerate
	ExchangeRate(context.Context, *ExchangeRateRequest) (*ExchangeRateResponse, error)
	//*
	//Get a report of your node's activity over a period.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/nodeaudit
	NodeAudit(context.Context, *NodeAuditRequest) (*NodeAuditResponse, error)
	//*
	//Get a channel close report for a specific channel.
	//
	//Example request:
	//http://localhost:8466/v1/faraday/closereport
	CloseReport(context.Context, *CloseReportRequest) (*CloseReportResponse, error)
}

type Granularity int32

type NodeAuditRequest struct {
	// The unix time from which to produce the report, inclusive.
	StartTime uint64 `protobuf:"varint,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// The unix time until which to produce the report, exclusive.
	EndTime uint64 `protobuf:"varint,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	//
	//Set to generate a report without conversion to fiat. If set, fiat values
	//will display as 0.
	DisableFiat bool `protobuf:"varint,4,opt,name=disable_fiat,json=disableFiat,proto3" json:"disable_fiat,omitempty"`
	// The level of granularity at which we wish to produce fiat prices.
	Granularity          Granularity `protobuf:"varint,5,opt,name=granularity,proto3,enum=frdrpc.Granularity" json:"granularity,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

type NodeAuditResponse struct {
	// On chain reports for the period queried.
	Reports              []*ReportEntry `protobuf:"bytes,1,rep,name=reports,proto3" json:"reports,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

type OutlierRecommendationsRequest struct {
	//
	//The parameters that are common to all close recommendations.
	RecRequest *CloseRecommendationRequest `protobuf:"bytes,1,opt,name=rec_request,json=recRequest,proto3" json:"rec_request,omitempty"`
	//
	//The number of inter-quartile ranges a value needs to be beneath the lower
	//quartile/ above the upper quartile to be considered a lower/upper outlier.
	//Lower values will be more aggressive in recommending channel closes, and
	//upper values will be more conservative. Recommended values are 1.5 for
	//aggressive recommendations and 3 for conservative recommendations.
	OutlierMultiplier    float32  `protobuf:"fixed32,2,opt,name=outlier_multiplier,json=outlierMultiplier,proto3" json:"outlier_multiplier,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type PairReport struct {
	//
	//Amount outgoing msat is the amount in millisatoshis that arrived
	//on the pair channel to be forwarded onwards by our channel.
	AmountOutgoingMsat int64 `protobuf:"varint,1,opt,name=amount_outgoing_msat,json=amountOutgoingMsat,proto3" json:"amount_outgoing_msat,omitempty"`
	//
	//Fees outgoing is the amount of fees in millisatoshis that we
	//attribute to the channel for its role as the outgoing channel in
	//forwards.
	FeesOutgoingMsat int64 `protobuf:"varint,2,opt,name=fees_outgoing_msat,json=feesOutgoingMsat,proto3" json:"fees_outgoing_msat,omitempty"`
	//
	//Amount incoming msat is the amount in millisatoshis that arrived
	//on our channel to be forwarded onwards by the pair channel.
	AmountIncomingMsat int64 `protobuf:"varint,3,opt,name=amount_incoming_msat,json=amountIncomingMsat,proto3" json:"amount_incoming_msat,omitempty"`
	//
	//Fees incoming is the amount of fees in millisatoshis that we
	//attribute to the channel for its role as the incoming channel in
	//forwards.
	FeesIncomingMsat     int64    `protobuf:"varint,4,opt,name=fees_incoming_msat,json=feesIncomingMsat,proto3" json:"fees_incoming_msat,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type RPCServer struct {
	// contains filtered or unexported fields
}

type Recommendation struct {
	//
	//The channel point [funding txid: outpoint] of the channel being considered
	//for close.
	ChanPoint string `protobuf:"bytes,1,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"`
	// The value of the metric that close recommendations were based on.
	Value float32 `protobuf:"fixed32,2,opt,name=value,proto3" json:"value,omitempty"`
	// A boolean indicating whether we recommend closing the channel.
	RecommendClose       bool     `protobuf:"varint,3,opt,name=recommend_close,json=recommendClose,proto3" json:"recommend_close,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ReportEntry struct {
	// The unix timestamp of the event.
	Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Whether the entry occurred on chain or off chain.
	OnChain bool `protobuf:"varint,2,opt,name=on_chain,json=onChain,proto3" json:"on_chain,omitempty"`
	// The amount of the entry, expressed in millisatoshis.
	Amount uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// Whether the entry is a credit or a debit.
	Credit bool `protobuf:"varint,4,opt,name=credit,proto3" json:"credit,omitempty"`
	// The asset affected by the entry.
	Asset string `protobuf:"bytes,5,opt,name=asset,proto3" json:"asset,omitempty"`
	// The kind of activity that this entry represents.
	Type EntryType `protobuf:"varint,6,opt,name=type,proto3,enum=frdrpc.EntryType" json:"type,omitempty"`
	// The transaction id of the entry.
	Txid string `protobuf:"bytes,7,opt,name=txid,proto3" json:"txid,omitempty"`
	// The fiat amount of the entry's amount in USD.
	Fiat string `protobuf:"bytes,8,opt,name=fiat,proto3" json:"fiat,omitempty"`
	// A unique identifier for the entry, if available.
	Reference string `protobuf:"bytes,9,opt,name=reference,proto3" json:"reference,omitempty"`
	// An additional note for the entry, providing additional context.
	Note string `protobuf:"bytes,10,opt,name=note,proto3" json:"note,omitempty"`
	// The bitcoin price and timestamp used to calcualte our fiat value.
	BtcPrice             *BitcoinPrice `protobuf:"bytes,11,opt,name=btc_price,json=btcPrice,proto3" json:"btc_price,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

type RevenueReport struct {
	//
	//Target channel is the channel that the report is generated for; incoming
	//fields in the report mean that this channel was the incoming channel,
	//and the pair as the outgoing, outgoing fields mean that this channel was
	//the outgoing channel and the peer was the incoming channel.
	TargetChannel string `protobuf:"bytes,1,opt,name=target_channel,json=targetChannel,proto3" json:"target_channel,omitempty"`
	//
	//Pair reports maps the channel point of a peer that we generated revenue
	//with to a report detailing the revenue.
	PairReports          map[string]*PairReport `` /* 182-byte string literal not displayed */
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

type RevenueReportRequest struct {
	//
	//The funding transaction outpoints for the channels to generate a revenue
	//report for. If this is empty, it will be generated for all open and closed
	//channels. Channel funding points should be expressed with the format
	//fundingTxID:outpoint.
	ChanPoints []string `protobuf:"bytes,1,rep,name=chan_points,json=chanPoints,proto3" json:"chan_points,omitempty"`
	//
	//Start time is beginning of the range over which the report will be
	//generated, expressed as unix epoch offset in seconds.
	StartTime uint64 `protobuf:"varint,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	//
	//End time is end of the range over which the report will be
	//generated, expressed as unix epoch offset in seconds.
	EndTime              uint64   `protobuf:"varint,3,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type RevenueReportResponse struct {
	//
	//Reports is a set of pairwise revenue report generated for the channel(s)
	//over the period specified.
	Reports              []*RevenueReport `protobuf:"bytes,1,rep,name=reports,proto3" json:"reports,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

type ThresholdRecommendationsRequest struct {
	//
	//The parameters that are common to all close recommendations.
	RecRequest *CloseRecommendationRequest `protobuf:"bytes,1,opt,name=rec_request,json=recRequest,proto3" json:"rec_request,omitempty"`
	//
	//The threshold that recommendations will be calculated based on.
	//For uptime: ratio of uptime to observed lifetime beneath which channels
	//will be recommended for closure.
	//
	//For revenue: revenue per block that capital has been committed to the
	//channel beneath which channels will be recommended for closure. This
	//value is provided per block so that channels that have been open for
	//different periods of time can be compared.
	//
	//For incoming volume: The incoming volume per block that capital has
	//been committed to the channel beneath which channels will be recommended
	//for closure. This value is provided per block so that channels that have
	//been open for different periods of time can be compared.
	//
	//For outgoing volume: The outgoing volume per block that capital has been
	//committed to the channel beneath which channels will be recommended for
	//closure. This value is provided per block so that channels that have been
	//open for different periods of time can be compared.
	//
	//For total volume: The total volume per block that capital has been
	//committed to the channel beneath which channels will be recommended for
	//closure. This value is provided per block so that channels that have been
	//open for different periods of time can be compared.
	ThresholdValue       float32  `protobuf:"fixed32,2,opt,name=threshold_value,json=thresholdValue,proto3" json:"threshold_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type UnimplementedFaradayServerServer struct {
}