Archives
/
loop
mirror of https://github.com/lightninglabs/loop
2
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #331 from carlaKC/autoloop-0-refactoring

Browse Source 
autoloop: refactoring to prepare for loopin
pull/334/head
Carla Kirk-Cohen 3 years ago committed by GitHub
parent d85cc010b0 68a5336362
commit 9af61481ea
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 290 additions and 259 deletions
Show Stats Download Patch File Download Diff File

14
cmd/loop/liquidity.go
Unescape Escape View File

@ -225,10 +225,10 @@ var setParamsCommand = cli.Command{
"included in suggestions.",
},
cli.BoolFlag{
Name: "autoout",
Name: "autoloop",
Usage: "set to true to enable automated dispatch " +
"of loop out swaps, limited to the budget " +
"set by autobudget",
"of swaps, limited to the budget set by " +
"autobudget",
},
cli.Uint64Flag{
Name: "autobudget",
@ -338,18 +338,18 @@ func setParams(ctx *cli.Context) error {
flagSet = true
}
if ctx.IsSet("autoout") {
params.AutoLoopOut = ctx.Bool("autoout")
if ctx.IsSet("autoloop") {
params.Autoloop = ctx.Bool("autoloop")
flagSet = true
}
if ctx.IsSet("autobudget") {
params.AutoOutBudgetSat = ctx.Uint64("autobudget")
params.AutoloopBudgetSat = ctx.Uint64("autobudget")
flagSet = true
}
if ctx.IsSet("budgetstart") {
params.AutoOutBudgetStartSec = ctx.Uint64("budgetstart")
params.AutoloopBudgetStartSec = ctx.Uint64("budgetstart")
flagSet = true
}

2
docs/autoloop.md
Unescape Escape View File

@ -6,7 +6,7 @@ budget of your choosing.
The autoloop functionality is disabled by default, and can be enabled using the
following command:
```
loop setparams --autoout=true
loop setparams --autoloop=true
```
Swaps that are dispatched by the autolooper can be identified in the output of

18
labels/labels.go
Unescape Escape View File

@ -4,6 +4,8 @@ import (
"errors"
"fmt"
"strings"
"github.com/lightninglabs/loop/swap"
)
const (
@ -17,6 +19,10 @@ const (
// autoOut is the label used for loop out swaps that are automatically
// dispatched.
autoOut = "autoloop-out"
// autoIn is the label used for loop in swaps that are automatically
// dispatched.
autoIn = "autoloop-in"
)
var (
@ -28,10 +34,14 @@ var (
ErrReservedPrefix = errors.New("label contains reserved prefix")
)
// AutoOutLabel returns a label with the reserved prefix that identifies
// automatically dispatched loop outs.
func AutoOutLabel() string {
return fmt.Sprintf("%v: %v", Reserved, autoOut)
// AutoloopLabel returns a label with the reserved prefix that identifies
// automatically dispatched swaps depending on the type of swap being executed.
func AutoloopLabel(swapType swap.Type) string {
if swapType == swap.TypeOut {
return fmt.Sprintf("%v: %v", Reserved, autoOut)
}
return fmt.Sprintf("%v: %v", Reserved, autoIn)
}
// Validate checks that a label is of appropriate length and is not in our list

7
liquidity/autoloop_test.go
Unescape Escape View File

@ -8,6 +8,7 @@ import (
"github.com/lightninglabs/loop"
"github.com/lightninglabs/loop/labels"
"github.com/lightninglabs/loop/loopdb"
"github.com/lightninglabs/loop/swap"
"github.com/lightninglabs/loop/test"
"github.com/lightningnetwork/lnd/lntypes"
"github.com/lightningnetwork/lnd/lnwire"
@ -75,7 +76,7 @@ func TestAutoLoopEnabled(t *testing.T) {
// is set to allow exactly 2 swaps at the prices that we set in our
// test quotes.
params := Parameters{
AutoOut: true,
Autoloop: true,
AutoFeeBudget: 40066,
AutoFeeStartDate: testTime,
MaxAutoInFlight: 2,
@ -145,7 +146,7 @@ func TestAutoLoopEnabled(t *testing.T) {
MaxMinerFee: params.MaximumMinerFee,
SweepConfTarget: params.SweepConfTarget,
OutgoingChanSet: loopdb.ChannelSet{chanID1.ToUint64()},
Label: labels.AutoOutLabel(),
Label: labels.AutoloopLabel(swap.TypeOut),
Initiator: autoloopSwapInitiator,
}
@ -161,7 +162,7 @@ func TestAutoLoopEnabled(t *testing.T) {
MaxMinerFee: params.MaximumMinerFee,
SweepConfTarget: params.SweepConfTarget,
OutgoingChanSet: loopdb.ChannelSet{chanID2.ToUint64()},
Label: labels.AutoOutLabel(),
Label: labels.AutoloopLabel(swap.TypeOut),
Initiator: autoloopSwapInitiator,
}

9
liquidity/autoloop_testcontext_test.go
Unescape Escape View File

@ -8,6 +8,7 @@ import (
"github.com/lightninglabs/lndclient"
"github.com/lightninglabs/loop"
"github.com/lightninglabs/loop/loopdb"
"github.com/lightninglabs/loop/swap"
"github.com/lightninglabs/loop/test"
"github.com/lightningnetwork/lnd/clock"
"github.com/lightningnetwork/lnd/ticker"
@ -91,8 +92,10 @@ func newAutoloopTestCtx(t *testing.T, parameters Parameters,
testCtx.lnd.Channels = channels
cfg := &Config{
AutoOutTicker: ticker.NewForce(DefaultAutoOutTicker),
LoopOutRestrictions: func(context.Context) (*Restrictions, error) {
AutoloopTicker: ticker.NewForce(DefaultAutoloopTicker),
Restrictions: func(context.Context, swap.Type) (*Restrictions,
error) {
return <-testCtx.loopOutRestrictions, nil
},
ListLoopOut: func() ([]*loopdb.LoopOut, error) {
@ -182,7 +185,7 @@ func (c *autoloopTestCtx) autoloop(minAmt, maxAmt btcutil.Amount,
expectedSwaps []loopOutRequestResp) {
// Tick our autoloop ticker to force assessing whether we want to loop.
c.manager.cfg.AutoOutTicker.Force <- testTime
c.manager.cfg.AutoloopTicker.Force <- testTime
// Send a mocked response from the server with the swap size limits.
c.loopOutRestrictions <- NewRestrictions(minAmt, maxAmt)

89
liquidity/liquidity.go
Unescape Escape View File

@ -46,6 +46,7 @@ import (
"github.com/lightninglabs/loop"
"github.com/lightninglabs/loop/labels"
"github.com/lightninglabs/loop/loopdb"
"github.com/lightninglabs/loop/swap"
"github.com/lightningnetwork/lnd/clock"
"github.com/lightningnetwork/lnd/funding"
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
@ -96,9 +97,9 @@ const (
// suggestions as a dry-run).
defaultMaxInFlight = 1
// DefaultAutoOutTicker is the default amount of time between automated
// loop out checks.
DefaultAutoOutTicker = time.Minute * 10
// DefaultAutoloopTicker is the default amount of time between automated
// swap checks.
DefaultAutoloopTicker = time.Minute * 10
// autoloopSwapInitiator is the value we send in the initiator field of
// a swap request when issuing an automatic swap.
@ -182,14 +183,15 @@ var (
// Config contains the external functionality required to run the
// liquidity manager.
type Config struct {
// AutoOutTicker determines how often we should check whether we want
// to dispatch an automated loop out. We use a force ticker so that
// we can trigger autoloop in itests.
AutoOutTicker *ticker.Force
// AutoloopTicker determines how often we should check whether we want
// to dispatch an automated swap. We use a force ticker so that we can
// trigger autoloop in itests.
AutoloopTicker *ticker.Force
// LoopOutRestrictions returns the restrictions that the server applies
// to loop out swaps.
LoopOutRestrictions func(ctx context.Context) (*Restrictions, error)
// Restrictions returns the restrictions that the server applies to
// swaps.
Restrictions func(ctx context.Context, swapType swap.Type) (
*Restrictions, error)
// Lnd provides us with access to lnd's rpc servers.
Lnd *lndclient.LndServices
@ -220,8 +222,8 @@ type Config struct {
// Parameters is a set of parameters provided by the user which guide
// how we assess liquidity.
type Parameters struct {
// AutoOut enables automatic dispatch of loop out swaps.
AutoOut bool
// Autoloop enables automatic dispatch of swaps.
Autoloop bool
// AutoFeeBudget is the total amount we allow to be spent on
// automatically dispatched swaps. Once this budget has been used, we
@ -431,12 +433,12 @@ type Manager struct {
// We run this loop even if automated swaps are not currently enabled rather
// than managing starting and stopping the ticker as our parameters are updated.
func (m *Manager) Run(ctx context.Context) error {
m.cfg.AutoOutTicker.Resume()
defer m.cfg.AutoOutTicker.Stop()
m.cfg.AutoloopTicker.Resume()
defer m.cfg.AutoloopTicker.Stop()
for {
select {
case <-m.cfg.AutoOutTicker.Ticks():
case <-m.cfg.AutoloopTicker.Ticks():
if err := m.autoloop(ctx); err != nil {
log.Errorf("autoloop failed: %v", err)
}
@ -466,7 +468,7 @@ func (m *Manager) GetParameters() Parameters {
// SetParameters updates our current set of parameters if the new parameters
// provided are valid.
func (m *Manager) SetParameters(ctx context.Context, params Parameters) error {
restrictions, err := m.cfg.LoopOutRestrictions(ctx)
restrictions, err := m.cfg.Restrictions(ctx, swap.TypeOut)
if err != nil {
return err
}
@ -510,6 +512,15 @@ func (m *Manager) autoloop(ctx context.Context) error {
}
for _, swap := range swaps {
// If we don't actually have dispatch of swaps enabled, log
// suggestions.
if !m.params.Autoloop {
log.Debugf("recommended autoloop: %v sats over "+
"%v", swap.Amount, swap.OutgoingChanSet)
continue
}
// Create a copy of our range var so that we can reference it.
swap := swap
loopOut, err := m.cfg.LoopOut(ctx, &swap)
@ -528,7 +539,7 @@ func (m *Manager) autoloop(ctx context.Context) error {
// ForceAutoLoop force-ticks our auto-out ticker.
func (m *Manager) ForceAutoLoop(ctx context.Context) error {
select {
case m.cfg.AutoOutTicker.Force <- m.cfg.Clock.Now():
case m.cfg.AutoloopTicker.Force <- m.cfg.Clock.Now():
return nil
case <-ctx.Done():
@ -538,11 +549,11 @@ func (m *Manager) ForceAutoLoop(ctx context.Context) error {
// SuggestSwaps returns a set of swap suggestions based on our current liquidity
// balance for the set of rules configured for the manager, failing if there are
// no rules set. It takes an autoOut boolean that indicates whether the
// no rules set. It takes an autoloop boolean that indicates whether the
// suggestions are being used for our internal autolooper. This boolean is used
// to determine the information we add to our swap suggestion and whether we
// return any suggestions.
func (m *Manager) SuggestSwaps(ctx context.Context, autoOut bool) (
func (m *Manager) SuggestSwaps(ctx context.Context, autoloop bool) (
[]loop.OutRequest, error) {
m.paramsLock.Lock()
@ -587,7 +598,7 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoOut bool) (
// Get the current server side restrictions, combined with the client
// set restrictions, if any.
outRestrictions, err := m.getLoopOutRestrictions(ctx)
restrictions, err := m.getSwapRestrictions(ctx, swap.TypeOut)
if err != nil {
return nil, err
}
@ -646,7 +657,7 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoOut bool) (
balance := newBalances(channel)
suggestion := rule.suggestSwap(balance, outRestrictions)
suggestion := rule.suggestSwap(balance, restrictions)
// We can have nil suggestions in the case where no action is
// required, so we skip over them.
@ -681,7 +692,7 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoOut bool) (
}
outRequest, err := m.makeLoopOutRequest(
ctx, suggestion, quote, autoOut,
ctx, suggestion, quote, autoloop,
)
if err != nil {
return nil, err
@ -728,29 +739,17 @@ func (m *Manager) SuggestSwaps(ctx context.Context, autoOut bool) (
}
}
// If we are getting suggestions for automatically dispatched swaps,
// and they are not enabled in our parameters, we just log the swap
// suggestions and return an empty set of suggestions.
if autoOut && !m.params.AutoOut {
for _, swap := range inBudget {
log.Debugf("recommended autoloop: %v sats over "+
"%v", swap.Amount, swap.OutgoingChanSet)
}
return nil, nil
}
return inBudget, nil
}
// getLoopOutRestrictions queries the server for its latest swap size
// restrictions, validates client restrictions (if present) against these
// values and merges the client's custom requirements with the server's limits
// to produce a single set of limitations for our swap.
func (m *Manager) getLoopOutRestrictions(ctx context.Context) (*Restrictions,
error) {
// getSwapRestrictions queries the server for its latest swap size restrictions,
// validates client restrictions (if present) against these values and merges
// the client's custom requirements with the server's limits to produce a single
// set of limitations for our swap.
func (m *Manager) getSwapRestrictions(ctx context.Context, swapType swap.Type) (
*Restrictions, error) {
restrictions, err := m.cfg.LoopOutRestrictions(ctx)
restrictions, err := m.cfg.Restrictions(ctx, swapType)
if err != nil {
return nil, err
}
@ -791,7 +790,7 @@ func (m *Manager) getLoopOutRestrictions(ctx context.Context) (*Restrictions,
// non-auto requests, because the client api will set it anyway).
func (m *Manager) makeLoopOutRequest(ctx context.Context,
suggestion *LoopOutRecommendation, quote *loop.LoopOutQuote,
autoOut bool) (loop.OutRequest, error) {
autoloop bool) (loop.OutRequest, error) {
prepayMaxFee := ppmToSat(
quote.PrepayAmount, m.params.MaximumPrepayRoutingFeePPM,
@ -815,8 +814,8 @@ func (m *Manager) makeLoopOutRequest(ctx context.Context,
Initiator: autoloopSwapInitiator,
}
if autoOut {
request.Label = labels.AutoOutLabel()
if autoloop {
request.Label = labels.AutoloopLabel(swap.TypeOut)
addr, err := m.cfg.Lnd.WalletKit.NextAddr(ctx)
if err != nil {
@ -882,7 +881,7 @@ func (m *Manager) checkExistingAutoLoops(ctx context.Context,
var summary existingAutoLoopSummary
for _, out := range loopOuts {
if out.Contract.Label != labels.AutoOutLabel() {
if out.Contract.Label != labels.AutoloopLabel(swap.TypeOut) {
continue
}

15
liquidity/liquidity_test.go
Unescape Escape View File

@ -10,6 +10,7 @@ import (
"github.com/lightninglabs/loop"
"github.com/lightninglabs/loop/labels"
"github.com/lightninglabs/loop/loopdb"
"github.com/lightninglabs/loop/swap"
"github.com/lightninglabs/loop/test"
"github.com/lightningnetwork/lnd/clock"
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
@ -99,7 +100,7 @@ var (
// and restricted to a channel that we do not use in our tests.
autoOutContract = &loopdb.LoopOutContract{
SwapContract: loopdb.SwapContract{
Label: labels.AutoOutLabel(),
Label: labels.AutoloopLabel(swap.TypeOut),
InitiationTime: testBudgetStart,
},
OutgoingChanSet: loopdb.ChannelSet{999},
@ -120,7 +121,7 @@ func newTestConfig() (*Config, *test.LndMockServices) {
)
return &Config{
LoopOutRestrictions: func(_ context.Context) (*Restrictions,
Restrictions: func(_ context.Context, _ swap.Type) (*Restrictions,
error) {
return testRestrictions, nil
@ -867,7 +868,7 @@ func TestSizeRestrictions(t *testing.T) {
Maximum: 10000,
}
swap = loop.OutRequest{
outSwap = loop.OutRequest{
OutgoingChanSet: loopdb.ChannelSet{chanID1.ToUint64()},
MaxPrepayRoutingFee: prepayFee,
MaxMinerFee: defaultMaximumMinerFee,
@ -966,7 +967,7 @@ func TestSizeRestrictions(t *testing.T) {
// our restrictions endpoint.
var callCount int
cfg.LoopOutRestrictions = func(_ context.Context) (
cfg.Restrictions = func(_ context.Context, _ swap.Type) (
*Restrictions, error) {
restrictions := testCase.serverRestrictions[callCount]
@ -980,14 +981,14 @@ func TestSizeRestrictions(t *testing.T) {
// and fee accordingly.
var expectedSwaps []loop.OutRequest
if testCase.expectedAmount != 0 {
swap.Amount = testCase.expectedAmount
outSwap.Amount = testCase.expectedAmount
swap.MaxSwapRoutingFee = ppmToSat(
outSwap.MaxSwapRoutingFee = ppmToSat(
testCase.expectedAmount,
defaultRoutingFeePPM,
)
expectedSwaps = append(expectedSwaps, swap)
expectedSwaps = append(expectedSwaps, outSwap)
}
testSuggestSwaps(

14
loopd/swapclient_server.go
Unescape Escape View File

@ -581,8 +581,8 @@ func (s *swapClientServer) GetLiquidityParams(_ context.Context,
SweepFeeRateSatPerVbyte: uint64(satPerByte),
SweepConfTarget: cfg.SweepConfTarget,
FailureBackoffSec: uint64(cfg.FailureBackOff.Seconds()),
AutoLoopOut: cfg.AutoOut,
AutoOutBudgetSat: uint64(cfg.AutoFeeBudget),
Autoloop: cfg.Autoloop,
AutoloopBudgetSat: uint64(cfg.AutoFeeBudget),
AutoMaxInFlight: uint64(cfg.MaxAutoInFlight),
Rules: make(
[]*looprpc.LiquidityRule, 0, len(cfg.ChannelRules),
@ -594,7 +594,7 @@ func (s *swapClientServer) GetLiquidityParams(_ context.Context,
// Zero golang time is different to a zero unix time, so we only set
// our start date if it is non-zero.
if !cfg.AutoFeeStartDate.IsZero() {
rpcCfg.AutoOutBudgetStartSec = uint64(
rpcCfg.AutoloopBudgetStartSec = uint64(
cfg.AutoFeeStartDate.Unix(),
)
}
@ -633,8 +633,8 @@ func (s *swapClientServer) SetLiquidityParams(ctx context.Context,
SweepConfTarget: in.Parameters.SweepConfTarget,
FailureBackOff: time.Duration(in.Parameters.FailureBackoffSec) *
time.Second,
AutoOut: in.Parameters.AutoLoopOut,
AutoFeeBudget: btcutil.Amount(in.Parameters.AutoOutBudgetSat),
Autoloop: in.Parameters.Autoloop,
AutoFeeBudget: btcutil.Amount(in.Parameters.AutoloopBudgetSat),
MaxAutoInFlight: int(in.Parameters.AutoMaxInFlight),
ChannelRules: make(
map[lnwire.ShortChannelID]*liquidity.ThresholdRule,
@ -647,9 +647,9 @@ func (s *swapClientServer) SetLiquidityParams(ctx context.Context,
}
// Zero unix time is different to zero golang time.
if in.Parameters.AutoOutBudgetStartSec != 0 {
if in.Parameters.AutoloopBudgetStartSec != 0 {
params.AutoFeeStartDate = time.Unix(
int64(in.Parameters.AutoOutBudgetStartSec), 0,
int64(in.Parameters.AutoloopBudgetStartSec), 0,
)
}

24
loopd/utils.go
Unescape Escape View File

@ -7,6 +7,7 @@ import (
"github.com/lightninglabs/lndclient"
"github.com/lightninglabs/loop"
"github.com/lightninglabs/loop/liquidity"
"github.com/lightninglabs/loop/swap"
"github.com/lightningnetwork/lnd/clock"
"github.com/lightningnetwork/lnd/ticker"
)
@ -36,18 +37,29 @@ func getClient(config *Config, lnd *lndclient.LndServices) (*loop.Client,
func getLiquidityManager(client *loop.Client) *liquidity.Manager {
mngrCfg := &liquidity.Config{
AutoOutTicker: ticker.NewForce(liquidity.DefaultAutoOutTicker),
LoopOut: client.LoopOut,
LoopOutRestrictions: func(ctx context.Context) (
*liquidity.Restrictions, error) {
AutoloopTicker: ticker.NewForce(liquidity.DefaultAutoloopTicker),
LoopOut: client.LoopOut,
Restrictions: func(ctx context.Context,
swapType swap.Type) (*liquidity.Restrictions, error) {
outTerms, err := client.Server.GetLoopOutTerms(ctx)
if swapType == swap.TypeOut {
outTerms, err := client.Server.GetLoopOutTerms(ctx)
if err != nil {
return nil, err
}
return liquidity.NewRestrictions(
outTerms.MinSwapAmount, outTerms.MaxSwapAmount,
), nil
}
inTerms, err := client.Server.GetLoopInTerms(ctx)
if err != nil {
return nil, err
}
return liquidity.NewRestrictions(
outTerms.MinSwapAmount, outTerms.MaxSwapAmount,
inTerms.MinSwapAmount, inTerms.MaxSwapAmount,
), nil
},
Lnd: client.LndServices,

328
looprpc/client.pb.go
Unescape Escape View File

@ -1609,20 +1609,20 @@ type LiquidityParameters struct {
//suggestions again, expressed in seconds.
FailureBackoffSec uint64 `protobuf:"varint,9,opt,name=failure_backoff_sec,json=failureBackoffSec,proto3" json:"failure_backoff_sec,omitempty"`
//
//Set to true to enable automatic dispatch of loop out swaps. All swaps will
//be limited to the fee categories set by these parameters, and total
//expenditure will be limited to the auto out budget.
AutoLoopOut bool `protobuf:"varint,10,opt,name=auto_loop_out,json=autoLoopOut,proto3" json:"auto_loop_out,omitempty"`
//Set to true to enable automatic dispatch of swaps. All swaps will be limited
//to the fee categories set by these parameters, and total expenditure will
//be limited to the autoloop budget.
Autoloop bool `protobuf:"varint,10,opt,name=autoloop,proto3" json:"autoloop,omitempty"`
//
//The total budget for automatically dispatched swaps since the budget start
//time, expressed in satoshis.
AutoOutBudgetSat uint64 `protobuf:"varint,11,opt,name=auto_out_budget_sat,json=autoOutBudgetSat,proto3" json:"auto_out_budget_sat,omitempty"`
AutoloopBudgetSat uint64 `protobuf:"varint,11,opt,name=autoloop_budget_sat,json=autoloopBudgetSat,proto3" json:"autoloop_budget_sat,omitempty"`
//
//The start time for auto-out budget, expressed as a unix timestamp in
//The start time for autoloop budget, expressed as a unix timestamp in
//seconds. If this value is 0, the budget will be applied for all
//automatically dispatched swaps. Swaps that were completed before this date
//will not be included in budget calculations.
AutoOutBudgetStartSec uint64 `protobuf:"varint,12,opt,name=auto_out_budget_start_sec,json=autoOutBudgetStartSec,proto3" json:"auto_out_budget_start_sec,omitempty"`
AutoloopBudgetStartSec uint64 `protobuf:"varint,12,opt,name=autoloop_budget_start_sec,json=autoloopBudgetStartSec,proto3" json:"autoloop_budget_start_sec,omitempty"`
//
//The maximum number of automatically dispatched swaps that we allow to be in
//flight at any point in time.
@ -1730,23 +1730,23 @@ func (m *LiquidityParameters) GetFailureBackoffSec() uint64 {
return 0
}
func (m *LiquidityParameters) GetAutoLoopOut() bool {
func (m *LiquidityParameters) GetAutoloop() bool {
if m != nil {
return m.AutoLoopOut
return m.Autoloop
}
return false
}
func (m *LiquidityParameters) GetAutoOutBudgetSat() uint64 {
func (m *LiquidityParameters) GetAutoloopBudgetSat() uint64 {
if m != nil {
return m.AutoOutBudgetSat
return m.AutoloopBudgetSat
}
return 0
}
func (m *LiquidityParameters) GetAutoOutBudgetStartSec() uint64 {
func (m *LiquidityParameters) GetAutoloopBudgetStartSec() uint64 {
if m != nil {
return m.AutoOutBudgetStartSec
return m.AutoloopBudgetStartSec
}
return 0
}
@ -2029,157 +2029,157 @@ func init() {
func init() { proto.RegisterFile("client.proto", fileDescriptor_014de31d7ac8c57c) }
var fileDescriptor_014de31d7ac8c57c = []byte{
// 2396 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0x4b, 0x6f, 0x23, 0xc7,
0x11, 0x5e, 0xbe, 0x44, 0xb2, 0xf8, 0x1a, 0xb5, 0x76, 0x57, 0x14, 0x2d, 0xc3, 0xda, 0xb1, 0x37,
0x96, 0x65, 0x7b, 0x19, 0xcb, 0x97, 0xc4, 0xb0, 0x03, 0x68, 0x29, 0xca, 0xe2, 0x46, 0x22, 0x99,
0x21, 0xb5, 0x86, 0x83, 0x00, 0x83, 0x16, 0xd9, 0x92, 0x06, 0xe6, 0x3c, 0x3c, 0xd3, 0xdc, 0xd5,
0xc2, 0x48, 0x02, 0x04, 0xc8, 0x39, 0x87, 0xfc, 0x83, 0xdc, 0x73, 0xcb, 0x2d, 0xf9, 0x09, 0xc9,
0x25, 0x39, 0xe6, 0x9a, 0x4b, 0x0e, 0xf9, 0x0f, 0x41, 0x55, 0xcf, 0x0c, 0x67, 0x28, 0x52, 0x46,
0x0e, 0xb9, 0x71, 0xaa, 0xbe, 0xae, 0xae, 0xae, 0x77, 0x11, 0xaa, 0x93, 0x99, 0x25, 0x1c, 0xf9,
0xcc, 0xf3, 0x5d, 0xe9, 0xb2, 0xe2, 0xcc, 0x75, 0x3d, 0xdf, 0x9b, 0xb4, 0x76, 0xaf, 0x5d, 0xf7,
0x7a, 0x26, 0xda, 0xdc, 0xb3, 0xda, 0xdc, 0x71, 0x5c, 0xc9, 0xa5, 0xe5, 0x3a, 0x81, 0x82, 0xe9,
0x7f, 0xcc, 0x43, 0xfd, 0xcc, 0x75, 0xbd, 0xc1, 0x5c, 0x1a, 0xe2, 0xdb, 0xb9, 0x08, 0x24, 0xd3,
0x20, 0xc7, 0x6d, 0xd9, 0xcc, 0xec, 0x65, 0xf6, 0x73, 0x06, 0xfe, 0x64, 0x0c, 0xf2, 0x53, 0x11,
0xc8, 0x66, 0x76, 0x2f, 0xb3, 0x5f, 0x36, 0xe8, 0x37, 0x6b, 0xc3, 0x43, 0x9b, 0xdf, 0x9a, 0xc1,
0x6b, 0xee, 0x99, 0xbe, 0x3b, 0x97, 0x96, 0x73, 0x6d, 0x5e, 0x09, 0xd1, 0xcc, 0xd1, 0xb1, 0x4d,
0x9b, 0xdf, 0x8e, 0x5e, 0x73, 0xcf, 0x50, 0x9c, 0x13, 0x21, 0xd8, 0xa7, 0xf0, 0x18, 0x0f, 0x78,
0xbe, 0xf0, 0xf8, 0x9b, 0xd4, 0x91, 0x3c, 0x1d, 0xd9, 0xb2, 0xf9, 0xed, 0x90, 0x98, 0x89, 0x43,
0x7b, 0x50, 0x8d, 0x6f, 0x41, 0x68, 0x81, 0xa0, 0x10, 0x4a, 0x47, 0xc4, 0x7b, 0x50, 0x4f, 0x88,
0x45, 0xc5, 0x37, 0x08, 0x53, 0x8d, 0xc5, 0x1d, 0xd9, 0x92, 0xe9, 0x50, 0x43, 0x94, 0x6d, 0x39,
0xc2, 0x27, 0x41, 0x45, 0x02, 0x55, 0x6c, 0x7e, 0x7b, 0x8e, 0x34, 0x94, 0xf4, 0x11, 0x68, 0x68,
0x33, 0xd3, 0x9d, 0x4b, 0x73, 0x72, 0xc3, 0x1d, 0x47, 0xcc, 0x9a, 0xa5, 0xbd, 0xcc, 0x7e, 0xfe,
0x79, 0xb6, 0x99, 0x31, 0xea, 0x33, 0x65, 0xa5, 0x8e, 0xe2, 0xb0, 0x03, 0xd8, 0x74, 0xe7, 0xf2,
0xda, 0xc5, 0x47, 0x20, 0xda, 0x0c, 0x84, 0x6c, 0x56, 0xf6, 0x72, 0xfb, 0x79, 0xa3, 0x11, 0x31,
0x10, 0x3b, 0x12, 0x12, 0xb1, 0xc1, 0x6b, 0x21, 0x3c, 0x73, 0xe2, 0x3a, 0x57, 0xa6, 0xe4, 0xfe,
0xb5, 0x90, 0xcd, 0xf2, 0x5e, 0x66, 0xbf, 0x60, 0x34, 0x88, 0xd1, 0x71, 0x9d, 0xab, 0x31, 0x91,
0xd9, 0xc7, 0xc0, 0x6e, 0xe4, 0x6c, 0x42, 0x50, 0xcb, 0xb7, 0x95, 0xb3, 0x9a, 0x35, 0x02, 0x6f,
0x22, 0xa7, 0x93, 0x64, 0xb0, 0xcf, 0x60, 0x87, 0x8c, 0xe3, 0xcd, 0x2f, 0x67, 0xd6, 0x84, 0x88,
0xe6, 0x54, 0xf0, 0xe9, 0xcc, 0x72, 0x44, 0x13, 0x50, 0x7b, 0x63, 0x1b, 0x01, 0xc3, 0x05, 0xff,
0x38, 0x64, 0xb3, 0x87, 0x50, 0x98, 0xf1, 0x4b, 0x31, 0x6b, 0x56, 0xc9, 0xaf, 0xea, 0x83, 0xed,
0x42, 0xd9, 0x72, 0x2c, 0x69, 0x71, 0xe9, 0xfa, 0xcd, 0x3a, 0x71, 0x16, 0x04, 0xfd, 0xb7, 0x59,
0xa8, 0x61, 0xbc, 0xf4, 0x9c, 0xf5, 0xe1, 0xb2, 0xec, 0xb4, 0xec, 0x1d, 0xa7, 0xdd, 0x71, 0x47,
0xee, 0xae, 0x3b, 0x76, 0xa0, 0x34, 0xe3, 0x81, 0x34, 0x6f, 0x5c, 0x8f, 0x22, 0xa4, 0x6a, 0x14,
0xf1, 0xfb, 0xd4, 0xf5, 0xd8, 0xbb, 0x50, 0x13, 0xb7, 0x52, 0xf8, 0x0e, 0x9f, 0x99, 0x68, 0x12,
0x0a, 0x8b, 0x92, 0x51, 0x8d, 0x88, 0xa7, 0x72, 0x36, 0x61, 0xfb, 0xa0, 0xc5, 0x86, 0x8c, 0x6c,
0xbe, 0x41, 0x66, 0xac, 0x47, 0x66, 0x0c, 0x4d, 0x1e, 0xdb, 0xa1, 0xb8, 0xd6, 0x0e, 0xa5, 0x65,
0x3b, 0xfc, 0x3b, 0x03, 0x55, 0x0a, 0x70, 0x11, 0x78, 0xae, 0x13, 0x08, 0xc6, 0x20, 0x6b, 0x4d,
0xc9, 0x0a, 0x65, 0x8a, 0x97, 0xac, 0x35, 0xc5, 0x27, 0x58, 0x53, 0xf3, 0xf2, 0x8d, 0x14, 0x01,
0xbd, 0xb0, 0x6a, 0x14, 0xad, 0xe9, 0x73, 0xfc, 0x64, 0x4f, 0xa1, 0x4a, 0xda, 0xf1, 0xe9, 0xd4,
0x17, 0x41, 0xa0, 0x52, 0x8b, 0x0e, 0x56, 0x90, 0x7e, 0xa4, 0xc8, 0xec, 0x19, 0x6c, 0x25, 0x61,
0xa6, 0xe3, 0x1d, 0xbe, 0x0e, 0x6e, 0xc8, 0x1e, 0x65, 0x15, 0x0e, 0x21, 0xb2, 0x4f, 0x0c, 0xf6,
0x51, 0x18, 0x3d, 0x11, 0x5e, 0xc1, 0x0b, 0x04, 0xd7, 0x12, 0xf0, 0x21, 0xa1, 0x9f, 0x42, 0x3d,
0x10, 0xfe, 0x2b, 0xe1, 0x9b, 0xb6, 0x08, 0x02, 0x7e, 0x2d, 0xc8, 0x40, 0x65, 0xa3, 0xa6, 0xa8,
0xe7, 0x8a, 0xa8, 0x6b, 0x50, 0x3f, 0x77, 0x1d, 0x4b, 0xba, 0x7e, 0xe8, 0x73, 0xfd, 0x4f, 0x79,
0x00, 0x7c, 0xfd, 0x48, 0x72, 0x39, 0x0f, 0x56, 0x56, 0x0c, 0xb4, 0x46, 0x76, 0xad, 0x35, 0x2a,
0xcb, 0xd6, 0xc8, 0xcb, 0x37, 0x9e, 0x0a, 0x83, 0xfa, 0xe1, 0xe6, 0xb3, 0xb0, 0x76, 0x3d, 0xc3,
0x3b, 0xc6, 0x6f, 0x3c, 0x61, 0x10, 0x9b, 0xed, 0x43, 0x21, 0x90, 0x5c, 0xaa, 0x8a, 0x51, 0x3f,
0x64, 0x29, 0x1c, 0xea, 0x22, 0x0c, 0x05, 0x60, 0x5f, 0x40, 0xfd, 0x8a, 0x5b, 0xb3, 0xb9, 0x2f,
0x4c, 0x5f, 0xf0, 0xc0, 0x75, 0x28, 0x92, 0xeb, 0x87, 0x8f, 0xe3, 0x23, 0x27, 0x8a, 0x6d, 0x10,
0xd7, 0xa8, 0x5d, 0x25, 0x3f, 0xd9, 0xfb, 0xd0, 0x08, 0x5d, 0x8d, 0xf9, 0x24, 0x2d, 0x3b, 0xaa,
0x3c, 0xf5, 0x05, 0x79, 0x6c, 0xd9, 0xa8, 0x91, 0x46, 0x41, 0x3a, 0xf7, 0xa6, 0x5c, 0x0a, 0x85,
0x54, 0xf5, 0xa7, 0x8e, 0xf4, 0x0b, 0x22, 0x13, 0x72, 0xd9, 0xe1, 0xc5, 0xd5, 0x0e, 0x5f, 0xed,
0xc0, 0xea, 0x1a, 0x07, 0xae, 0x09, 0x8f, 0xda, 0xba, 0xf0, 0x78, 0x07, 0x2a, 0x13, 0x37, 0x90,
0xa6, 0xf2, 0x2f, 0x45, 0x75, 0xce, 0x00, 0x24, 0x8d, 0x88, 0xc2, 0x9e, 0x40, 0x95, 0x00, 0xae,
0x33, 0xb9, 0xe1, 0x96, 0x43, 0x45, 0x2a, 0x67, 0xd0, 0xa1, 0x81, 0x22, 0x61, 0xf2, 0x29, 0xc8,
0xd5, 0x95, 0xc2, 0x80, 0xaa, 0xb7, 0x84, 0x09, 0x69, 0x8b, 0x94, 0x6a, 0x24, 0x52, 0x4a, 0x67,
0xa0, 0x9d, 0x59, 0x81, 0x44, 0x6f, 0x05, 0x51, 0x28, 0xfd, 0x04, 0x36, 0x13, 0xb4, 0x30, 0x99,
0x3e, 0x80, 0x02, 0x56, 0x8f, 0xa0, 0x99, 0xd9, 0xcb, 0xed, 0x57, 0x0e, 0xb7, 0xee, 0x38, 0x7a,
0x1e, 0x18, 0x0a, 0xa1, 0x3f, 0x81, 0x06, 0x12, 0x7b, 0xce, 0x95, 0x1b, 0x55, 0xa4, 0x7a, 0x9c,
0x8a, 0x55, 0x0c, 0x3c, 0xbd, 0x0e, 0xd5, 0xb1, 0xf0, 0xed, 0xf8, 0xca, 0x5f, 0x43, 0xa3, 0xe7,
0x84, 0x94, 0xf0, 0xc2, 0x1f, 0x40, 0xc3, 0xb6, 0x1c, 0x55, 0xb2, 0xb8, 0xed, 0xce, 0x1d, 0x19,
0x3a, 0xbc, 0x66, 0x5b, 0x0e, 0xca, 0x3f, 0x22, 0x22, 0xe1, 0xa2, 0xd2, 0x16, 0xe2, 0x36, 0x42,
0x9c, 0xaa, 0x6e, 0x0a, 0xf7, 0x22, 0x5f, 0xca, 0x68, 0xd9, 0x17, 0xf9, 0x52, 0x56, 0xcb, 0xbd,
0xc8, 0x97, 0x72, 0x5a, 0xfe, 0x45, 0xbe, 0x94, 0xd7, 0x0a, 0x2f, 0xf2, 0xa5, 0xa2, 0x56, 0xd2,
0xff, 0x9a, 0x01, 0x6d, 0x30, 0x97, 0xff, 0x57, 0x15, 0xa8, 0x31, 0x5a, 0x8e, 0x39, 0x99, 0xc9,
0x57, 0xe6, 0x54, 0xcc, 0x24, 0x27, 0x77, 0x17, 0x8c, 0xaa, 0x6d, 0x39, 0x9d, 0x99, 0x7c, 0x75,
0x8c, 0xb4, 0xa8, 0x7d, 0x26, 0x50, 0xe5, 0x10, 0xc5, 0x6f, 0x63, 0xd4, 0xf7, 0x3c, 0xe7, 0x0f,
0x19, 0xa8, 0xfe, 0x6c, 0xee, 0x4a, 0xb1, 0xbe, 0x25, 0x50, 0xe0, 0x2d, 0xea, 0x70, 0x96, 0xee,
0x80, 0xc9, 0xa2, 0x06, 0xdf, 0x29, 0xe9, 0xb9, 0x15, 0x25, 0xfd, 0xde, 0x66, 0x97, 0xbf, 0xb7,
0xd9, 0xe9, 0xbf, 0xcb, 0xa0, 0xd7, 0x43, 0x35, 0x43, 0x93, 0xef, 0x41, 0x35, 0x6a, 0x52, 0x66,
0xc0, 0x23, 0x85, 0x21, 0x50, 0x5d, 0x6a, 0xc4, 0x69, 0xca, 0xa1, 0x04, 0xa3, 0x1b, 0x83, 0x9b,
0x18, 0x19, 0x4e, 0x39, 0xc8, 0x1b, 0x2a, 0x56, 0x78, 0xe0, 0x6d, 0x80, 0x84, 0x2d, 0x0b, 0xf4,
0xce, 0xf2, 0x24, 0x61, 0x48, 0x65, 0xc2, 0xbc, 0x56, 0xd0, 0xff, 0xae, 0xa2, 0xe0, 0x7f, 0x55,
0xe9, 0x3d, 0xa8, 0x2f, 0x86, 0x1d, 0xc2, 0xa8, 0xfe, 0x5a, 0xf5, 0xa2, 0x69, 0x07, 0x51, 0x1f,
0x86, 0x75, 0x44, 0xcd, 0x1d, 0x69, 0xb5, 0x1b, 0xc8, 0x19, 0x21, 0x23, 0x14, 0x49, 0xf3, 0x09,
0xda, 0x95, 0xbf, 0xb1, 0x85, 0x23, 0x4d, 0x1a, 0xf6, 0x54, 0xcf, 0x6d, 0x90, 0x3d, 0x15, 0xfd,
0x18, 0x7d, 0x7b, 0xff, 0x03, 0xf5, 0x06, 0xd4, 0xc6, 0xee, 0x37, 0xc2, 0x89, 0x93, 0xed, 0x73,
0xa8, 0x47, 0x84, 0xf0, 0x89, 0x07, 0xb0, 0x21, 0x89, 0x12, 0x66, 0xf7, 0xa2, 0x8c, 0x9f, 0x05,
0x5c, 0x12, 0xd8, 0x08, 0x11, 0xfa, 0x9f, 0xb3, 0x50, 0x8e, 0xa9, 0x18, 0x24, 0x97, 0x3c, 0x10,
0xa6, 0xcd, 0x27, 0xdc, 0x77, 0x5d, 0x27, 0xcc, 0xf1, 0x2a, 0x12, 0xcf, 0x43, 0x1a, 0x96, 0xb0,
0xe8, 0x1d, 0x37, 0x3c, 0xb8, 0x21, 0xeb, 0x54, 0x8d, 0x4a, 0x48, 0x3b, 0xe5, 0xc1, 0x0d, 0xfb,
0x00, 0xb4, 0x08, 0xe2, 0xf9, 0xc2, 0xb2, 0xb1, 0xf3, 0xa9, 0xfe, 0xdc, 0x08, 0xe9, 0xc3, 0x90,
0x8c, 0x05, 0x5e, 0x25, 0x99, 0xe9, 0x71, 0x6b, 0x6a, 0xda, 0x68, 0x45, 0x35, 0xaf, 0xd6, 0x15,
0x7d, 0xc8, 0xad, 0xe9, 0x79, 0xc0, 0x25, 0xfb, 0x04, 0x1e, 0x25, 0x86, 0xda, 0x04, 0x5c, 0x65,
0x31, 0xf3, 0xe3, 0xa9, 0x36, 0x3e, 0xf2, 0x04, 0xaa, 0xd8, 0x31, 0xcc, 0x89, 0x2f, 0xb8, 0x14,
0xd3, 0x30, 0x8f, 0x2b, 0x48, 0xeb, 0x28, 0x12, 0x6b, 0x42, 0x51, 0xdc, 0x7a, 0x96, 0x2f, 0xa6,
0xd4, 0x31, 0x4a, 0x46, 0xf4, 0x89, 0x87, 0x03, 0xe9, 0xfa, 0xfc, 0x5a, 0x98, 0x0e, 0xb7, 0x45,
0x38, 0xa2, 0x54, 0x42, 0x5a, 0x9f, 0xdb, 0x42, 0x7f, 0x0b, 0x76, 0xbe, 0x14, 0xf2, 0xcc, 0xfa,
0x76, 0x6e, 0x4d, 0x2d, 0xf9, 0x66, 0xc8, 0x7d, 0xbe, 0xa8, 0x82, 0x7f, 0x2b, 0xc0, 0x56, 0x9a,
0x25, 0xa4, 0xf0, 0xb1, 0x03, 0x15, 0xfc, 0xf9, 0x4c, 0x44, 0xde, 0x59, 0x74, 0xcc, 0x18, 0x6c,
0xcc, 0x67, 0xc2, 0x50, 0x20, 0xf6, 0x05, 0xec, 0x2e, 0x42, 0xcc, 0xc7, 0x1e, 0x18, 0x70, 0x69,
0x7a, 0xc2, 0x37, 0x5f, 0x61, 0xa7, 0x27, 0xeb, 0x53, 0x56, 0xaa, 0x68, 0x33, 0xb8, 0xc4, 0x88,
0x1b, 0x0a, 0xff, 0x25, 0xb2, 0xd9, 0xfb, 0xa0, 0x25, 0x47, 0x45, 0xd3, 0xf3, 0x6c, 0xf2, 0x44,
0x3e, 0xae, 0x66, 0x68, 0x2f, 0xcf, 0x66, 0x1f, 0x03, 0xee, 0x07, 0x66, 0xca, 0xc2, 0x9e, 0x1d,
0x26, 0x3d, 0xca, 0x58, 0x2c, 0x0d, 0x08, 0xff, 0x0c, 0x5a, 0xab, 0x97, 0x0d, 0x3a, 0x55, 0xa0,
0x53, 0x8f, 0x57, 0x2c, 0x1c, 0x78, 0x36, 0xbd, 0x51, 0xa0, 0x07, 0x37, 0x08, 0xbf, 0xd8, 0x28,
0x30, 0x67, 0x3e, 0x80, 0xcd, 0xd4, 0x08, 0x4b, 0xc0, 0x22, 0x01, 0xeb, 0x89, 0x31, 0x36, 0x4e,
0xaf, 0xe5, 0xf1, 0xbf, 0xb4, 0x7a, 0xfc, 0x7f, 0x06, 0x5b, 0xd1, 0xe0, 0x72, 0xc9, 0x27, 0xdf,
0xb8, 0x57, 0x57, 0x66, 0x20, 0x26, 0x54, 0x94, 0xf3, 0xc6, 0x66, 0xc8, 0x7a, 0xae, 0x38, 0x23,
0x31, 0xc1, 0x49, 0x9a, 0xcf, 0xa5, 0x6b, 0x46, 0x9b, 0x0b, 0x75, 0xe3, 0x92, 0x51, 0x41, 0x62,
0xb8, 0xd7, 0xa1, 0xed, 0x08, 0x83, 0x8b, 0xcd, 0xe5, 0x7c, 0x7a, 0x2d, 0x54, 0xd9, 0xa8, 0x28,
0xdb, 0x21, 0x6b, 0x30, 0x97, 0xcf, 0x89, 0x81, 0xea, 0xfe, 0x08, 0x76, 0xee, 0xc0, 0x25, 0xf7,
0x25, 0x29, 0x52, 0xa5, 0x43, 0x8f, 0xd2, 0x87, 0x90, 0x8b, 0xca, 0x7c, 0x08, 0x8c, 0x4e, 0xa2,
0x61, 0x2c, 0xc7, 0xbc, 0x9a, 0x59, 0xd7, 0x37, 0x92, 0xa6, 0x91, 0xbc, 0xd1, 0x40, 0xce, 0x39,
0xbf, 0xed, 0x39, 0x27, 0x44, 0x5e, 0xd5, 0xef, 0xea, 0xa1, 0xe7, 0xbf, 0xaf, 0xdf, 0x35, 0x52,
0x11, 0xa2, 0x70, 0xfa, 0x5f, 0x32, 0x50, 0x4b, 0x85, 0x28, 0x95, 0x2a, 0xb5, 0xad, 0x99, 0xe1,
0x3c, 0x90, 0x37, 0xca, 0x21, 0xa5, 0x37, 0x65, 0xcf, 0xc2, 0xa1, 0x33, 0x4b, 0x93, 0x61, 0x6b,
0x75, 0x9c, 0x27, 0xa6, 0xcf, 0x8f, 0x81, 0x59, 0xce, 0xc4, 0xb5, 0x31, 0x92, 0xe4, 0x8d, 0x2f,
0x82, 0x1b, 0x77, 0x36, 0xa5, 0x68, 0xad, 0x19, 0x9b, 0x11, 0x67, 0x1c, 0x31, 0x10, 0x1e, 0x2f,
0x88, 0x0b, 0x78, 0x5e, 0xc1, 0x23, 0x4e, 0x0c, 0xd7, 0xbf, 0x86, 0x9d, 0xd1, 0xba, 0x5c, 0x65,
0x9f, 0x03, 0x78, 0x71, 0x86, 0xd2, 0x4b, 0x2a, 0x87, 0xbb, 0x77, 0x15, 0x5e, 0x64, 0xb1, 0x91,
0xc0, 0xeb, 0xbb, 0xd0, 0x5a, 0x25, 0x5a, 0x95, 0x63, 0xfd, 0x11, 0x6c, 0x8d, 0xe6, 0xd7, 0xd7,
0x62, 0x69, 0x2e, 0x7b, 0x01, 0x0f, 0xd3, 0xe4, 0xb0, 0x7a, 0x1f, 0x42, 0x29, 0x8e, 0x35, 0x55,
0x21, 0xb6, 0x17, 0x8a, 0xa4, 0xfe, 0x48, 0x30, 0x8a, 0xe1, 0xca, 0x7c, 0xf0, 0x14, 0x4a, 0xd1,
0x24, 0xcf, 0xaa, 0x50, 0x3a, 0x1b, 0x0c, 0x86, 0xe6, 0xe0, 0x62, 0xac, 0x3d, 0x60, 0x15, 0x28,
0xd2, 0x57, 0xaf, 0xaf, 0x65, 0x0e, 0x02, 0x28, 0xc7, 0x83, 0x3c, 0xab, 0x41, 0xb9, 0xd7, 0xef,
0x8d, 0x7b, 0x47, 0xe3, 0xee, 0xb1, 0xf6, 0x80, 0x3d, 0x82, 0xcd, 0xa1, 0xd1, 0xed, 0x9d, 0x1f,
0x7d, 0xd9, 0x35, 0x8d, 0xee, 0xcb, 0xee, 0xd1, 0x59, 0xf7, 0x58, 0xcb, 0x30, 0x06, 0xf5, 0xd3,
0xf1, 0x59, 0xc7, 0x1c, 0x5e, 0x3c, 0x3f, 0xeb, 0x8d, 0x4e, 0xbb, 0xc7, 0x5a, 0x16, 0x65, 0x8e,
0x2e, 0x3a, 0x9d, 0xee, 0x68, 0xa4, 0xe5, 0x18, 0xc0, 0xc6, 0xc9, 0x51, 0x0f, 0xc1, 0x79, 0xb6,
0x05, 0x8d, 0x5e, 0xff, 0xe5, 0xa0, 0xd7, 0xe9, 0x9a, 0xa3, 0xee, 0x78, 0x8c, 0xc4, 0xc2, 0xc1,
0x7f, 0x32, 0x50, 0x4b, 0xed, 0x02, 0x6c, 0x1b, 0xb6, 0xf0, 0xc8, 0x85, 0x81, 0x37, 0x1d, 0x8d,
0x06, 0x7d, 0xb3, 0x3f, 0xe8, 0x77, 0xb5, 0x07, 0xec, 0x2d, 0xd8, 0x5e, 0x62, 0x0c, 0x4e, 0x4e,
0x3a, 0xa7, 0x47, 0xa8, 0x3c, 0x6b, 0xc1, 0xe3, 0x25, 0xe6, 0xb8, 0x77, 0xde, 0xc5, 0x57, 0x66,
0xd9, 0x1e, 0xec, 0x2e, 0xf1, 0x46, 0x5f, 0x75, 0xbb, 0xc3, 0x18, 0x91, 0x63, 0x4f, 0xe1, 0xc9,
0x12, 0xa2, 0xd7, 0x1f, 0x5d, 0x9c, 0x9c, 0xf4, 0x3a, 0xbd, 0x6e, 0x7f, 0x6c, 0xbe, 0x3c, 0x3a,
0xbb, 0xe8, 0x6a, 0x79, 0xb6, 0x0b, 0xcd, 0xe5, 0x4b, 0xba, 0xe7, 0xc3, 0x81, 0x71, 0x64, 0x7c,
0xad, 0x15, 0xd8, 0xbb, 0xf0, 0xce, 0x1d, 0x21, 0x9d, 0x81, 0x61, 0x74, 0x3b, 0x63, 0xf3, 0xe8,
0x7c, 0x70, 0xd1, 0x1f, 0x6b, 0x1b, 0x07, 0x6d, 0x9c, 0xb7, 0x97, 0x02, 0x1c, 0x4d, 0x76, 0xd1,
0xff, 0x69, 0x7f, 0xf0, 0x55, 0x5f, 0x7b, 0x80, 0x96, 0x1f, 0x9f, 0x1a, 0xdd, 0xd1, 0xe9, 0xe0,
0xec, 0x58, 0xcb, 0x1c, 0xfe, 0xb3, 0xac, 0x76, 0xbd, 0x0e, 0xfd, 0xbb, 0xc4, 0x0c, 0x28, 0x46,
0x75, 0x65, 0x9d, 0xe3, 0x5b, 0x8f, 0x52, 0xf3, 0x7a, 0x1c, 0x69, 0xdb, 0xbf, 0xf9, 0xc7, 0xbf,
0x7e, 0x9f, 0xdd, 0xd4, 0xab, 0xed, 0x57, 0x9f, 0xb4, 0x11, 0xd1, 0x76, 0xe7, 0xf2, 0xb3, 0xcc,
0x01, 0x1b, 0xc0, 0x86, 0xfa, 0x4f, 0x81, 0x3d, 0x4e, 0x89, 0x8c, 0xff, 0x64, 0x58, 0x27, 0xf1,
0x31, 0x49, 0xd4, 0xf4, 0x4a, 0x2c, 0xd1, 0x72, 0x50, 0xe0, 0x8f, 0xa1, 0x18, 0x6e, 0xac, 0x09,
0x25, 0xd3, 0x3b, 0x6c, 0x6b, 0xd5, 0x52, 0xf1, 0xc3, 0x0c, 0xfb, 0x39, 0x94, 0xe3, 0x7d, 0x84,
0xed, 0x24, 0x72, 0x2c, 0x9d, 0x1f, 0xad, 0xd6, 0x2a, 0x56, 0x5a, 0x2d, 0x56, 0x8f, 0xd5, 0xa2,
0x5d, 0x85, 0x5d, 0xa8, 0x3c, 0xc0, 0x5d, 0x85, 0x35, 0x53, 0xd7, 0x27, 0xd6, 0x97, 0x95, 0x8a,
0xe9, 0x2d, 0x12, 0xf9, 0x90, 0xb1, 0x94, 0xc8, 0xf6, 0x77, 0xd6, 0xf4, 0x97, 0xec, 0x17, 0x50,
0x0d, 0x1d, 0x40, 0x1b, 0x05, 0x5b, 0x18, 0x2b, 0xb9, 0xf6, 0xb4, 0x16, 0x8f, 0x59, 0xde, 0x3d,
0x56, 0x48, 0x77, 0xe7, 0xb2, 0x2d, 0x49, 0xda, 0x65, 0x2c, 0x9d, 0x26, 0xd5, 0x84, 0xf4, 0xe4,
0xcc, 0x9f, 0x96, 0x9e, 0x9a, 0x69, 0xf5, 0x3d, 0x92, 0xde, 0x62, 0xcd, 0x94, 0xf4, 0x6f, 0x11,
0xd3, 0xfe, 0x8e, 0xdb, 0x12, 0x5f, 0x50, 0xc7, 0x41, 0x85, 0x5c, 0x7e, 0xef, 0x1b, 0x16, 0x56,
0x5b, 0xda, 0xe0, 0xf4, 0x1d, 0xba, 0x64, 0x8b, 0x6d, 0x26, 0x42, 0x21, 0x7e, 0xc1, 0x42, 0xfa,
0xbd, 0x6f, 0x48, 0x4a, 0x4f, 0x3f, 0xe1, 0x1d, 0x92, 0xbe, 0xc3, 0xb6, 0x93, 0xd2, 0x93, 0x2f,
0xf8, 0x1a, 0x6a, 0x78, 0x47, 0x34, 0xaa, 0x06, 0x89, 0x48, 0x4e, 0xcd, 0xc3, 0xad, 0xed, 0x3b,
0xf4, 0x74, 0x76, 0xb0, 0x06, 0x5d, 0x11, 0x70, 0xd9, 0x56, 0x33, 0x30, 0x93, 0xc0, 0xee, 0x4e,
0x71, 0x4c, 0x8f, 0xe5, 0xac, 0x1d, 0xf1, 0x5a, 0xf7, 0xb6, 0x08, 0x7d, 0x97, 0x2e, 0x7c, 0xcc,
0x1e, 0xd2, 0x85, 0x11, 0xa0, 0xed, 0x29, 0xf9, 0xbf, 0x02, 0x36, 0xba, 0xef, 0xd6, 0xb5, 0xcd,
0xaa, 0xf5, 0xee, 0xbd, 0x98, 0xb4, 0x41, 0xf5, 0x95, 0x97, 0x63, 0x0a, 0x0b, 0xa8, 0x26, 0xfb,
0x0f, 0x5b, 0xbc, 0x65, 0x45, 0xb7, 0x6a, 0xbd, 0xbd, 0x86, 0x1b, 0xde, 0xd6, 0xa4, 0xdb, 0x18,
0xd3, 0xf0, 0x36, 0x1c, 0x44, 0xda, 0x81, 0x82, 0x5d, 0x6e, 0xd0, 0xdf, 0xe0, 0x9f, 0xfe, 0x37,
0x00, 0x00, 0xff, 0xff, 0x79, 0xf0, 0xb4, 0xfa, 0x3d, 0x17, 0x00, 0x00,
// 2389 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x6f, 0xe3, 0xc6,
0x15, 0x5f, 0x7d, 0x59, 0xd2, 0x13, 0x45, 0xd1, 0xe3, 0x5d, 0x5b, 0x56, 0x1c, 0xc4, 0xcb, 0x64,
0x1b, 0xc7, 0x49, 0xac, 0xc6, 0x39, 0x25, 0x48, 0x0a, 0x68, 0x65, 0x39, 0x96, 0x6b, 0x4b, 0x2a,
0x25, 0x6f, 0x90, 0xa2, 0x00, 0x31, 0x96, 0xc6, 0x16, 0x11, 0xf1, 0x23, 0xe4, 0x68, 0xd7, 0x46,
0xd0, 0x16, 0x28, 0xd0, 0x73, 0x0f, 0xfd, 0x0f, 0x7a, 0xef, 0xad, 0xb7, 0xf6, 0xde, 0x4b, 0x4f,
0xed, 0xb1, 0xd7, 0x5e, 0x7a, 0xe8, 0xff, 0x50, 0xcc, 0x1b, 0x92, 0x22, 0x65, 0xc9, 0x41, 0x0f,
0xbd, 0x89, 0xef, 0xfd, 0xe6, 0xcd, 0x9b, 0xf7, 0xfd, 0x04, 0xca, 0x78, 0x66, 0x31, 0x87, 0x1f,
0x79, 0xbe, 0xcb, 0x5d, 0x52, 0x9c, 0xb9, 0xae, 0xe7, 0x7b, 0xe3, 0xc6, 0xde, 0xad, 0xeb, 0xde,
0xce, 0x58, 0x93, 0x7a, 0x56, 0x93, 0x3a, 0x8e, 0xcb, 0x29, 0xb7, 0x5c, 0x27, 0x90, 0x30, 0xfd,
0x8f, 0x79, 0x50, 0x2f, 0x5c, 0xd7, 0xeb, 0xcf, 0xb9, 0xc1, 0xbe, 0x9b, 0xb3, 0x80, 0x13, 0x0d,
0x72, 0xd4, 0xe6, 0xf5, 0xcc, 0x7e, 0xe6, 0x20, 0x67, 0x88, 0x9f, 0x84, 0x40, 0x7e, 0xc2, 0x02,
0x5e, 0xcf, 0xee, 0x67, 0x0e, 0xca, 0x06, 0xfe, 0x26, 0x4d, 0x78, 0x6a, 0xd3, 0x3b, 0x33, 0x78,
0x43, 0x3d, 0xd3, 0x77, 0xe7, 0xdc, 0x72, 0x6e, 0xcd, 0x1b, 0xc6, 0xea, 0x39, 0x3c, 0xb6, 0x69,
0xd3, 0xbb, 0xe1, 0x1b, 0xea, 0x19, 0x92, 0x73, 0xca, 0x18, 0xf9, 0x14, 0xb6, 0xc5, 0x01, 0xcf,
0x67, 0x1e, 0xbd, 0x4f, 0x1d, 0xc9, 0xe3, 0x91, 0x2d, 0x9b, 0xde, 0x0d, 0x90, 0x99, 0x38, 0xb4,
0x0f, 0x4a, 0x7c, 0x8b, 0x80, 0x16, 0x10, 0x0a, 0xa1, 0x74, 0x81, 0x78, 0x0f, 0xd4, 0x84, 0x58,
0xa1, 0xf8, 0x06, 0x62, 0x94, 0x58, 0x5c, 0xcb, 0xe6, 0x44, 0x87, 0xaa, 0x40, 0xd9, 0x96, 0xc3,
0x7c, 0x14, 0x54, 0x44, 0x50, 0xc5, 0xa6, 0x77, 0x97, 0x82, 0x26, 0x24, 0x7d, 0x04, 0x9a, 0xb0,
0x99, 0xe9, 0xce, 0xb9, 0x39, 0x9e, 0x52, 0xc7, 0x61, 0xb3, 0x7a, 0x69, 0x3f, 0x73, 0x90, 0x7f,
0x99, 0xad, 0x67, 0x0c, 0x75, 0x26, 0xad, 0xd4, 0x96, 0x1c, 0x72, 0x08, 0x9b, 0xee, 0x9c, 0xdf,
0xba, 0xe2, 0x11, 0x02, 0x6d, 0x06, 0x8c, 0xd7, 0x2b, 0xfb, 0xb9, 0x83, 0xbc, 0x51, 0x8b, 0x18,
0x02, 0x3b, 0x64, 0x5c, 0x60, 0x83, 0x37, 0x8c, 0x79, 0xe6, 0xd8, 0x75, 0x6e, 0x4c, 0x4e, 0xfd,
0x5b, 0xc6, 0xeb, 0xe5, 0xfd, 0xcc, 0x41, 0xc1, 0xa8, 0x21, 0xa3, 0xed, 0x3a, 0x37, 0x23, 0x24,
0x93, 0x8f, 0x81, 0x4c, 0xf9, 0x6c, 0x8c, 0x50, 0xcb, 0xb7, 0xa5, 0xb3, 0xea, 0x55, 0x04, 0x6f,
0x0a, 0x4e, 0x3b, 0xc9, 0x20, 0x9f, 0xc3, 0x2e, 0x1a, 0xc7, 0x9b, 0x5f, 0xcf, 0xac, 0x31, 0x12,
0xcd, 0x09, 0xa3, 0x93, 0x99, 0xe5, 0xb0, 0x3a, 0x08, 0xed, 0x8d, 0x1d, 0x01, 0x18, 0x2c, 0xf8,
0x27, 0x21, 0x9b, 0x3c, 0x85, 0xc2, 0x8c, 0x5e, 0xb3, 0x59, 0x5d, 0x41, 0xbf, 0xca, 0x0f, 0xb2,
0x07, 0x65, 0xcb, 0xb1, 0xb8, 0x45, 0xb9, 0xeb, 0xd7, 0x55, 0xe4, 0x2c, 0x08, 0xfa, 0x6f, 0xb3,
0x50, 0x15, 0xf1, 0xd2, 0x75, 0xd6, 0x87, 0xcb, 0xb2, 0xd3, 0xb2, 0x0f, 0x9c, 0xf6, 0xc0, 0x1d,
0xb9, 0x87, 0xee, 0xd8, 0x85, 0xd2, 0x8c, 0x06, 0xdc, 0x9c, 0xba, 0x1e, 0x46, 0x88, 0x62, 0x14,
0xc5, 0xf7, 0x99, 0xeb, 0x91, 0x77, 0xa1, 0xca, 0xee, 0x38, 0xf3, 0x1d, 0x3a, 0x33, 0x85, 0x49,
0x30, 0x2c, 0x4a, 0x86, 0x12, 0x11, 0xcf, 0xf8, 0x6c, 0x4c, 0x0e, 0x40, 0x8b, 0x0d, 0x19, 0xd9,
0x7c, 0x03, 0xcd, 0xa8, 0x46, 0x66, 0x0c, 0x4d, 0x1e, 0xdb, 0xa1, 0xb8, 0xd6, 0x0e, 0xa5, 0x65,
0x3b, 0xfc, 0x3b, 0x03, 0x0a, 0x06, 0x38, 0x0b, 0x3c, 0xd7, 0x09, 0x18, 0x21, 0x90, 0xb5, 0x26,
0x68, 0x85, 0x32, 0xc6, 0x4b, 0xd6, 0x9a, 0x88, 0x27, 0x58, 0x13, 0xf3, 0xfa, 0x9e, 0xb3, 0x00,
0x5f, 0xa8, 0x18, 0x45, 0x6b, 0xf2, 0x52, 0x7c, 0x92, 0x17, 0xa0, 0xa0, 0x76, 0x74, 0x32, 0xf1,
0x59, 0x10, 0xc8, 0xd4, 0xc2, 0x83, 0x15, 0x41, 0x6f, 0x49, 0x32, 0x39, 0x82, 0xad, 0x24, 0xcc,
0x74, 0xbc, 0xe3, 0x37, 0xc1, 0x14, 0xed, 0x51, 0x96, 0xe1, 0x10, 0x22, 0x7b, 0xc8, 0x20, 0x1f,
0x85, 0xd1, 0x13, 0xe1, 0x25, 0xbc, 0x80, 0x70, 0x2d, 0x01, 0x1f, 0x20, 0xfa, 0x05, 0xa8, 0x01,
0xf3, 0x5f, 0x33, 0xdf, 0xb4, 0x59, 0x10, 0xd0, 0x5b, 0x86, 0x06, 0x2a, 0x1b, 0x55, 0x49, 0xbd,
0x94, 0x44, 0x5d, 0x03, 0xf5, 0xd2, 0x75, 0x2c, 0xee, 0xfa, 0xa1, 0xcf, 0xf5, 0x3f, 0xe5, 0x01,
0xc4, 0xeb, 0x87, 0x9c, 0xf2, 0x79, 0xb0, 0xb2, 0x62, 0x08, 0x6b, 0x64, 0xd7, 0x5a, 0xa3, 0xb2,
0x6c, 0x8d, 0x3c, 0xbf, 0xf7, 0x64, 0x18, 0xa8, 0xc7, 0x9b, 0x47, 0x61, 0xed, 0x3a, 0x12, 0x77,
0x8c, 0xee, 0x3d, 0x66, 0x20, 0x9b, 0x1c, 0x40, 0x21, 0xe0, 0x94, 0xcb, 0x8a, 0xa1, 0x1e, 0x93,
0x14, 0x4e, 0xe8, 0xc2, 0x0c, 0x09, 0x20, 0x5f, 0x82, 0x7a, 0x43, 0xad, 0xd9, 0xdc, 0x67, 0xa6,
0xcf, 0x68, 0xe0, 0x3a, 0x18, 0xc9, 0xea, 0xf1, 0x76, 0x7c, 0xe4, 0x54, 0xb2, 0x0d, 0xe4, 0x1a,
0xd5, 0x9b, 0xe4, 0x27, 0x79, 0x1f, 0x6a, 0xa1, 0xab, 0x45, 0x3e, 0x71, 0xcb, 0x8e, 0x2a, 0x8f,
0xba, 0x20, 0x8f, 0x2c, 0x5b, 0x68, 0xa4, 0x61, 0x90, 0xce, 0xbd, 0x09, 0xe5, 0x4c, 0x22, 0x65,
0xfd, 0x51, 0x05, 0xfd, 0x0a, 0xc9, 0x88, 0x5c, 0x76, 0x78, 0x71, 0xb5, 0xc3, 0x57, 0x3b, 0x50,
0x59, 0xe3, 0xc0, 0x35, 0xe1, 0x51, 0x5d, 0x17, 0x1e, 0xef, 0x40, 0x65, 0xec, 0x06, 0xdc, 0x94,
0xfe, 0xc5, 0xa8, 0xce, 0x19, 0x20, 0x48, 0x43, 0xa4, 0x90, 0xe7, 0xa0, 0x20, 0xc0, 0x75, 0xc6,
0x53, 0x6a, 0x39, 0x58, 0xa4, 0x72, 0x06, 0x1e, 0xea, 0x4b, 0x92, 0x48, 0x3e, 0x09, 0xb9, 0xb9,
0x91, 0x18, 0x90, 0xf5, 0x16, 0x31, 0x21, 0x6d, 0x91, 0x52, 0xb5, 0x44, 0x4a, 0xe9, 0x04, 0xb4,
0x0b, 0x2b, 0xe0, 0xc2, 0x5b, 0x41, 0x14, 0x4a, 0x3f, 0x81, 0xcd, 0x04, 0x2d, 0x4c, 0xa6, 0x0f,
0xa0, 0x20, 0xaa, 0x47, 0x50, 0xcf, 0xec, 0xe7, 0x0e, 0x2a, 0xc7, 0x5b, 0x0f, 0x1c, 0x3d, 0x0f,
0x0c, 0x89, 0xd0, 0x9f, 0x43, 0x4d, 0x10, 0xbb, 0xce, 0x8d, 0x1b, 0x55, 0x24, 0x35, 0x4e, 0x45,
0x45, 0x04, 0x9e, 0xae, 0x82, 0x32, 0x62, 0xbe, 0x1d, 0x5f, 0xf9, 0x6b, 0xa8, 0x75, 0x9d, 0x90,
0x12, 0x5e, 0xf8, 0x23, 0xa8, 0xd9, 0x96, 0x23, 0x4b, 0x16, 0xb5, 0xdd, 0xb9, 0xc3, 0x43, 0x87,
0x57, 0x6d, 0xcb, 0x11, 0xf2, 0x5b, 0x48, 0x44, 0x5c, 0x54, 0xda, 0x42, 0xdc, 0x46, 0x88, 0x93,
0xd5, 0x4d, 0xe2, 0xce, 0xf3, 0xa5, 0x8c, 0x96, 0x3d, 0xcf, 0x97, 0xb2, 0x5a, 0xee, 0x3c, 0x5f,
0xca, 0x69, 0xf9, 0xf3, 0x7c, 0x29, 0xaf, 0x15, 0xce, 0xf3, 0xa5, 0xa2, 0x56, 0xd2, 0xff, 0x96,
0x01, 0xad, 0x3f, 0xe7, 0xff, 0x57, 0x15, 0xb0, 0x31, 0x5a, 0x8e, 0x39, 0x9e, 0xf1, 0xd7, 0xe6,
0x84, 0xcd, 0x38, 0x45, 0x77, 0x17, 0x0c, 0xc5, 0xb6, 0x9c, 0xf6, 0x8c, 0xbf, 0x3e, 0x11, 0xb4,
0xa8, 0x7d, 0x26, 0x50, 0xe5, 0x10, 0x45, 0xef, 0x62, 0xd4, 0x0f, 0x3c, 0xe7, 0x0f, 0x19, 0x50,
0x7e, 0x36, 0x77, 0x39, 0x5b, 0xdf, 0x12, 0x30, 0xf0, 0x16, 0x75, 0x38, 0x8b, 0x77, 0xc0, 0x78,
0x51, 0x83, 0x1f, 0x94, 0xf4, 0xdc, 0x8a, 0x92, 0xfe, 0x68, 0xb3, 0xcb, 0x3f, 0xda, 0xec, 0xf4,
0xdf, 0x65, 0x84, 0xd7, 0x43, 0x35, 0x43, 0x93, 0xef, 0x83, 0x12, 0x35, 0x29, 0x33, 0xa0, 0x91,
0xc2, 0x10, 0xc8, 0x2e, 0x35, 0xa4, 0x38, 0xe5, 0x60, 0x82, 0xe1, 0x8d, 0xc1, 0x34, 0x46, 0x86,
0x53, 0x8e, 0xe0, 0x0d, 0x24, 0x2b, 0x3c, 0xf0, 0x36, 0x40, 0xc2, 0x96, 0x05, 0x7c, 0x67, 0x79,
0x9c, 0x30, 0xa4, 0x34, 0x61, 0x5e, 0x2b, 0xe8, 0x7f, 0x97, 0x51, 0xf0, 0xbf, 0xaa, 0xf4, 0x1e,
0xa8, 0x8b, 0x61, 0x07, 0x31, 0xb2, 0xbf, 0x2a, 0x5e, 0x34, 0xed, 0x08, 0xd4, 0x87, 0x61, 0x1d,
0x91, 0x73, 0x47, 0x5a, 0xed, 0x9a, 0xe0, 0x0c, 0x05, 0x23, 0x14, 0x89, 0xf3, 0x89, 0xb0, 0x2b,
0xbd, 0xb7, 0x99, 0xc3, 0x4d, 0x1c, 0xf6, 0x64, 0xcf, 0xad, 0xa1, 0x3d, 0x25, 0xfd, 0x44, 0xf8,
0xf6, 0xf1, 0x07, 0xea, 0x35, 0xa8, 0x8e, 0xdc, 0x6f, 0x99, 0x13, 0x27, 0xdb, 0x17, 0xa0, 0x46,
0x84, 0xf0, 0x89, 0x87, 0xb0, 0xc1, 0x91, 0x12, 0x66, 0xf7, 0xa2, 0x8c, 0x5f, 0x04, 0x94, 0x23,
0xd8, 0x08, 0x11, 0xfa, 0x9f, 0xb3, 0x50, 0x8e, 0xa9, 0x22, 0x48, 0xae, 0x69, 0xc0, 0x4c, 0x9b,
0x8e, 0xa9, 0xef, 0xba, 0x4e, 0x98, 0xe3, 0x8a, 0x20, 0x5e, 0x86, 0x34, 0x51, 0xc2, 0xa2, 0x77,
0x4c, 0x69, 0x30, 0x45, 0xeb, 0x28, 0x46, 0x25, 0xa4, 0x9d, 0xd1, 0x60, 0x4a, 0x3e, 0x00, 0x2d,
0x82, 0x78, 0x3e, 0xb3, 0x6c, 0xd1, 0xf9, 0x64, 0x7f, 0xae, 0x85, 0xf4, 0x41, 0x48, 0x16, 0x05,
0x5e, 0x26, 0x99, 0xe9, 0x51, 0x6b, 0x62, 0xda, 0xc2, 0x8a, 0x72, 0x5e, 0x55, 0x25, 0x7d, 0x40,
0xad, 0xc9, 0x65, 0x40, 0x39, 0xf9, 0x04, 0x9e, 0x25, 0x86, 0xda, 0x04, 0x5c, 0x66, 0x31, 0xf1,
0xe3, 0xa9, 0x36, 0x3e, 0xf2, 0x1c, 0x14, 0xd1, 0x31, 0xcc, 0xb1, 0xcf, 0x28, 0x67, 0x93, 0x30,
0x8f, 0x2b, 0x82, 0xd6, 0x96, 0x24, 0x52, 0x87, 0x22, 0xbb, 0xf3, 0x2c, 0x9f, 0x4d, 0xb0, 0x63,
0x94, 0x8c, 0xe8, 0x53, 0x1c, 0x0e, 0xb8, 0xeb, 0xd3, 0x5b, 0x66, 0x3a, 0xd4, 0x66, 0xe1, 0x88,
0x52, 0x09, 0x69, 0x3d, 0x6a, 0x33, 0xfd, 0x2d, 0xd8, 0xfd, 0x8a, 0xf1, 0x0b, 0xeb, 0xbb, 0xb9,
0x35, 0xb1, 0xf8, 0xfd, 0x80, 0xfa, 0x74, 0x51, 0x05, 0xff, 0x5a, 0x80, 0xad, 0x34, 0x8b, 0x71,
0xe6, 0x8b, 0x0e, 0x54, 0xf0, 0xe7, 0x33, 0x16, 0x79, 0x67, 0xd1, 0x31, 0x63, 0xb0, 0x31, 0x9f,
0x31, 0x43, 0x82, 0xc8, 0x97, 0xb0, 0xb7, 0x08, 0x31, 0x5f, 0xf4, 0xc0, 0x80, 0x72, 0xd3, 0x63,
0xbe, 0xf9, 0x5a, 0x74, 0x7a, 0xb4, 0x3e, 0x66, 0xa5, 0x8c, 0x36, 0x83, 0x72, 0x11, 0x71, 0x03,
0xe6, 0xbf, 0x12, 0x6c, 0xf2, 0x3e, 0x68, 0xc9, 0x51, 0xd1, 0xf4, 0x3c, 0x1b, 0x3d, 0x91, 0x8f,
0xab, 0x99, 0xb0, 0x97, 0x67, 0x93, 0x8f, 0x41, 0xec, 0x07, 0x66, 0xca, 0xc2, 0x9e, 0x1d, 0x26,
0xbd, 0x90, 0xb1, 0x58, 0x1a, 0x04, 0xfc, 0x73, 0x68, 0xac, 0x5e, 0x36, 0xf0, 0x54, 0x01, 0x4f,
0x6d, 0xaf, 0x58, 0x38, 0xc4, 0xd9, 0xf4, 0x46, 0x21, 0x3c, 0xb8, 0x81, 0xf8, 0xc5, 0x46, 0x21,
0x72, 0xe6, 0x03, 0xd8, 0x4c, 0x8d, 0xb0, 0x08, 0x2c, 0x22, 0x50, 0x4d, 0x8c, 0xb1, 0x71, 0x7a,
0x2d, 0x8f, 0xff, 0xa5, 0xd5, 0xe3, 0xff, 0x11, 0x6c, 0x45, 0x83, 0xcb, 0x35, 0x1d, 0x7f, 0xeb,
0xde, 0xdc, 0x98, 0x01, 0x1b, 0x63, 0x51, 0xce, 0x1b, 0x9b, 0x21, 0xeb, 0xa5, 0xe4, 0x0c, 0xd9,
0x98, 0x34, 0xa0, 0x44, 0xe7, 0xdc, 0x15, 0x3e, 0xc2, 0x46, 0x5c, 0x32, 0xe2, 0x6f, 0x21, 0x2b,
0xfa, 0x6d, 0x5e, 0xcf, 0x27, 0xb7, 0x4c, 0x96, 0x8b, 0x8a, 0x94, 0x15, 0xb1, 0x5e, 0x22, 0x47,
0xe8, 0xf9, 0x19, 0xec, 0x3e, 0xc0, 0x73, 0xea, 0x73, 0xd4, 0x40, 0x91, 0x36, 0x5b, 0x3a, 0x25,
0xd8, 0x42, 0x8d, 0x0f, 0x81, 0x08, 0x8e, 0x29, 0x4c, 0x62, 0x39, 0xe6, 0xcd, 0xcc, 0xba, 0x9d,
0x72, 0x9c, 0x43, 0xf2, 0x46, 0x4d, 0x70, 0x2e, 0xe9, 0x5d, 0xd7, 0x39, 0x45, 0xf2, 0xaa, 0x4e,
0xa7, 0x86, 0x3e, 0xff, 0xa1, 0x4e, 0x57, 0x4b, 0xc5, 0x86, 0xc4, 0xe9, 0x7f, 0xc9, 0x40, 0x35,
0x15, 0x9c, 0x58, 0xa4, 0xe4, 0x9e, 0x66, 0x86, 0x93, 0x40, 0xde, 0x28, 0x87, 0x94, 0xee, 0x84,
0x1c, 0x85, 0xe3, 0x66, 0x16, 0x67, 0xc2, 0xc6, 0xea, 0x08, 0x4f, 0xcc, 0x9d, 0x1f, 0x03, 0xb1,
0x9c, 0xb1, 0x6b, 0x8b, 0x18, 0xe2, 0x53, 0x9f, 0x05, 0x53, 0x77, 0x36, 0xc1, 0x38, 0xad, 0x1a,
0x9b, 0x11, 0x67, 0x14, 0x31, 0x04, 0x3c, 0x5e, 0x0d, 0x17, 0xf0, 0xbc, 0x84, 0x47, 0x9c, 0x18,
0xae, 0x7f, 0x03, 0xbb, 0xc3, 0x75, 0x59, 0x4a, 0xbe, 0x00, 0xf0, 0xe2, 0xdc, 0xc4, 0x97, 0x54,
0x8e, 0xf7, 0x1e, 0x2a, 0xbc, 0xc8, 0x5f, 0x23, 0x81, 0xd7, 0xf7, 0xa0, 0xb1, 0x4a, 0xb4, 0x2c,
0xc4, 0xfa, 0x33, 0xd8, 0x1a, 0xce, 0x6f, 0x6f, 0xd9, 0xd2, 0x44, 0x76, 0x0e, 0x4f, 0xd3, 0xe4,
0xb0, 0x6e, 0x1f, 0x43, 0x29, 0xda, 0x8f, 0xc3, 0xda, 0xb0, 0xb3, 0x50, 0x24, 0xf5, 0x17, 0x82,
0x51, 0x0c, 0x97, 0xe5, 0xc3, 0x17, 0x50, 0x8a, 0x66, 0x78, 0xa2, 0x40, 0xe9, 0xa2, 0xdf, 0x1f,
0x98, 0xfd, 0xab, 0x91, 0xf6, 0x84, 0x54, 0xa0, 0x88, 0x5f, 0xdd, 0x9e, 0x96, 0x39, 0x0c, 0xa0,
0x1c, 0x8f, 0xf0, 0xa4, 0x0a, 0xe5, 0x6e, 0xaf, 0x3b, 0xea, 0xb6, 0x46, 0x9d, 0x13, 0xed, 0x09,
0x79, 0x06, 0x9b, 0x03, 0xa3, 0xd3, 0xbd, 0x6c, 0x7d, 0xd5, 0x31, 0x8d, 0xce, 0xab, 0x4e, 0xeb,
0xa2, 0x73, 0xa2, 0x65, 0x08, 0x01, 0xf5, 0x6c, 0x74, 0xd1, 0x36, 0x07, 0x57, 0x2f, 0x2f, 0xba,
0xc3, 0xb3, 0xce, 0x89, 0x96, 0x15, 0x32, 0x87, 0x57, 0xed, 0x76, 0x67, 0x38, 0xd4, 0x72, 0x04,
0x60, 0xe3, 0xb4, 0xd5, 0x15, 0xe0, 0x3c, 0xd9, 0x82, 0x5a, 0xb7, 0xf7, 0xaa, 0xdf, 0x6d, 0x77,
0xcc, 0x61, 0x67, 0x34, 0x12, 0xc4, 0xc2, 0xe1, 0x7f, 0x32, 0x50, 0x4d, 0x6d, 0x01, 0x64, 0x07,
0xb6, 0xc4, 0x91, 0x2b, 0x43, 0xdc, 0xd4, 0x1a, 0xf6, 0x7b, 0x66, 0xaf, 0xdf, 0xeb, 0x68, 0x4f,
0xc8, 0x5b, 0xb0, 0xb3, 0xc4, 0xe8, 0x9f, 0x9e, 0xb6, 0xcf, 0x5a, 0x42, 0x79, 0xd2, 0x80, 0xed,
0x25, 0xe6, 0xa8, 0x7b, 0xd9, 0x11, 0xaf, 0xcc, 0x92, 0x7d, 0xd8, 0x5b, 0xe2, 0x0d, 0xbf, 0xee,
0x74, 0x06, 0x31, 0x22, 0x47, 0x5e, 0xc0, 0xf3, 0x25, 0x44, 0xb7, 0x37, 0xbc, 0x3a, 0x3d, 0xed,
0xb6, 0xbb, 0x9d, 0xde, 0xc8, 0x7c, 0xd5, 0xba, 0xb8, 0xea, 0x68, 0x79, 0xb2, 0x07, 0xf5, 0xe5,
0x4b, 0x3a, 0x97, 0x83, 0xbe, 0xd1, 0x32, 0xbe, 0xd1, 0x0a, 0xe4, 0x5d, 0x78, 0xe7, 0x81, 0x90,
0x76, 0xdf, 0x30, 0x3a, 0xed, 0x91, 0xd9, 0xba, 0xec, 0x5f, 0xf5, 0x46, 0xda, 0xc6, 0x61, 0x53,
0x4c, 0xda, 0x4b, 0x01, 0x2e, 0x4c, 0x76, 0xd5, 0xfb, 0x69, 0xaf, 0xff, 0x75, 0x4f, 0x7b, 0x22,
0x2c, 0x3f, 0x3a, 0x33, 0x3a, 0xc3, 0xb3, 0xfe, 0xc5, 0x89, 0x96, 0x39, 0xfe, 0x67, 0x59, 0x6e,
0x79, 0x6d, 0xfc, 0x5f, 0x89, 0x18, 0x50, 0x0c, 0xdd, 0x4c, 0xd6, 0x39, 0xbe, 0xf1, 0x2c, 0x35,
0xa9, 0xc7, 0x91, 0xb6, 0xf3, 0x9b, 0x7f, 0xfc, 0xeb, 0xf7, 0xd9, 0x4d, 0x5d, 0x69, 0xbe, 0xfe,
0xa4, 0x29, 0x10, 0x4d, 0x77, 0xce, 0x3f, 0xcf, 0x1c, 0x92, 0x3e, 0x6c, 0xc8, 0x7f, 0x13, 0xc8,
0x76, 0x4a, 0x64, 0xfc, 0xf7, 0xc2, 0x3a, 0x89, 0xdb, 0x28, 0x51, 0xd3, 0x2b, 0xb1, 0x44, 0xcb,
0x11, 0x02, 0x3f, 0x83, 0x62, 0xb8, 0xab, 0x26, 0x94, 0x4c, 0x6f, 0xaf, 0x8d, 0x55, 0xeb, 0xc4,
0x8f, 0x33, 0xe4, 0xe7, 0x50, 0x8e, 0x37, 0x11, 0xb2, 0x9b, 0xc8, 0xb1, 0x74, 0x7e, 0x34, 0x1a,
0xab, 0x58, 0x69, 0xb5, 0x88, 0x1a, 0xab, 0x85, 0x5b, 0x0a, 0xb9, 0x92, 0x79, 0x20, 0xb6, 0x14,
0x52, 0x4f, 0x5d, 0x9f, 0x58, 0x5c, 0x56, 0x2a, 0xa6, 0x37, 0x50, 0xe4, 0x53, 0x42, 0x52, 0x22,
0x9b, 0xdf, 0x5b, 0x93, 0x5f, 0x92, 0x5f, 0x80, 0x12, 0x3a, 0x00, 0x77, 0x09, 0xb2, 0x30, 0x56,
0x72, 0xe1, 0x69, 0x2c, 0x1e, 0xb3, 0xbc, 0x75, 0xac, 0x90, 0xee, 0xce, 0x79, 0x93, 0xa3, 0xb4,
0xeb, 0x58, 0x3a, 0xce, 0xa8, 0x09, 0xe9, 0xc9, 0x69, 0x3f, 0x2d, 0x3d, 0x35, 0xcd, 0xea, 0xfb,
0x28, 0xbd, 0x41, 0xea, 0x29, 0xe9, 0xdf, 0x09, 0x4c, 0xf3, 0x7b, 0x6a, 0x73, 0xf1, 0x02, 0x55,
0x8c, 0x28, 0xe8, 0xf2, 0x47, 0xdf, 0xb0, 0xb0, 0xda, 0xd2, 0xee, 0xa6, 0xef, 0xe2, 0x25, 0x5b,
0x64, 0x33, 0x11, 0x0a, 0xf1, 0x0b, 0x16, 0xd2, 0x1f, 0x7d, 0x43, 0x52, 0x7a, 0xfa, 0x09, 0xef,
0xa0, 0xf4, 0x5d, 0xb2, 0x93, 0x94, 0x9e, 0x7c, 0xc1, 0x37, 0x50, 0x15, 0x77, 0x44, 0x43, 0x6a,
0x90, 0x88, 0xe4, 0xd4, 0x24, 0xdc, 0xd8, 0x79, 0x40, 0x4f, 0x67, 0x07, 0xa9, 0xe1, 0x15, 0x01,
0xe5, 0x4d, 0x39, 0xfd, 0x12, 0x0e, 0xe4, 0xe1, 0xfc, 0x46, 0xf4, 0x58, 0xce, 0xda, 0xe1, 0xae,
0xf1, 0x68, 0x8b, 0xd0, 0xf7, 0xf0, 0xc2, 0x6d, 0xf2, 0x14, 0x2f, 0x8c, 0x00, 0x4d, 0x4f, 0xca,
0xff, 0x15, 0x90, 0xe1, 0x63, 0xb7, 0xae, 0x6d, 0x56, 0x8d, 0x77, 0x1f, 0xc5, 0xa4, 0x0d, 0xaa,
0xaf, 0xbc, 0x5c, 0xa4, 0x30, 0x03, 0x25, 0xd9, 0x7f, 0xc8, 0xe2, 0x2d, 0x2b, 0xba, 0x55, 0xe3,
0xed, 0x35, 0xdc, 0xf0, 0xb6, 0x3a, 0xde, 0x46, 0x88, 0x26, 0x6e, 0x13, 0x83, 0x48, 0x33, 0x90,
0xb0, 0xeb, 0x0d, 0xfc, 0x03, 0xfc, 0xd3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x03, 0x91,
0x2d, 0x37, 0x17, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

14
looprpc/client.proto
Unescape Escape View File

@ -783,25 +783,25 @@ message LiquidityParameters {
uint64 failure_backoff_sec = 9;
/*
Set to true to enable automatic dispatch of loop out swaps. All swaps will
be limited to the fee categories set by these parameters, and total
expenditure will be limited to the auto out budget.
Set to true to enable automatic dispatch of swaps. All swaps will be limited
to the fee categories set by these parameters, and total expenditure will
be limited to the autoloop budget.
*/
bool auto_loop_out = 10;
bool autoloop = 10;
/*
The total budget for automatically dispatched swaps since the budget start
time, expressed in satoshis.
*/
uint64 auto_out_budget_sat = 11;
uint64 autoloop_budget_sat = 11;
/*
The start time for auto-out budget, expressed as a unix timestamp in
The start time for autoloop budget, expressed as a unix timestamp in
seconds. If this value is 0, the budget will be applied for all
automatically dispatched swaps. Swaps that were completed before this date
will not be included in budget calculations.
*/
uint64 auto_out_budget_start_sec = 12;
uint64 autoloop_budget_start_sec = 12;
/*
The maximum number of automatically dispatched swaps that we allow to be in

10
looprpc/client.swagger.json
Unescape Escape View File

@ -494,20 +494,20 @@
"format": "uint64",
"description": "The amount of time we require pass since a channel was part of a failed\nswap due to off chain payment failure until it will be considered for swap\nsuggestions again, expressed in seconds."
},
"auto_loop_out": {
"autoloop": {
"type": "boolean",
"format": "boolean",
"description": "Set to true to enable automatic dispatch of loop out swaps. All swaps will\nbe limited to the fee categories set by these parameters, and total\nexpenditure will be limited to the auto out budget."
"description": "Set to true to enable automatic dispatch of swaps. All swaps will be limited \nto the fee categories set by these parameters, and total expenditure will \nbe limited to the autoloop budget."
},
"auto_out_budget_sat": {
"autoloop_budget_sat": {
"type": "string",
"format": "uint64",
"description": "The total budget for automatically dispatched swaps since the budget start\ntime, expressed in satoshis."
},
"auto_out_budget_start_sec": {
"autoloop_budget_start_sec": {
"type": "string",
"format": "uint64",
"description": "The start time for auto-out budget, expressed as a unix timestamp in\nseconds. If this value is 0, the budget will be applied for all\nautomatically dispatched swaps. Swaps that were completed before this date\nwill not be included in budget calculations."
"description": "The start time for autoloop budget, expressed as a unix timestamp in\nseconds. If this value is 0, the budget will be applied for all\nautomatically dispatched swaps. Swaps that were completed before this date\nwill not be included in budget calculations."
},
"auto_max_in_flight": {
"type": "string",

5
release_notes.md
Unescape Escape View File

@ -20,5 +20,10 @@ This file tracks release notes for the loop client.
unlocked. Previous versions would exit with an error.
#### Breaking Changes
* The `AutoOut`, `AutoOutBudgetSat` and `AutoOutBudgetStartSec` fields in the
`LiquidityParameters` message used in the experimental autoloop API have
been renamed to `Autoloop`, `AutoloopBudgetSat` and `AutoloopBudgetStartSec`.
* The `autoout` flag for enabling automatic dispatch of loop out swaps has been
renamed to `autoloop` so that it can cover loop out and loop in.
#### Bug Fixes

Write Preview
Loading…
Cancel
Save