From 5f2f6f884bd2bcc321edc94adcf58c9aa431d8c7 Mon Sep 17 00:00:00 2001 From: Scott Date: Tue, 26 Sep 2023 16:16:31 +1000 Subject: [PATCH] Binance,Okx: Add Leverage, MarginType, Positions and CollateralMode support (#1220) * init * surprise train commit * basic distinctions * the terms of binance are confusing * renames and introduction of allocatedMargin * add new margin funcs * pulling out wires * implement proper getposition stuff * bad coding day * investigate order manager next * a broken mess, but a progressing one * finally completes some usdtmargined stuff * coinMfutures eludes me * expand to okx * imports fix * completes okx wrapper implementations * cleans and polishes before rpc implementations * rpc setup, order manager features, exch features * more rpc, collateral and margin things * mini test * looking at rpc response, expansion of features * reorganising before the storm * changing how futures requests work * cleanup and tests of cli usage * remove silly client side logic * cleanup * collateral package, typo fix, margin err, rpc derive * uses convert.StringToFloat ONLY ON STRUCTS FROM THIS PR * fix binance order history bug * niteroos * adds new funcs to exchange standards testing * more post merge fixes * fix binance * replace simepletimeformat * fix for merge * merge fixes * micro fixes * order side now required for leverage * fix up the rest * global -> portfolio collateral * Update exchanges/collateral/collateral_test.go Co-authored-by: Adrian Gallagher * adds fields and todos * rm field redundancy * lint fix oopsie daisy * fixes panic, expands error and cli explanations (sorry shaz) * ensures casing is appropriate for underlying * Adds a shiny TODO --------- Co-authored-by: Adrian Gallagher --- backtester/data/kline/live/live_test.go | 6 +- backtester/engine/setup.go | 12 +- .../eventhandlers/exchange/exchange_test.go | 7 +- cmd/exchange_wrapper_issues/main.go | 13 +- .../exchange_wrapper_standards_test.go | 63 +- cmd/gctcli/commands.go | 18 + cmd/gctcli/futures.go | 1221 ++- common/common.go | 2 +- common/convert/convert.go | 8 +- config/config.go | 3 + config/config_types.go | 2 + currency/manager.go | 9 +- currency/manager_test.go | 4 +- currency/pair.go | 10 + currency/pair_test.go | 22 + engine/engine.go | 5 +- engine/helpers.go | 8 +- engine/order_manager.go | 65 +- engine/order_manager_test.go | 61 +- engine/order_manager_types.go | 1 + engine/rpcserver.go | 913 +- engine/rpcserver_test.go | 529 +- engine/websocketroutine_manager_test.go | 3 +- exchanges/asset/asset.go | 3 +- exchanges/binance/binance.go | 3 + exchanges/binance/binance_cfutures.go | 60 +- exchanges/binance/binance_live_test.go | 1 + exchanges/binance/binance_test.go | 267 +- exchanges/binance/binance_types.go | 2 +- exchanges/binance/binance_ufutures.go | 79 +- exchanges/binance/binance_wrapper.go | 584 +- exchanges/binance/cfutures_types.go | 83 +- exchanges/binance/ratelimit.go | 6 + exchanges/binance/type_convert.go | 6 +- exchanges/binance/ufutures_types.go | 125 +- exchanges/bybit/bybit.go | 2 +- exchanges/bybit/bybit_cfutures.go | 30 +- exchanges/bybit/bybit_futures.go | 12 +- exchanges/bybit/bybit_test.go | 2 +- exchanges/bybit/bybit_ufutures.go | 18 +- exchanges/bybit/bybit_usdcfutures.go | 26 +- exchanges/collateral/collateral.go | 71 + exchanges/collateral/collateral_test.go | 180 + exchanges/collateral/collateral_types.go | 85 + exchanges/exchange.go | 171 +- exchanges/exchange_test.go | 61 +- exchanges/exchange_types.go | 11 +- exchanges/interfaces.go | 22 +- exchanges/margin/margin.go | 67 + exchanges/margin/margin_test.go | 162 + exchanges/margin/margin_types.go | 61 + exchanges/okx/okx.go | 34 +- exchanges/okx/okx_test.go | 696 +- exchanges/okx/okx_types.go | 162 +- exchanges/okx/okx_wrapper.go | 465 +- exchanges/order/futures_types.go | 138 +- exchanges/order/order_test.go | 6 +- exchanges/order/order_types.go | 9 + exchanges/order/orders.go | 6 +- gctrpc/buf.lock | 6 +- gctrpc/rpc.pb.go | 9319 ++++++++++------- gctrpc/rpc.pb.gw.go | 639 +- gctrpc/rpc.proto | 201 +- gctrpc/rpc.swagger.json | 628 +- gctrpc/rpc_grpc.pb.go | 289 +- gctscript/wrappers/gct/gctwrapper_test.go | 3 +- testdata/http_mock/binance/binance.json | 83 +- 67 files changed, 12476 insertions(+), 5393 deletions(-) create mode 100644 exchanges/collateral/collateral.go create mode 100644 exchanges/collateral/collateral_test.go create mode 100644 exchanges/collateral/collateral_types.go create mode 100644 exchanges/margin/margin.go create mode 100644 exchanges/margin/margin_test.go diff --git a/backtester/data/kline/live/live_test.go b/backtester/data/kline/live/live_test.go index 26f8abb060e..089200877fc 100644 --- a/backtester/data/kline/live/live_test.go +++ b/backtester/data/kline/live/live_test.go @@ -14,7 +14,7 @@ import ( gctkline "github.com/thrasher-corp/gocryptotrader/exchanges/kline" ) -const testExchange = "binanceus" +const testExchange = "okx" func TestLoadCandles(t *testing.T) { t.Parallel() @@ -73,7 +73,9 @@ func TestLoadTrades(t *testing.T) { ConfigFormat: pFormat, } var data *gctkline.Item - data, err = LoadData(context.Background(), time.Now().Add(-interval.Duration()*10), exch, common.DataTrade, interval.Duration(), cp, currency.EMPTYPAIR, a, true) + // start is 10 mins in the past to ensure there are some trades to pull from the exchange + start := time.Now().Add(-time.Minute * 10) + data, err = LoadData(context.Background(), start, exch, common.DataTrade, interval.Duration(), cp, currency.EMPTYPAIR, a, true) if err != nil { t.Fatal(err) } diff --git a/backtester/engine/setup.go b/backtester/engine/setup.go index 33c9ed04b46..81dd99a099e 100644 --- a/backtester/engine/setup.go +++ b/backtester/engine/setup.go @@ -205,13 +205,11 @@ func (bt *BackTest) SetupFromConfig(cfg *config.Config, templatePath, output str } } - bt.orderManager, err = engine.SetupOrderManager( - bt.exchangeManager, - &engine.CommunicationManager{}, - &sync.WaitGroup{}, - verbose, - trackFuturesPositions, - 0) + bt.orderManager, err = engine.SetupOrderManager(bt.exchangeManager, &engine.CommunicationManager{}, &sync.WaitGroup{}, &gctconfig.OrderManager{ + Verbose: verbose, + ActivelyTrackFuturesPositions: trackFuturesPositions, + RespectOrderHistoryLimits: convert.BoolPtr(true), + }) if err != nil { return err } diff --git a/backtester/eventhandlers/exchange/exchange_test.go b/backtester/eventhandlers/exchange/exchange_test.go index e298fc79784..6a3c4deb409 100644 --- a/backtester/eventhandlers/exchange/exchange_test.go +++ b/backtester/eventhandlers/exchange/exchange_test.go @@ -17,6 +17,7 @@ import ( "github.com/thrasher-corp/gocryptotrader/backtester/funding" gctcommon "github.com/thrasher-corp/gocryptotrader/common" "github.com/thrasher-corp/gocryptotrader/common/convert" + gctconfig "github.com/thrasher-corp/gocryptotrader/config" "github.com/thrasher-corp/gocryptotrader/currency" "github.com/thrasher-corp/gocryptotrader/engine" exchange "github.com/thrasher-corp/gocryptotrader/exchanges" @@ -198,7 +199,7 @@ func TestPlaceOrder(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } bot.ExchangeManager = em - bot.OrderManager, err = engine.SetupOrderManager(em, &engine.CommunicationManager{}, &bot.ServicesWG, false, false, 0) + bot.OrderManager, err = engine.SetupOrderManager(em, &engine.CommunicationManager{}, &bot.ServicesWG, &gctconfig.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("received '%v' expected '%v'", err, nil) } @@ -256,7 +257,7 @@ func TestExecuteOrder(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } bot.ExchangeManager = em - bot.OrderManager, err = engine.SetupOrderManager(em, &engine.CommunicationManager{}, &bot.ServicesWG, false, false, 0) + bot.OrderManager, err = engine.SetupOrderManager(em, &engine.CommunicationManager{}, &bot.ServicesWG, &gctconfig.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("received: %v, expected: %v", err, nil) } @@ -392,7 +393,7 @@ func TestExecuteOrderBuySellSizeLimit(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } bot.ExchangeManager = em - bot.OrderManager, err = engine.SetupOrderManager(em, &engine.CommunicationManager{}, &bot.ServicesWG, false, false, 0) + bot.OrderManager, err = engine.SetupOrderManager(em, &engine.CommunicationManager{}, &bot.ServicesWG, &gctconfig.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("received: %v, expected: %v", err, nil) } diff --git a/cmd/exchange_wrapper_issues/main.go b/cmd/exchange_wrapper_issues/main.go index 6178418af99..829d8bc2d90 100644 --- a/cmd/exchange_wrapper_issues/main.go +++ b/cmd/exchange_wrapper_issues/main.go @@ -23,6 +23,7 @@ import ( exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/deposit" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" @@ -920,7 +921,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config) Pair: p, } var positionSummaryResponse *order.PositionSummary - positionSummaryResponse, err = e.GetPositionSummary(context.TODO(), positionSummaryRequest) + positionSummaryResponse, err = e.GetFuturesPositionSummary(context.TODO(), positionSummaryRequest) msg = "" if err != nil { msg = err.Error() @@ -928,7 +929,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config) } responseContainer.EndpointResponses = append(responseContainer.EndpointResponses, EndpointResponse{ SentParams: jsonifyInterface([]interface{}{positionSummaryRequest}), - Function: "GetPositionSummary", + Function: "GetFuturesPositionSummary", Error: msg, Response: jsonifyInterface([]interface{}{positionSummaryResponse}), }) @@ -968,7 +969,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config) LockedCollateral: decimal.NewFromInt(1337), UnrealisedPNL: decimal.NewFromInt(1337), } - var scaleCollateralResponse *order.CollateralByCurrency + var scaleCollateralResponse *collateral.ByCurrency scaleCollateralResponse, err = e.ScaleCollateral(context.TODO(), collateralCalculator) msg = "" if err != nil { @@ -999,13 +1000,13 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config) Response: jsonifyInterface([]interface{}{calculateTotalCollateralResponse}), }) - var futuresPositionsResponse []order.PositionDetails + var futuresPositionsResponse []order.PositionResponse futuresPositionsRequest := &order.PositionsRequest{ Asset: assetTypes[i], Pairs: currency.Pairs{p}, StartDate: time.Now().Add(-time.Hour), } - futuresPositionsResponse, err = e.GetFuturesPositions(context.TODO(), futuresPositionsRequest) + futuresPositionsResponse, err = e.GetFuturesPositionOrders(context.TODO(), futuresPositionsRequest) msg = "" if err != nil { msg = err.Error() @@ -1013,7 +1014,7 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config) } responseContainer.EndpointResponses = append(responseContainer.EndpointResponses, EndpointResponse{ SentParams: jsonifyInterface([]interface{}{futuresPositionsRequest}), - Function: "GetFuturesPositions", + Function: "GetFuturesPositionOrders", Error: msg, Response: jsonifyInterface([]interface{}{futuresPositionsResponse}), }) diff --git a/cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go b/cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go index 76bd3d2d833..6d5b1d88d6b 100644 --- a/cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go +++ b/cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go @@ -16,8 +16,10 @@ import ( exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/deposit" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/exchanges/request" "github.com/thrasher-corp/gocryptotrader/portfolio/banking" @@ -263,13 +265,21 @@ var ( stringParam = reflect.TypeOf((*string)(nil)).Elem() feeBuilderParam = reflect.TypeOf((**exchange.FeeBuilder)(nil)).Elem() credentialsParam = reflect.TypeOf((**account.Credentials)(nil)).Elem() + orderSideParam = reflect.TypeOf((*order.Side)(nil)).Elem() + collateralModeParam = reflect.TypeOf((*collateral.Mode)(nil)).Elem() + marginTypeParam = reflect.TypeOf((*margin.Type)(nil)).Elem() + int64Param = reflect.TypeOf((*int64)(nil)).Elem() + float64Param = reflect.TypeOf((*float64)(nil)).Elem() // types with asset in params - assetParam = reflect.TypeOf((*asset.Item)(nil)).Elem() - orderSubmitParam = reflect.TypeOf((**order.Submit)(nil)).Elem() - orderModifyParam = reflect.TypeOf((**order.Modify)(nil)).Elem() - orderCancelParam = reflect.TypeOf((**order.Cancel)(nil)).Elem() - orderCancelsParam = reflect.TypeOf((*[]order.Cancel)(nil)).Elem() - getOrdersRequestParam = reflect.TypeOf((**order.MultiOrderRequest)(nil)).Elem() + assetParam = reflect.TypeOf((*asset.Item)(nil)).Elem() + orderSubmitParam = reflect.TypeOf((**order.Submit)(nil)).Elem() + orderModifyParam = reflect.TypeOf((**order.Modify)(nil)).Elem() + orderCancelParam = reflect.TypeOf((**order.Cancel)(nil)).Elem() + orderCancelsParam = reflect.TypeOf((*[]order.Cancel)(nil)).Elem() + getOrdersRequestParam = reflect.TypeOf((**order.MultiOrderRequest)(nil)).Elem() + positionChangeRequestParam = reflect.TypeOf((**margin.PositionChangeRequest)(nil)).Elem() + positionSummaryRequestParam = reflect.TypeOf((**order.PositionSummaryRequest)(nil)).Elem() + positionsRequestParam = reflect.TypeOf((**order.PositionsRequest)(nil)).Elem() ) // generateMethodArg determines the argument type and returns a pre-made @@ -459,6 +469,39 @@ func generateMethodArg(ctx context.Context, t *testing.T, argGenerator *MethodAr AssetType: argGenerator.AssetParams.Asset, Pairs: currency.Pairs{argGenerator.AssetParams.Pair}, }) + case argGenerator.MethodInputType.AssignableTo(marginTypeParam): + input = reflect.ValueOf(margin.Isolated) + case argGenerator.MethodInputType.AssignableTo(collateralModeParam): + input = reflect.ValueOf(collateral.SingleMode) + case argGenerator.MethodInputType.AssignableTo(positionChangeRequestParam): + input = reflect.ValueOf(&margin.PositionChangeRequest{ + Exchange: argGenerator.Exchange.GetName(), + Pair: argGenerator.AssetParams.Pair, + Asset: argGenerator.AssetParams.Asset, + MarginType: margin.Isolated, + OriginalAllocatedMargin: 1337, + NewAllocatedMargin: 1338, + }) + case argGenerator.MethodInputType.AssignableTo(positionSummaryRequestParam): + input = reflect.ValueOf(&order.PositionSummaryRequest{ + Asset: argGenerator.AssetParams.Asset, + Pair: argGenerator.AssetParams.Pair, + Direction: order.Buy, + }) + case argGenerator.MethodInputType.AssignableTo(positionsRequestParam): + input = reflect.ValueOf(&order.PositionsRequest{ + Asset: argGenerator.AssetParams.Asset, + Pairs: currency.Pairs{argGenerator.AssetParams.Pair}, + StartDate: argGenerator.Start, + EndDate: argGenerator.End, + RespectOrderHistoryLimits: true, + }) + case argGenerator.MethodInputType.AssignableTo(orderSideParam): + input = reflect.ValueOf(order.Long) + case argGenerator.MethodInputType.AssignableTo(int64Param): + input = reflect.ValueOf(1337) + case argGenerator.MethodInputType.AssignableTo(float64Param): + input = reflect.ValueOf(13.37) default: input = reflect.Zero(argGenerator.MethodInputType) } @@ -509,6 +552,14 @@ var excludedMethodNames = map[string]struct{}{ "CalculateTotalCollateral": {}, "ScaleCollateral": {}, "GetPositionSummary": {}, + "GetFuturesPositionSummary": {}, + "GetFuturesPositionOrders": {}, + "SetCollateralMode": {}, + "GetCollateralMode": {}, + "SetLeverage": {}, + "GetLeverage": {}, + "SetMarginType": {}, + "ChangePositionMargin": {}, "GetLatestFundingRate": {}, } diff --git a/cmd/gctcli/commands.go b/cmd/gctcli/commands.go index e68638990b6..53c6cade8db 100644 --- a/cmd/gctcli/commands.go +++ b/cmd/gctcli/commands.go @@ -13,6 +13,7 @@ import ( "github.com/thrasher-corp/gocryptotrader/common" "github.com/thrasher-corp/gocryptotrader/currency" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" "github.com/thrasher-corp/gocryptotrader/gctrpc" "github.com/urfave/cli/v2" ) @@ -1420,6 +1421,11 @@ var submitOrderCommand = &cli.Command{ Name: "asset", Usage: "required asset type", }, + &cli.StringFlag{ + Name: "margintype", + Usage: "required asset type", + Required: false, + }, }, } @@ -1436,6 +1442,7 @@ func submitOrder(c *cli.Context) error { var price float64 var clientID string var assetType string + var marginType string if c.IsSet("exchange") { exchangeName = c.String("exchange") @@ -1510,11 +1517,22 @@ func submitOrder(c *cli.Context) error { assetType = c.Args().Get(7) } + if c.IsSet("margintype") { + marginType = c.String("margintype") + } else { + marginType = c.Args().Get(8) + } + assetType = strings.ToLower(assetType) if !validAsset(assetType) { return errInvalidAsset } + marginType = strings.ToLower(marginType) + if !margin.IsValidString(marginType) { + return margin.ErrInvalidMarginType + } + p, err := currency.NewPairDelimiter(currencyPair, pairDelimiter) if err != nil { return err diff --git a/cmd/gctcli/futures.go b/cmd/gctcli/futures.go index 5c1d4c93ebc..a614b91fa86 100644 --- a/cmd/gctcli/futures.go +++ b/cmd/gctcli/futures.go @@ -4,11 +4,12 @@ import ( "errors" "fmt" "strconv" - "strings" "time" "github.com/thrasher-corp/gocryptotrader/common" "github.com/thrasher-corp/gocryptotrader/currency" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/gctrpc" "github.com/urfave/cli/v2" @@ -95,88 +96,6 @@ var futuresCommands = &cli.Command{ }, }, }, - - { - Name: "getfuturespositions", - Aliases: []string{"positions", "p"}, - Usage: "will retrieve all futures positions in a timeframe, then calculate PNL based on that. Note, the dates have an impact on PNL calculations, ensure your start date is not after a new position is opened", - ArgsUsage: " ", - Action: getFuturesPositions, - Flags: []cli.Flag{ - &cli.StringFlag{ - Name: "exchange", - Aliases: []string{"e"}, - Usage: "the exchange to retrieve futures positions from", - }, - &cli.StringFlag{ - Name: "asset", - Aliases: []string{"a"}, - Usage: "the asset type of the currency pair, must be a futures type", - }, - &cli.StringFlag{ - Name: "pair", - Aliases: []string{"p"}, - Usage: "the currency pair", - }, - &cli.StringFlag{ - Name: "start", - Aliases: []string{"sd"}, - Usage: " rounded down to the nearest hour, ensure your starting position is within this window for accurate calculations", - Value: time.Now().AddDate(-1, 0, 0).Truncate(time.Hour).Format(time.DateTime), - Destination: &startTime, - }, - &cli.StringFlag{ - Name: "end", - Aliases: []string{"ed"}, - Usage: " rounded down to the nearest hour, ensure your last position is within this window for accurate calculations", - Value: time.Now().Format(time.DateTime), - Destination: &endTime, - }, - &cli.IntFlag{ - Name: "limit", - Aliases: []string{"l"}, - Usage: "the number of positions (not orders) to return", - Value: 86400, - Destination: &limit, - }, - &cli.StringFlag{ - Name: "status", - Aliases: []string{"s"}, - Usage: "limit return to position statuses - open, closed, any", - Value: "ANY", - }, - &cli.BoolFlag{ - Name: "overwrite", - Aliases: []string{"o"}, - Usage: "if true, will overwrite futures results for the provided exchange, asset, pair", - }, - &cli.BoolFlag{ - Name: "includeorderdetails", - Aliases: []string{"orders"}, - Usage: "includes all orders that make up a position in the response", - }, - &cli.BoolFlag{ - Name: "getpositionstats", - Aliases: []string{"stats"}, - Usage: "if true, will return extra stats on the position from the exchange", - }, - &cli.BoolFlag{ - Name: "getfundingdata", - Aliases: []string{"funding", "fd"}, - Usage: "if true, will return funding rate summary", - }, - &cli.BoolFlag{ - Name: "includefundingentries", - Aliases: []string{"allfunding", "af"}, - Usage: "if true, will return all funding rate entries - requires --getfundingdata", - }, - &cli.BoolFlag{ - Name: "includepredictedrate", - Aliases: []string{"predicted", "pr"}, - Usage: "if true, will return the predicted funding rate - requires --getfundingdata", - }, - }, - }, { Name: "getcollateral", Aliases: []string{"collateral", "c"}, @@ -243,8 +162,8 @@ var futuresCommands = &cli.Command{ &cli.StringFlag{ Name: "end", Aliases: []string{"ed"}, - Usage: " rounded down to the nearest hour", - Value: time.Now().Truncate(time.Hour).Format(time.DateTime), + Usage: "", + Value: time.Now().Format(time.DateTime), Destination: &endTime, }, &cli.StringFlag{ @@ -298,6 +217,277 @@ var futuresCommands = &cli.Command{ }, }, }, + { + Name: "getcollateralmode", + Aliases: []string{"gcm"}, + Usage: "gets the collateral mode for an exchange asset", + ArgsUsage: " ", + Action: getCollateralMode, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Aliases: []string{"e"}, + Usage: "the exchange to retrieve futures positions from", + }, + &cli.StringFlag{ + Name: "asset", + Aliases: []string{"a"}, + Usage: "the asset type of the currency pair, must be a futures type", + }, + }, + }, + { + Name: "setcollateralmode", + Aliases: []string{"scm"}, + Usage: "sets the collateral mode for an exchange asset", + ArgsUsage: " ", + Action: setCollateralMode, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Aliases: []string{"e"}, + Usage: "the exchange to retrieve futures positions from", + }, + &cli.StringFlag{ + Name: "asset", + Aliases: []string{"a"}, + Usage: "the asset type of the currency pair, must be a futures type", + }, + &cli.StringFlag{ + Name: "collateralmode", + Aliases: []string{"collateral", "cm", "c"}, + Usage: "the collateral mode type, such as 'single', 'multi' or 'global'", + }, + }, + }, + { + Name: "setleverage", + Aliases: []string{"sl"}, + Usage: "sets the initial leverage level for an exchange currency pair", + ArgsUsage: " ", + Action: setLeverage, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Aliases: []string{"e"}, + Usage: "the exchange to retrieve futures positions from", + }, + &cli.StringFlag{ + Name: "asset", + Aliases: []string{"a"}, + Usage: "the asset type of the currency pair, must be a futures type", + }, + &cli.StringFlag{ + Name: "pair", + Aliases: []string{"p"}, + Usage: "the currency pair", + }, + &cli.StringFlag{ + Name: "margintype", + Aliases: []string{"margin", "mt", "m"}, + Usage: "the margin type, such as 'isolated', 'multi' or 'cross'", + }, + &cli.Float64Flag{ + Name: "leverage", + Aliases: []string{"l"}, + Usage: "the level of leverage you want, increase it to lose your capital faster", + }, + &cli.StringFlag{ + Name: "orderside", + Aliases: []string{"side", "os", "o"}, + Usage: "optional - some exchanges distinguish between order side", + }, + }, + }, + { + Name: "getleverage", + Aliases: []string{"gl"}, + Usage: "gets the initial leverage level for an exchange currency pair", + ArgsUsage: " ", + Action: getLeverage, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Aliases: []string{"e"}, + Usage: "the exchange to retrieve futures positions from", + }, + &cli.StringFlag{ + Name: "asset", + Aliases: []string{"a"}, + Usage: "the asset type of the currency pair, must be a futures type", + }, + &cli.StringFlag{ + Name: "pair", + Aliases: []string{"p"}, + Usage: "the currency pair", + }, + &cli.StringFlag{ + Name: "margintype", + Aliases: []string{"margin", "mt", "m"}, + Usage: "the margin type, such as 'isolated', 'multi' or 'cross'", + }, + &cli.StringFlag{ + Name: "orderside", + Aliases: []string{"side", "os", "o"}, + Usage: "optional - some exchanges distinguish between order side", + }, + }, + }, + { + Name: "changepositionmargin", + Aliases: []string{"cpm"}, + Usage: "sets isolated margin levels for an existing position", + ArgsUsage: " ", + Action: changePositionMargin, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Aliases: []string{"e"}, + Usage: "the exchange to retrieve futures positions from", + }, + &cli.StringFlag{ + Name: "asset", + Aliases: []string{"a"}, + Usage: "the asset type of the currency pair, must be a futures type", + }, + &cli.StringFlag{ + Name: "pair", + Aliases: []string{"p"}, + Usage: "the currency pair", + }, + &cli.StringFlag{ + Name: "margintype", + Aliases: []string{"margin", "mt", "m"}, + Usage: "the margin type, most likely 'isolated'", + }, + &cli.Float64Flag{ + Name: "originalallocatedmargin", + Aliases: []string{"oac"}, + Usage: "the original allocated margin, is used by some exchanges to determine differences to apply", + }, + &cli.Float64Flag{ + Name: "newallocatedmargin", + Aliases: []string{"nac"}, + Usage: "the new allocated margin level you desire", + }, + &cli.StringFlag{ + Name: "marginside", + Aliases: []string{"side", "ms"}, + Usage: "optional - the margin side, typically 'buy' or 'sell'", + }, + }, + }, + { + Name: "getfuturespositionsummary", + Aliases: []string{"summary", "fps"}, + Usage: "return a summary of your futures position", + ArgsUsage: " ", + Action: getFuturesPositionSummary, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Aliases: []string{"e"}, + Usage: "the exchange to retrieve futures positions from", + }, + &cli.StringFlag{ + Name: "asset", + Aliases: []string{"a"}, + Usage: "the asset type of the currency pair, must be a futures type", + }, + &cli.StringFlag{ + Name: "pair", + Aliases: []string{"p"}, + Usage: "the currency pair", + }, + &cli.StringFlag{ + Name: "underlyingpair", + Aliases: []string{"up"}, + Usage: "optional - used to distinguish the underlying currency of a futures pair eg pair is BTCUSD-1337-C, the underlying pair could be BTC-USD, or if pair is LTCUSD-PERP the underlying pair could be LTC-USD", + }, + }, + }, + { + Name: "getfuturepositionorders", + Aliases: []string{"orders", "fpo"}, + Usage: "return a slice of orders that make up your position", + ArgsUsage: " ", + Action: getFuturePositionOrders, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Aliases: []string{"e"}, + Usage: "the exchange to retrieve futures positions from", + }, + &cli.StringFlag{ + Name: "asset", + Aliases: []string{"a"}, + Usage: "the asset type of the currency pair, must be a futures type", + }, + &cli.StringFlag{ + Name: "pair", + Aliases: []string{"p"}, + Usage: "the currency pair", + }, + &cli.StringFlag{ + Name: "start", + Aliases: []string{"sd"}, + Usage: " rounded down to the nearest hour", + Value: time.Now().AddDate(0, 0, -7).Truncate(time.Hour).Format(time.DateTime), + Destination: &startTime, + }, + &cli.StringFlag{ + Name: "end", + Aliases: []string{"ed"}, + Usage: "", + Value: time.Now().Format(time.DateTime), + Destination: &endTime, + }, + &cli.BoolFlag{ + Name: "respectorderhistorylimits", + Aliases: []string{"r"}, + Usage: "recommended true - if set to true, will not request orders beyond its API limits, preventing errors", + }, + &cli.StringFlag{ + Name: "underlyingpair", + Aliases: []string{"up"}, + Usage: "optional - the underlying currency pair", + }, + &cli.BoolFlag{ + Name: "syncwithordermanager", + Aliases: []string{"sync", "s"}, + Usage: "if true, will sync the orders with the order manager if supported", + }, + }, + }, + { + Name: "setmargintype", + Aliases: []string{"smt"}, + Usage: "sets the margin type for a exchange asset pair", + ArgsUsage: " ", + Action: setMarginType, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Aliases: []string{"e"}, + Usage: "the exchange to retrieve futures positions from", + }, + &cli.StringFlag{ + Name: "asset", + Aliases: []string{"a"}, + Usage: "the asset type of the currency pair, must be a futures type", + }, + &cli.StringFlag{ + Name: "pair", + Aliases: []string{"p"}, + Usage: "the currency pair", + }, + &cli.StringFlag{ + Name: "margintype", + Aliases: []string{"margin", "mt", "m"}, + Usage: "the margin type, such as 'isolated', 'multi' or 'cross'", + }, + }, + }, }, } @@ -483,217 +673,30 @@ func getAllManagedPositions(c *cli.Context) error { return nil } -func getFuturesPositions(c *cli.Context) error { +func getCollateral(c *cli.Context) error { if c.NArg() == 0 && c.NumFlags() == 0 { return cli.ShowSubcommandHelp(c) } var ( - exchangeName string - assetType string - currencyPair string - err error - includeOrderDetails bool - status string - overwrite bool - getFundingData bool - includeFundingEntries bool - getPositionsStats bool - includePredicted bool - s, e time.Time + exchangeName, assetType string + calculateOffline, includeBreakdown, includeZeroValues bool + err error ) if c.IsSet("exchange") { exchangeName = c.String("exchange") } else { exchangeName = c.Args().First() } - if c.IsSet("asset") { assetType = c.String("asset") } else { assetType = c.Args().Get(1) } - err = isFuturesAsset(assetType) if err != nil { return err } - if c.IsSet("pair") { - currencyPair = c.String("pair") - } else { - currencyPair = c.Args().Get(2) - } - if !validPair(currencyPair) { - return errInvalidPair - } - - p, err := currency.NewPairDelimiter(currencyPair, pairDelimiter) - if err != nil { - return err - } - - if !c.IsSet("start") { - if c.Args().Get(3) != "" { - startTime = c.Args().Get(3) - } - } - - if !c.IsSet("end") { - if c.Args().Get(4) != "" { - endTime = c.Args().Get(4) - } - } - if c.IsSet("limit") { - limit = c.Int("limit") - } else if c.Args().Get(5) != "" { - var limit64 int64 - limit64, err = strconv.ParseInt(c.Args().Get(5), 10, 64) - if err != nil { - return err - } - limit = int(limit64) - } - if limit <= 0 { - return errors.New("limit must be greater than 0") - } - - if c.IsSet("status") { - status = c.String("status") - } else if c.Args().Get(6) != "" { - status = c.Args().Get(6) - } - if !strings.EqualFold(status, "any") && - !strings.EqualFold(status, "open") && - !strings.EqualFold(status, "closed") && - status != "" { - return errors.New("unrecognised status") - } - - if c.IsSet("overwrite") { - overwrite = c.Bool("overwrite") - } else if c.Args().Get(7) != "" { - overwrite, err = strconv.ParseBool(c.Args().Get(7)) - if err != nil { - return err - } - } - - if c.IsSet("includeorderdetails") { - includeOrderDetails = c.Bool("includeorderdetails") - } else if c.Args().Get(8) != "" { - includeOrderDetails, err = strconv.ParseBool(c.Args().Get(8)) - if err != nil { - return err - } - } - if c.IsSet("getpositionstats") { - getPositionsStats = c.Bool("getpositionstats") - } else if c.Args().Get(9) != "" { - getPositionsStats, err = strconv.ParseBool(c.Args().Get(9)) - if err != nil { - return err - } - } - if c.IsSet("getfundingdata") { - getFundingData = c.Bool("getfundingdata") - } else if c.Args().Get(10) != "" { - getFundingData, err = strconv.ParseBool(c.Args().Get(10)) - if err != nil { - return err - } - } - if c.IsSet("includefundingentries") { - includeFundingEntries = c.Bool("includefundingentries") - } else if c.Args().Get(11) != "" { - includeFundingEntries, err = strconv.ParseBool(c.Args().Get(11)) - if err != nil { - return err - } - } - if c.IsSet("includepredictedrate") { - includePredicted = c.Bool("includepredictedrate") - } else if c.Args().Get(12) != "" { - includePredicted, err = strconv.ParseBool(c.Args().Get(12)) - if err != nil { - return err - } - } - err = order.CheckFundingRatePrerequisites(getFundingData, includePredicted, includeFundingEntries) - if err != nil { - return err - } - - s, err = time.ParseInLocation(time.DateTime, startTime, time.Local) - if err != nil { - return fmt.Errorf("invalid time format for start: %v", err) - } - e, err = time.ParseInLocation(time.DateTime, endTime, time.Local) - if err != nil { - return fmt.Errorf("invalid time format for end: %v", err) - } - - if e.Before(s) { - return errors.New("start cannot be after end") - } - - conn, cancel, err := setupClient(c) - if err != nil { - return err - } - defer closeConn(conn, cancel) - - client := gctrpc.NewGoCryptoTraderServiceClient(conn) - result, err := client.GetFuturesPositions(c.Context, - &gctrpc.GetFuturesPositionsRequest{ - Exchange: exchangeName, - Asset: assetType, - Pair: &gctrpc.CurrencyPair{ - Delimiter: p.Delimiter, - Base: p.Base.String(), - Quote: p.Quote.String(), - }, - StartDate: s.Format(common.SimpleTimeFormatWithTimezone), - EndDate: e.Format(common.SimpleTimeFormatWithTimezone), - Status: status, - PositionLimit: int64(limit), - Overwrite: overwrite, - GetPositionStats: getPositionsStats, - IncludeFullOrderData: includeOrderDetails, - GetFundingPayments: getFundingData, - IncludeFullFundingRates: includeFundingEntries, - IncludePredictedRate: includePredicted, - }) - if err != nil { - return err - } - - jsonOutput(result) - return nil -} - -func getCollateral(c *cli.Context) error { - if c.NArg() == 0 && c.NumFlags() == 0 { - return cli.ShowSubcommandHelp(c) - } - var ( - exchangeName, assetType string - calculateOffline, includeBreakdown, includeZeroValues bool - err error - ) - if c.IsSet("exchange") { - exchangeName = c.String("exchange") - } else { - exchangeName = c.Args().First() - } - if c.IsSet("asset") { - assetType = c.String("asset") - } else { - assetType = c.Args().Get(1) - } - err = isFuturesAsset(assetType) - if err != nil { - return err - } if c.IsSet("calculateoffline") { calculateOffline = c.Bool("calculateoffline") } else if c.Args().Get(2) != "" { @@ -942,3 +945,669 @@ func getLatestFundingRate(c *cli.Context) error { jsonOutput(result) return nil } + +func getCollateralMode(c *cli.Context) error { + if c.NArg() == 0 && c.NumFlags() == 0 { + return cli.ShowSubcommandHelp(c) + } + var ( + exchangeName, assetType string + err error + ) + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else { + exchangeName = c.Args().First() + } + + if c.IsSet("asset") { + assetType = c.String("asset") + } else { + assetType = c.Args().Get(1) + } + + err = isFuturesAsset(assetType) + if err != nil { + return err + } + + conn, cancel, err := setupClient(c) + if err != nil { + return err + } + defer closeConn(conn, cancel) + + client := gctrpc.NewGoCryptoTraderServiceClient(conn) + result, err := client.GetCollateralMode(c.Context, + &gctrpc.GetCollateralModeRequest{ + Exchange: exchangeName, + Asset: assetType, + }) + if err != nil { + return err + } + + jsonOutput(result) + return nil +} + +func setCollateralMode(c *cli.Context) error { + if c.NArg() == 0 && c.NumFlags() == 0 { + return cli.ShowSubcommandHelp(c) + } + var ( + exchangeName, assetType, collateralMode string + err error + ) + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else { + exchangeName = c.Args().First() + } + + if c.IsSet("asset") { + assetType = c.String("asset") + } else { + assetType = c.Args().Get(1) + } + + err = isFuturesAsset(assetType) + if err != nil { + return err + } + + if c.IsSet("collateralmode") { + collateralMode = c.String("collateralmode") + } else { + collateralMode = c.Args().Get(2) + } + + if !collateral.IsValidCollateralModeString(collateralMode) { + return fmt.Errorf("invalid collateral mode: %v", collateralMode) + } + + conn, cancel, err := setupClient(c) + if err != nil { + return err + } + defer closeConn(conn, cancel) + + client := gctrpc.NewGoCryptoTraderServiceClient(conn) + result, err := client.SetCollateralMode(c.Context, + &gctrpc.SetCollateralModeRequest{ + Exchange: exchangeName, + Asset: assetType, + CollateralMode: collateralMode, + }) + if err != nil { + return err + } + + jsonOutput(result) + return nil +} + +func setLeverage(c *cli.Context) error { + if c.NArg() == 0 && c.NumFlags() == 0 { + return cli.ShowSubcommandHelp(c) + } + var ( + exchangeName, assetType, currencyPair, marginType, orderSide string + leverage float64 + err error + ) + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else { + exchangeName = c.Args().First() + } + + if c.IsSet("asset") { + assetType = c.String("asset") + } else { + assetType = c.Args().Get(1) + } + + err = isFuturesAsset(assetType) + if err != nil { + return err + } + + if c.IsSet("pair") { + currencyPair = c.String("pair") + } else { + currencyPair = c.Args().Get(2) + } + if !validPair(currencyPair) { + return fmt.Errorf("%w currencypair:%v", errInvalidPair, currencyPair) + } + pair, err := currency.NewPairDelimiter(currencyPair, pairDelimiter) + if err != nil { + return err + } + + if c.IsSet("margintype") { + marginType = c.String("margintype") + } else { + marginType = c.Args().Get(3) + } + if !margin.IsValidString(marginType) { + return fmt.Errorf("%w margintype:%v", margin.ErrInvalidMarginType, marginType) + } + + if c.IsSet("leverage") { + leverage = c.Float64("leverage") + } else { + leverage, err = strconv.ParseFloat(c.Args().Get(4), 64) + if err != nil { + return err + } + } + + if c.IsSet("orderside") { + orderSide = c.String("orderside") + } else { + orderSide = c.Args().Get(5) + } + if orderSide != "" { + _, err = order.StringToOrderSide(orderSide) + if err != nil { + return err + } + } + + conn, cancel, err := setupClient(c) + if err != nil { + return err + } + defer closeConn(conn, cancel) + + client := gctrpc.NewGoCryptoTraderServiceClient(conn) + result, err := client.SetLeverage(c.Context, + &gctrpc.SetLeverageRequest{ + Exchange: exchangeName, + Asset: assetType, + Pair: &gctrpc.CurrencyPair{ + Delimiter: pair.Delimiter, + Base: pair.Base.String(), + Quote: pair.Quote.String(), + }, + MarginType: marginType, + Leverage: leverage, + OrderSide: orderSide, + }) + if err != nil { + return err + } + + jsonOutput(result) + return nil +} + +func getLeverage(c *cli.Context) error { + if c.NArg() == 0 && c.NumFlags() == 0 { + return cli.ShowSubcommandHelp(c) + } + var ( + exchangeName, assetType, currencyPair, marginType, orderSide string + err error + ) + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else { + exchangeName = c.Args().First() + } + + if c.IsSet("asset") { + assetType = c.String("asset") + } else { + assetType = c.Args().Get(1) + } + + err = isFuturesAsset(assetType) + if err != nil { + return err + } + + if c.IsSet("pair") { + currencyPair = c.String("pair") + } else { + currencyPair = c.Args().Get(2) + } + if !validPair(currencyPair) { + return fmt.Errorf("%w currencypair:%v", errInvalidPair, currencyPair) + } + pair, err := currency.NewPairDelimiter(currencyPair, pairDelimiter) + if err != nil { + return err + } + + if c.IsSet("margintype") { + marginType = c.String("margintype") + } else { + marginType = c.Args().Get(3) + } + if !margin.IsValidString(marginType) { + return fmt.Errorf("%w margintype:%v", margin.ErrInvalidMarginType, marginType) + } + + if c.IsSet("orderside") { + orderSide = c.String("orderside") + } else { + orderSide = c.Args().Get(4) + } + if orderSide != "" { + _, err = order.StringToOrderSide(orderSide) + if err != nil { + return err + } + } + + conn, cancel, err := setupClient(c) + if err != nil { + return err + } + defer closeConn(conn, cancel) + + client := gctrpc.NewGoCryptoTraderServiceClient(conn) + result, err := client.GetLeverage(c.Context, + &gctrpc.GetLeverageRequest{ + Exchange: exchangeName, + Asset: assetType, + Pair: &gctrpc.CurrencyPair{ + Delimiter: pair.Delimiter, + Base: pair.Base.String(), + Quote: pair.Quote.String(), + }, + MarginType: marginType, + OrderSide: orderSide, + }) + if err != nil { + return err + } + + jsonOutput(result) + return nil +} + +func changePositionMargin(c *cli.Context) error { + if c.NArg() == 0 && c.NumFlags() == 0 { + return cli.ShowSubcommandHelp(c) + } + var ( + exchangeName, assetType, currencyPair, marginType, marginSide string + originalAllocatedMargin, newAllocatedMargin float64 + err error + ) + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else { + exchangeName = c.Args().First() + } + + if c.IsSet("asset") { + assetType = c.String("asset") + } else { + assetType = c.Args().Get(1) + } + + err = isFuturesAsset(assetType) + if err != nil { + return err + } + + if c.IsSet("pair") { + currencyPair = c.String("pair") + } else { + currencyPair = c.Args().Get(2) + } + if !validPair(currencyPair) { + return fmt.Errorf("%w currencypair:%v", errInvalidPair, currencyPair) + } + pair, err := currency.NewPairDelimiter(currencyPair, pairDelimiter) + if err != nil { + return err + } + + if c.IsSet("margintype") { + marginType = c.String("margintype") + } else { + marginType = c.Args().Get(3) + } + if !margin.IsValidString(marginType) { + return fmt.Errorf("%w margintype:%v", margin.ErrInvalidMarginType, marginType) + } + + if c.IsSet("originalallocatedmargin") { + originalAllocatedMargin = c.Float64("originalallocatedmargin") + } else { + originalAllocatedMargin, err = strconv.ParseFloat(c.Args().Get(4), 64) + if err != nil { + return err + } + } + + if c.IsSet("newallocatedmargin") { + newAllocatedMargin = c.Float64("newallocatedmargin") + } else { + newAllocatedMargin, err = strconv.ParseFloat(c.Args().Get(5), 64) + if err != nil { + return err + } + } + + if c.IsSet("marginside") { + marginSide = c.String("marginside") + } else { + marginSide = c.Args().Get(6) + } + + conn, cancel, err := setupClient(c) + if err != nil { + return err + } + defer closeConn(conn, cancel) + + client := gctrpc.NewGoCryptoTraderServiceClient(conn) + result, err := client.ChangePositionMargin(c.Context, + &gctrpc.ChangePositionMarginRequest{ + Exchange: exchangeName, + Asset: assetType, + Pair: &gctrpc.CurrencyPair{ + Delimiter: pair.Delimiter, + Base: pair.Base.String(), + Quote: pair.Quote.String(), + }, + MarginType: marginType, + OriginalAllocatedMargin: originalAllocatedMargin, + NewAllocatedMargin: newAllocatedMargin, + MarginSide: marginSide, + }) + if err != nil { + return err + } + + jsonOutput(result) + return nil +} + +func getFuturesPositionSummary(c *cli.Context) error { + if c.NArg() == 0 && c.NumFlags() == 0 { + return cli.ShowSubcommandHelp(c) + } + var ( + exchangeName, assetType, currencyPair, underlyingPair string + err error + ) + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else { + exchangeName = c.Args().First() + } + + if c.IsSet("asset") { + assetType = c.String("asset") + } else { + assetType = c.Args().Get(1) + } + + err = isFuturesAsset(assetType) + if err != nil { + return err + } + + if c.IsSet("pair") { + currencyPair = c.String("pair") + } else { + currencyPair = c.Args().Get(2) + } + if !validPair(currencyPair) { + return fmt.Errorf("%w currencypair:%v", errInvalidPair, currencyPair) + } + pair, err := currency.NewPairDelimiter(currencyPair, pairDelimiter) + if err != nil { + return err + } + + if c.IsSet("underlyingpair") { + underlyingPair = c.String("underlyingpair") + } else { + underlyingPair = c.Args().Get(3) + } + var underlying currency.Pair + if underlyingPair != "" { + underlying, err = currency.NewPairDelimiter(underlyingPair, pairDelimiter) + if err != nil { + return err + } + } + + conn, cancel, err := setupClient(c) + if err != nil { + return err + } + defer closeConn(conn, cancel) + + client := gctrpc.NewGoCryptoTraderServiceClient(conn) + result, err := client.GetFuturesPositionsSummary(c.Context, + &gctrpc.GetFuturesPositionsSummaryRequest{ + Exchange: exchangeName, + Asset: assetType, + Pair: &gctrpc.CurrencyPair{ + Delimiter: pair.Delimiter, + Base: pair.Base.String(), + Quote: pair.Quote.String(), + }, + UnderlyingPair: &gctrpc.CurrencyPair{ + Delimiter: underlying.Delimiter, + Base: underlying.Base.Upper().String(), + Quote: underlying.Quote.Upper().String(), + }, + }) + if err != nil { + return err + } + + jsonOutput(result) + return nil +} + +func getFuturePositionOrders(c *cli.Context) error { + if c.NArg() == 0 && c.NumFlags() == 0 { + return cli.ShowSubcommandHelp(c) + } + var ( + exchangeName, assetType, currencyPair, underlyingPair string + respectOrderHistoryLimits, syncWithOrderManager bool + s, e time.Time + err error + ) + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else { + exchangeName = c.Args().First() + } + + if c.IsSet("asset") { + assetType = c.String("asset") + } else { + assetType = c.Args().Get(1) + } + + err = isFuturesAsset(assetType) + if err != nil { + return err + } + if c.IsSet("pair") { + currencyPair = c.String("pair") + } else { + currencyPair = c.Args().Get(2) + } + if !validPair(currencyPair) { + return fmt.Errorf("%w currencypair:%v", errInvalidPair, currencyPair) + } + pair, err := currency.NewPairDelimiter(currencyPair, pairDelimiter) + if err != nil { + return err + } + + if !c.IsSet("start") { + if c.Args().Get(3) != "" { + startTime = c.Args().Get(3) + } + } + s, err = time.ParseInLocation(time.DateTime, startTime, time.Local) + if err != nil { + return fmt.Errorf("invalid time format for start: %v", err) + } + + if !c.IsSet("end") { + if c.Args().Get(4) != "" { + endTime = c.Args().Get(4) + } + } + e, err = time.ParseInLocation(time.DateTime, endTime, time.Local) + if err != nil { + return fmt.Errorf("invalid time format for start: %v", err) + } + err = common.StartEndTimeCheck(s, e) + if err != nil { + return err + } + + if c.IsSet("respectorderhistorylimits") { + respectOrderHistoryLimits = c.Bool("respectorderhistorylimits") + } else if c.Args().Get(5) != "" { + respectOrderHistoryLimits, err = strconv.ParseBool(c.Args().Get(5)) + if err != nil { + return err + } + } + + if c.IsSet("underlyingpair") { + underlyingPair = c.String("underlyingpair") + } else { + underlyingPair = c.Args().Get(6) + } + var underlying currency.Pair + if underlyingPair != "" { + underlying, err = currency.NewPairDelimiter(underlyingPair, pairDelimiter) + if err != nil { + return err + } + } + if c.IsSet("syncwithordermanager") { + syncWithOrderManager = c.Bool("syncwithordermanager") + } else if c.Args().Get(7) != "" { + syncWithOrderManager, err = strconv.ParseBool(c.Args().Get(7)) + if err != nil { + return err + } + } + + conn, cancel, err := setupClient(c) + if err != nil { + return err + } + defer closeConn(conn, cancel) + + client := gctrpc.NewGoCryptoTraderServiceClient(conn) + result, err := client.GetFuturesPositionsOrders(c.Context, + &gctrpc.GetFuturesPositionsOrdersRequest{ + Exchange: exchangeName, + Asset: assetType, + Pair: &gctrpc.CurrencyPair{ + Delimiter: pair.Delimiter, + Base: pair.Base.String(), + Quote: pair.Quote.String(), + }, + StartDate: s.Format(common.SimpleTimeFormatWithTimezone), + EndDate: e.Format(common.SimpleTimeFormatWithTimezone), + UnderlyingPair: &gctrpc.CurrencyPair{ + Delimiter: underlying.Delimiter, + Base: underlying.Base.Upper().String(), + Quote: underlying.Quote.Upper().String(), + }, + SyncWithOrderManager: syncWithOrderManager, + RespectOrderHistoryLimits: respectOrderHistoryLimits, + }) + if err != nil { + return err + } + + jsonOutput(result) + return nil +} + +func setMarginType(c *cli.Context) error { + if c.NArg() == 0 && c.NumFlags() == 0 { + return cli.ShowSubcommandHelp(c) + } + var ( + exchangeName, assetType, currencyPair, marginType string + err error + ) + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else { + exchangeName = c.Args().First() + } + + if c.IsSet("asset") { + assetType = c.String("asset") + } else { + assetType = c.Args().Get(1) + } + + err = isFuturesAsset(assetType) + if err != nil { + return err + } + + if c.IsSet("pair") { + currencyPair = c.String("pair") + } else { + currencyPair = c.Args().Get(2) + } + if !validPair(currencyPair) { + return fmt.Errorf("%w currencypair:%v", errInvalidPair, currencyPair) + } + pair, err := currency.NewPairDelimiter(currencyPair, pairDelimiter) + if err != nil { + return err + } + + if c.IsSet("margintype") { + marginType = c.String("margintype") + } else { + marginType = c.Args().Get(3) + } + if !margin.IsValidString(marginType) { + return fmt.Errorf("%w margintype:%v", margin.ErrInvalidMarginType, marginType) + } + + conn, cancel, err := setupClient(c) + if err != nil { + return err + } + defer closeConn(conn, cancel) + + client := gctrpc.NewGoCryptoTraderServiceClient(conn) + result, err := client.SetMarginType(c.Context, + &gctrpc.SetMarginTypeRequest{ + Exchange: exchangeName, + Asset: assetType, + Pair: &gctrpc.CurrencyPair{ + Delimiter: pair.Delimiter, + Base: pair.Base.String(), + Quote: pair.Quote.String(), + }, + MarginType: marginType, + }) + if err != nil { + return err + } + + jsonOutput(result) + return nil +} diff --git a/common/common.go b/common/common.go index bafc8dc2e13..93e66a5f40a 100644 --- a/common/common.go +++ b/common/common.go @@ -69,7 +69,7 @@ var ( ErrNilPointer = errors.New("nil pointer") // ErrCannotCalculateOffline is returned when a request wishes to calculate // something offline, but has an online requirement - ErrCannotCalculateOffline = errors.New("cannot calculate offline") + ErrCannotCalculateOffline = errors.New("cannot calculate offline, unsupported") // ErrNoResponse is returned when a response has no entries/is empty // when one is expected ErrNoResponse = errors.New("no response") diff --git a/common/convert/convert.go b/common/convert/convert.go index 949e368d007..dc91a96db40 100644 --- a/common/convert/convert.go +++ b/common/convert/convert.go @@ -232,13 +232,13 @@ func (f StringToFloat64) MarshalJSON() ([]byte, error) { } // Float64 returns the float64 value of the FloatString. -func (f *StringToFloat64) Float64() float64 { - return float64(*f) +func (f StringToFloat64) Float64() float64 { + return float64(f) } // Decimal returns the decimal value of the FloatString // Warning: this does not handle big numbers as the underlying // is still a float -func (f *StringToFloat64) Decimal() decimal.Decimal { - return decimal.NewFromFloat(float64(*f)) +func (f StringToFloat64) Decimal() decimal.Decimal { + return decimal.NewFromFloat(float64(f)) } diff --git a/config/config.go b/config/config.go index 06254be4547..28144bcd2c9 100644 --- a/config/config.go +++ b/config/config.go @@ -1427,6 +1427,9 @@ func (c *Config) CheckOrderManagerConfig() { c.OrderManager.Enabled = convert.BoolPtr(true) c.OrderManager.ActivelyTrackFuturesPositions = true } + if c.OrderManager.RespectOrderHistoryLimits == nil { + c.OrderManager.RespectOrderHistoryLimits = convert.BoolPtr(true) + } if c.OrderManager.ActivelyTrackFuturesPositions && c.OrderManager.FuturesTrackingSeekDuration >= 0 { // one isn't likely to have a perpetual futures order open // for longer than a year diff --git a/config/config_types.go b/config/config_types.go index 79fea8966e1..657cabbe5c1 100644 --- a/config/config_types.go +++ b/config/config_types.go @@ -125,6 +125,8 @@ type OrderManager struct { Verbose bool `json:"verbose"` ActivelyTrackFuturesPositions bool `json:"activelyTrackFuturesPositions"` FuturesTrackingSeekDuration time.Duration `json:"futuresTrackingSeekDuration"` + RespectOrderHistoryLimits *bool `json:"respectOrderHistoryLimits"` + CancelOrdersOnShutdown bool `json:"cancelOrdersOnShutdown"` } // DataHistoryManager holds all information required for the data history manager diff --git a/currency/manager.go b/currency/manager.go index 470724d7f63..a3c682ce584 100644 --- a/currency/manager.go +++ b/currency/manager.go @@ -25,10 +25,13 @@ var ( // contained in the available pairs list and is not supported by the // exchange for that asset type. ErrPairNotContainedInAvailablePairs = errors.New("pair not contained in available pairs") + // ErrPairManagerNotInitialised is returned when a pairs manager is requested, but has not been setup + ErrPairManagerNotInitialised = errors.New("pair manager not initialised") + // ErrAssetNotFound is returned when an asset does not exist in the pairstore + ErrAssetNotFound = errors.New("asset type not found in pair store") errPairStoreIsNil = errors.New("pair store is nil") errPairFormatIsNil = errors.New("pair format is nil") - errAssetNotFound = errors.New("asset type not found") ) // GetAssetTypes returns a list of stored asset types @@ -368,12 +371,12 @@ func (p *PairsManager) SetAssetEnabled(a asset.Item, enabled bool) error { func (p *PairsManager) getPairStoreRequiresLock(a asset.Item) (*PairStore, error) { if p.Pairs == nil { - return nil, errors.New("pair manager not initialised") + return nil, fmt.Errorf("%w when requesting %v pairs", ErrPairManagerNotInitialised, a) } pairStore, ok := p.Pairs[a] if !ok { - return nil, fmt.Errorf("%w %v", errAssetNotFound, a) + return nil, fmt.Errorf("%w %v", ErrAssetNotFound, a) } if pairStore == nil { diff --git a/currency/manager_test.go b/currency/manager_test.go index 319292137d8..5585c14eccc 100644 --- a/currency/manager_test.go +++ b/currency/manager_test.go @@ -550,8 +550,8 @@ func TestIsAssetPairEnabled(t *testing.T) { } err = pm.IsAssetPairEnabled(asset.PerpetualSwap, cp) - if !errors.Is(err, errAssetNotFound) { - t.Fatalf("received: '%v' but expected: '%v'", err, errAssetNotFound) + if !errors.Is(err, ErrAssetNotFound) { + t.Fatalf("received: '%v' but expected: '%v'", err, ErrAssetNotFound) } err = pm.IsAssetPairEnabled(asset.Item(1337), cp) diff --git a/currency/pair.go b/currency/pair.go index a6de487287c..975eeb9704f 100644 --- a/currency/pair.go +++ b/currency/pair.go @@ -8,6 +8,16 @@ import ( var errCannotCreatePair = errors.New("cannot create currency pair") +// NewBTCUSDT is a shortcut for NewPair(BTC, USDT) +func NewBTCUSDT() Pair { + return NewPair(BTC, USDT) +} + +// NewBTCUSD is a shortcut for NewPair(BTC, USD) +func NewBTCUSD() Pair { + return NewPair(BTC, USD) +} + // NewPairDelimiter splits the desired currency string at delimiter, the returns // a Pair struct func NewPairDelimiter(currencyPair, delimiter string) (Pair, error) { diff --git a/currency/pair_test.go b/currency/pair_test.go index 9e9d3b5771e..9ed5dc79775 100644 --- a/currency/pair_test.go +++ b/currency/pair_test.go @@ -1094,3 +1094,25 @@ func TestPair_GetFormatting(t *testing.T) { t.Error(err) } } + +func TestNewBTCUSD(t *testing.T) { + t.Parallel() + p := NewBTCUSD() + if !p.Base.Equal(BTC) { + t.Fatal("expected base BTC from function NewBTCUSD") + } + if !p.Quote.Equal(USD) { + t.Fatal("expected quote USD from function NewBTCUSD") + } +} + +func TestNewBTCUSDT(t *testing.T) { + t.Parallel() + p := NewBTCUSDT() + if !p.Base.Equal(BTC) { + t.Fatal("expected base BTC from function NewBTCUSDT") + } + if !p.Quote.Equal(USDT) { + t.Fatal("expected quote USDT from function NewBTCUSDT") + } +} diff --git a/engine/engine.go b/engine/engine.go index 28f609036ed..fcc221c2253 100644 --- a/engine/engine.go +++ b/engine/engine.go @@ -483,10 +483,7 @@ func (bot *Engine) Start() error { bot.ExchangeManager, bot.CommunicationsManager, &bot.ServicesWG, - bot.Config.OrderManager.Verbose, - bot.Config.OrderManager.ActivelyTrackFuturesPositions, - bot.Config.OrderManager.FuturesTrackingSeekDuration, - ); err != nil { + &bot.Config.OrderManager); err != nil { gctlog.Errorf(gctlog.Global, "Order manager unable to setup: %s", err) } else { bot.OrderManager = o diff --git a/engine/helpers.go b/engine/helpers.go index 2467af9969f..84f9e60dc90 100644 --- a/engine/helpers.go +++ b/engine/helpers.go @@ -133,13 +133,7 @@ func (bot *Engine) SetSubsystem(subSystemName string, enable bool) error { case OrderManagerName: if enable { if bot.OrderManager == nil { - bot.OrderManager, err = SetupOrderManager( - bot.ExchangeManager, - bot.CommunicationsManager, - &bot.ServicesWG, - bot.Config.OrderManager.Verbose, - bot.Config.OrderManager.ActivelyTrackFuturesPositions, - bot.Config.OrderManager.FuturesTrackingSeekDuration) + bot.OrderManager, err = SetupOrderManager(bot.ExchangeManager, bot.CommunicationsManager, &bot.ServicesWG, &bot.Config.OrderManager) if err != nil { return err } diff --git a/engine/order_manager.go b/engine/order_manager.go index 3408be00f37..34711b2d583 100644 --- a/engine/order_manager.go +++ b/engine/order_manager.go @@ -14,6 +14,7 @@ import ( "github.com/shopspring/decimal" "github.com/thrasher-corp/gocryptotrader/common" "github.com/thrasher-corp/gocryptotrader/communications/base" + "github.com/thrasher-corp/gocryptotrader/config" "github.com/thrasher-corp/gocryptotrader/currency" exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" @@ -24,7 +25,7 @@ import ( ) // SetupOrderManager will boot up the OrderManager -func SetupOrderManager(exchangeManager iExchangeManager, communicationsManager iCommsManager, wg *sync.WaitGroup, verbose, activelyTrackFuturesPositions bool, futuresTrackingSeekDuration time.Duration) (*OrderManager, error) { +func SetupOrderManager(exchangeManager iExchangeManager, communicationsManager iCommsManager, wg *sync.WaitGroup, cfg *config.OrderManager) (*OrderManager, error) { if exchangeManager == nil { return nil, errNilExchangeManager } @@ -34,10 +35,18 @@ func SetupOrderManager(exchangeManager iExchangeManager, communicationsManager i if wg == nil { return nil, errNilWaitGroup } + if cfg == nil { + return nil, fmt.Errorf("%w OrderManager", errNilConfig) + } + var respectOrderHistoryLimits bool + if cfg.RespectOrderHistoryLimits != nil { + respectOrderHistoryLimits = *cfg.RespectOrderHistoryLimits + } om := &OrderManager{ shutdown: make(chan struct{}), - activelyTrackFuturesPositions: activelyTrackFuturesPositions, + activelyTrackFuturesPositions: cfg.ActivelyTrackFuturesPositions, + respectOrderHistoryLimits: respectOrderHistoryLimits, orderStore: store{ Orders: make(map[string][]*order.Detail), exchangeManager: exchangeManager, @@ -45,16 +54,19 @@ func SetupOrderManager(exchangeManager iExchangeManager, communicationsManager i wg: wg, futuresPositionController: order.SetupPositionController(), }, - verbose: verbose, + verbose: cfg.Verbose, + cfg: orderManagerConfig{ + CancelOrdersOnShutdown: cfg.CancelOrdersOnShutdown, + }, } - if activelyTrackFuturesPositions { - if futuresTrackingSeekDuration > 0 { - futuresTrackingSeekDuration = -futuresTrackingSeekDuration + if cfg.ActivelyTrackFuturesPositions { + if cfg.FuturesTrackingSeekDuration > 0 { + cfg.FuturesTrackingSeekDuration *= -1 } - if futuresTrackingSeekDuration == 0 { - futuresTrackingSeekDuration = defaultOrderSeekTime + if cfg.FuturesTrackingSeekDuration == 0 { + cfg.FuturesTrackingSeekDuration = defaultOrderSeekTime } - om.futuresPositionSeekDuration = futuresTrackingSeekDuration + om.futuresPositionSeekDuration = cfg.FuturesTrackingSeekDuration } return om, nil } @@ -699,9 +711,9 @@ func (m *OrderManager) processOrders() { wg.Add(1) go m.processMatchingOrders(exchanges[x], orders, &wg) } - - if m.activelyTrackFuturesPositions && enabledAssets[y].IsFutures() { - var positions []order.PositionDetails + supportedFeatures := exchanges[x].GetSupportedFeatures() + if m.activelyTrackFuturesPositions && enabledAssets[y].IsFutures() && supportedFeatures.FuturesCapabilities.OrderManagerPositionTracking { + var positions []order.PositionResponse var sd time.Time sd, err = m.orderStore.futuresPositionController.LastUpdated() if err != nil { @@ -711,10 +723,11 @@ func (m *OrderManager) processOrders() { if sd.IsZero() { sd = time.Now().Add(m.futuresPositionSeekDuration) } - positions, err = exchanges[x].GetFuturesPositions(context.TODO(), &order.PositionsRequest{ - Asset: enabledAssets[y], - Pairs: pairs, - StartDate: sd, + positions, err = exchanges[x].GetFuturesPositionOrders(context.TODO(), &order.PositionsRequest{ + Asset: enabledAssets[y], + Pairs: pairs, + StartDate: sd, + RespectOrderHistoryLimits: m.respectOrderHistoryLimits, }) if err != nil { if !errors.Is(err, common.ErrNotYetImplemented) { @@ -728,7 +741,7 @@ func (m *OrderManager) processOrders() { } err = m.processFuturesPositions(exchanges[x], &positions[z]) if err != nil { - log.Errorf(log.OrderMgr, "unable to process future positions for %v %v %v. err: %v", positions[z].Exchange, positions[z].Asset, positions[z].Pair, err) + log.Errorf(log.OrderMgr, "unable to process future positions for %v %v %v. err: %v", exchanges[x].GetName(), positions[z].Asset, positions[z].Pair, err) } } } @@ -741,7 +754,7 @@ func (m *OrderManager) processOrders() { } // processFuturesPositions ensures any open position found is kept up to date in the order manager -func (m *OrderManager) processFuturesPositions(exch exchange.IBotExchange, position *order.PositionDetails) error { +func (m *OrderManager) processFuturesPositions(exch exchange.IBotExchange, position *order.PositionResponse) error { if !m.activelyTrackFuturesPositions { return errFuturesTrackingDisabled } @@ -749,14 +762,15 @@ func (m *OrderManager) processFuturesPositions(exch exchange.IBotExchange, posit return fmt.Errorf("%w IBotExchange", common.ErrNilPointer) } if position == nil { - return fmt.Errorf("%w PositionDetails", common.ErrNilPointer) + return fmt.Errorf("%w PositionResponse", common.ErrNilPointer) } if len(position.Orders) == 0 { - return fmt.Errorf("%w position for '%v' '%v' '%v' has no orders", errNilOrder, position.Exchange, position.Asset, position.Pair) + return fmt.Errorf("%w position for '%v' '%v' '%v' has no orders", errNilOrder, exch.GetName(), position.Asset, position.Pair) } sort.Slice(position.Orders, func(i, j int) bool { return position.Orders[i].Date.Before(position.Orders[j].Date) }) + feat := exch.GetSupportedFeatures() var err error for i := range position.Orders { err = m.orderStore.futuresPositionController.TrackNewOrder(&position.Orders[i]) @@ -764,7 +778,7 @@ func (m *OrderManager) processFuturesPositions(exch exchange.IBotExchange, posit return err } } - _, err = m.orderStore.futuresPositionController.GetOpenPosition(position.Exchange, position.Asset, position.Pair) + _, err = m.orderStore.futuresPositionController.GetOpenPosition(exch.GetName(), position.Asset, position.Pair) if err != nil { if errors.Is(err, order.ErrPositionNotFound) { return nil @@ -773,11 +787,14 @@ func (m *OrderManager) processFuturesPositions(exch exchange.IBotExchange, posit } tick, err := exch.FetchTicker(context.TODO(), position.Pair, position.Asset) if err != nil { - return fmt.Errorf("%w when fetching ticker data for %v %v %v", err, position.Exchange, position.Asset, position.Pair) + return fmt.Errorf("%w when fetching ticker data for %v %v %v", err, exch.GetName(), position.Asset, position.Pair) } - _, err = m.UpdateOpenPositionUnrealisedPNL(position.Exchange, position.Asset, position.Pair, tick.Last, tick.LastUpdated) + _, err = m.UpdateOpenPositionUnrealisedPNL(exch.GetName(), position.Asset, position.Pair, tick.Last, tick.LastUpdated) if err != nil { - return fmt.Errorf("%w when updating unrealised PNL for %v %v %v", err, position.Exchange, position.Asset, position.Pair) + return fmt.Errorf("%w when updating unrealised PNL for %v %v %v", err, exch.GetName(), position.Asset, position.Pair) + } + if !feat.FuturesCapabilities.FundingRates { + return nil } isPerp, err := exch.IsPerpetualFutureCurrency(position.Asset, position.Pair) if err != nil { diff --git a/engine/order_manager_test.go b/engine/order_manager_test.go index bac0ab10ad6..e7d682eccfc 100644 --- a/engine/order_manager_test.go +++ b/engine/order_manager_test.go @@ -120,18 +120,17 @@ func (f omfExchange) ModifyOrder(_ context.Context, action *order.Modify) (*orde return modResp, nil } -func (f omfExchange) GetFuturesPositions(_ context.Context, req *order.PositionsRequest) ([]order.PositionDetails, error) { +func (f omfExchange) GetFuturesPositionOrders(_ context.Context, req *order.PositionsRequest) ([]order.PositionResponse, error) { id, err := uuid.NewV4() if err != nil { return nil, err } - resp := make([]order.PositionDetails, len(req.Pairs)) + resp := make([]order.PositionResponse, len(req.Pairs)) tt := time.Now() for i := range req.Pairs { - resp[i] = order.PositionDetails{ - Exchange: f.GetName(), - Asset: req.Asset, - Pair: req.Pairs[i], + resp[i] = order.PositionResponse{ + Asset: req.Asset, + Pair: req.Pairs[i], Orders: []order.Detail{ { Exchange: f.GetName(), @@ -156,28 +155,28 @@ func (f omfExchange) GetFuturesPositions(_ context.Context, req *order.Positions } func TestSetupOrderManager(t *testing.T) { - _, err := SetupOrderManager(nil, nil, nil, false, false, 0) + _, err := SetupOrderManager(nil, nil, nil, nil) if !errors.Is(err, errNilExchangeManager) { t.Errorf("error '%v', expected '%v'", err, errNilExchangeManager) } - _, err = SetupOrderManager(NewExchangeManager(), nil, nil, false, false, 0) + _, err = SetupOrderManager(NewExchangeManager(), nil, nil, nil) if !errors.Is(err, errNilCommunicationsManager) { t.Errorf("error '%v', expected '%v'", err, errNilCommunicationsManager) } - _, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, nil, false, false, 0) + _, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, nil, &config.OrderManager{}) if !errors.Is(err, errNilWaitGroup) { t.Errorf("error '%v', expected '%v'", err, errNilWaitGroup) } var wg sync.WaitGroup - _, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, false, false, 0) + _, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } - _, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, false, true, 0) + _, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{ActivelyTrackFuturesPositions: true, FuturesTrackingSeekDuration: 0}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } - _, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, false, true, 1337) + _, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{ActivelyTrackFuturesPositions: true, FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } @@ -190,7 +189,7 @@ func TestOrderManagerStart(t *testing.T) { t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem) } var wg sync.WaitGroup - m, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, false, false, 0) + m, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } @@ -211,7 +210,7 @@ func TestOrderManagerIsRunning(t *testing.T) { } var wg sync.WaitGroup - m, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, false, false, 0) + m, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } @@ -236,7 +235,7 @@ func TestOrderManagerStop(t *testing.T) { } var wg sync.WaitGroup - m, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, false, false, 0) + m, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } @@ -281,7 +280,7 @@ func OrdersSetup(t *testing.T) *OrderManager { if !errors.Is(err, nil) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } - m, err := SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, 0) + m, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } @@ -749,7 +748,7 @@ func TestProcessOrders(t *testing.T) { if !errors.Is(err, nil) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } - m, err := SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, 0) + m, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } @@ -1445,7 +1444,7 @@ func TestOrderManagerAdd(t *testing.T) { func TestGetAllOpenFuturesPositions(t *testing.T) { t.Parallel() wg := &sync.WaitGroup{} - o, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, wg, false, false, time.Hour) + o, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -1473,7 +1472,7 @@ func TestGetAllOpenFuturesPositions(t *testing.T) { func TestGetOpenFuturesPosition(t *testing.T) { t.Parallel() wg := &sync.WaitGroup{} - o, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, wg, false, false, time.Hour) + o, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -1521,7 +1520,12 @@ func TestGetOpenFuturesPosition(t *testing.T) { if !errors.Is(err, nil) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } - o, err = SetupOrderManager(em, &CommunicationManager{}, wg, false, true, time.Hour) + o, err = SetupOrderManager(em, &CommunicationManager{}, wg, &config.OrderManager{ + Enabled: convert.BoolPtr(true), + FuturesTrackingSeekDuration: time.Hour, + Verbose: true, + ActivelyTrackFuturesPositions: true, + }) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -1611,7 +1615,7 @@ func TestProcessFuturesPositions(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - o, err = SetupOrderManager(em, &CommunicationManager{}, &wg, false, true, time.Hour) + o, err = SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{ActivelyTrackFuturesPositions: true, FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -1622,11 +1626,10 @@ func TestProcessFuturesPositions(t *testing.T) { t.Errorf("received '%v', expected '%v'", err, common.ErrNilPointer) } - position := &order.PositionDetails{ - Exchange: b.Name, - Asset: asset.Spot, - Pair: cp, - Orders: nil, + position := &order.PositionResponse{ + Asset: asset.Spot, + Pair: cp, + Orders: nil, } err = o.processFuturesPositions(fakeExchange, position) if !errors.Is(err, errNilOrder) { @@ -1657,4 +1660,10 @@ func TestProcessFuturesPositions(t *testing.T) { if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } + + b.Features.Supports.FuturesCapabilities.FundingRates = true + err = o.processFuturesPositions(fakeExchange, position) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } } diff --git a/engine/order_manager_types.go b/engine/order_manager_types.go index b312dce503c..7d11262eb19 100644 --- a/engine/order_manager_types.go +++ b/engine/order_manager_types.go @@ -48,6 +48,7 @@ type OrderManager struct { verbose bool activelyTrackFuturesPositions bool futuresPositionSeekDuration time.Duration + respectOrderHistoryLimits bool } // store holds all orders by exchange diff --git a/engine/rpcserver.go b/engine/rpcserver.go index 65651ed10d3..56680af4b2e 100644 --- a/engine/rpcserver.go +++ b/engine/rpcserver.go @@ -34,6 +34,7 @@ import ( exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" "github.com/thrasher-corp/gocryptotrader/exchanges/margin" @@ -64,14 +65,12 @@ var ( errExchangeNameUnset = errors.New("exchange name unset") errCurrencyPairUnset = errors.New("currency pair unset") errInvalidTimes = errors.New("invalid start and end times") - errAssetTypeDisabled = errors.New("asset type is disabled") errAssetTypeUnset = errors.New("asset type unset") errDispatchSystem = errors.New("dispatch system offline") errCurrencyNotEnabled = errors.New("currency not enabled") errCurrencyNotSpecified = errors.New("a currency must be specified") errCurrencyPairInvalid = errors.New("currency provided is not found in the available pairs list") errNoTrades = errors.New("no trades returned from supplied params") - errUnexpectedResponseSize = errors.New("unexpected slice size") errNilRequestData = errors.New("nil request data received, cannot continue") errNoAccountInformation = errors.New("account information does not exist") errShutdownNotAllowed = errors.New("shutting down this bot instance is not allowed via gRPC, please enable by command line flag --grpcshutdown or config.json field grpcAllowBotShutdown") @@ -1198,14 +1197,20 @@ func (s *RPCServer) GetOrder(ctx context.Context, r *gctrpc.GetOrderRequest) (*g }, err } -// SubmitOrder submits an order specified by exchange, currency pair and asset -// type +// SubmitOrder submits an order specified by exchange, currency pair and asset type func (s *RPCServer) SubmitOrder(ctx context.Context, r *gctrpc.SubmitOrderRequest) (*gctrpc.SubmitOrderResponse, error) { a, err := asset.New(r.AssetType) if err != nil { return nil, err } + var marginType margin.Type + if r.MarginType != "" { + marginType, err = margin.StringToMarginType(r.MarginType) + if err != nil { + return nil, err + } + } if r.Pair == nil { return nil, errCurrencyPairUnset } @@ -1247,6 +1252,9 @@ func (s *RPCServer) SubmitOrder(ctx context.Context, r *gctrpc.SubmitOrderReques Exchange: r.Exchange, AssetType: a, } + if r.MarginType != "" { + submission.MarginType = marginType + } resp, err := s.OrderManager.Submit(ctx, submission) if err != nil { @@ -3649,7 +3657,7 @@ func checkParams(exchName string, e exchange.IBotExchange, a asset.Item, p curre } err := b.CurrencyPairs.IsAssetEnabled(a) if err != nil { - return fmt.Errorf("%v %w", a, errAssetTypeDisabled) + return err } } if p.IsEmpty() { @@ -4323,6 +4331,10 @@ func (s *RPCServer) GetManagedPosition(_ context.Context, r *gctrpc.GetManagedPo if !exch.IsEnabled() { return nil, fmt.Errorf("%w '%v'", errExchangeDisabled, exch.GetName()) } + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.OrderManagerPositionTracking { + return nil, fmt.Errorf("%w OrderManagerPositionTracking for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } ai, err = asset.New(r.Asset) if err != nil { return nil, err @@ -4351,7 +4363,7 @@ func (s *RPCServer) GetManagedPosition(_ context.Context, r *gctrpc.GetManagedPo // GetAllManagedPositions returns all open positions from the order manager, no calling any API endpoints to return this information func (s *RPCServer) GetAllManagedPositions(_ context.Context, r *gctrpc.GetAllManagedPositionsRequest) (*gctrpc.GetManagedPositionsResponse, error) { if r == nil { - return nil, fmt.Errorf("%w GetAllManagedPositions", common.ErrNilPointer) + return nil, fmt.Errorf("%w GetAllManagedPositionsRequest", common.ErrNilPointer) } if err := order.CheckFundingRatePrerequisites(r.GetFundingPayments, r.IncludePredictedRate, r.GetFundingPayments); err != nil { return nil, err @@ -4371,35 +4383,178 @@ func (s *RPCServer) GetAllManagedPositions(_ context.Context, r *gctrpc.GetAllMa return &gctrpc.GetManagedPositionsResponse{Positions: response}, nil } -// GetFuturesPositions returns pnl positions for an exchange asset pair -func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuturesPositionsRequest) (*gctrpc.GetFuturesPositionsResponse, error) { +// GetFuturesPositionsSummary returns a summary of futures positions for an exchange asset pair from the API +func (s *RPCServer) GetFuturesPositionsSummary(ctx context.Context, r *gctrpc.GetFuturesPositionsSummaryRequest) (*gctrpc.GetFuturesPositionsSummaryResponse, error) { if r == nil { - return nil, fmt.Errorf("%w GetFuturesPositions", common.ErrNilPointer) + return nil, fmt.Errorf("%w GetFuturesPositionsSummaryRequest", common.ErrNilPointer) } - if err := order.CheckFundingRatePrerequisites(r.GetFundingPayments, r.IncludePredictedRate, r.GetFundingPayments); err != nil { - return nil, err + if r.Pair == nil { + return nil, currency.ErrCurrencyPairEmpty } exch, err := s.GetExchangeByName(r.Exchange) if err != nil { return nil, err } - cp, err := currency.NewPairFromStrings(r.Pair.Base, r.Pair.Quote) + if !exch.IsEnabled() { + return nil, fmt.Errorf("%s %w", r.Exchange, errExchangeNotEnabled) + } + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.Positions { + return nil, fmt.Errorf("%w futures position tracking for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } + ai, err := asset.New(r.Asset) if err != nil { return nil, err } - - ai, err := asset.New(r.Asset) + if !ai.IsFutures() { + return nil, fmt.Errorf("%s %w", ai, order.ErrNotFuturesAsset) + } + enabledPairs, err := exch.GetEnabledPairs(ai) + if err != nil { + return nil, err + } + cp, err := enabledPairs.DeriveFrom(r.Pair.Base + r.Pair.Quote) if err != nil { return nil, err } - err = checkParams(r.Exchange, exch, ai, cp) + var underlying currency.Pair + if r.UnderlyingPair != nil { + underlying, err = currency.NewPairFromStrings(r.UnderlyingPair.Base, r.UnderlyingPair.Quote) + if err != nil { + return nil, err + } + } + + var stats *order.PositionSummary + stats, err = exch.GetFuturesPositionSummary(ctx, &order.PositionSummaryRequest{ + Asset: ai, + Pair: cp, + UnderlyingPair: underlying, + }) + if err != nil { + return nil, fmt.Errorf("cannot GetFuturesPositionSummary %w", err) + } + + positionStats := &gctrpc.FuturesPositionStats{} + if !stats.MaintenanceMarginRequirement.IsZero() { + positionStats.MaintenanceMarginRequirement = stats.MaintenanceMarginRequirement.String() + } + if !stats.InitialMarginRequirement.IsZero() { + positionStats.InitialMarginRequirement = stats.InitialMarginRequirement.String() + } + if !stats.CollateralUsed.IsZero() { + positionStats.CollateralUsed = stats.CollateralUsed.String() + } + if !stats.MarkPrice.IsZero() { + positionStats.MarkPrice = stats.MarkPrice.String() + } + if !stats.CurrentSize.IsZero() { + positionStats.CurrentSize = stats.CurrentSize.String() + } + if !stats.AverageOpenPrice.IsZero() { + positionStats.AverageOpenPrice = stats.AverageOpenPrice.String() + } + if !stats.PositionPNL.IsZero() { + positionStats.RecentPnl = stats.PositionPNL.String() + } + if !stats.MaintenanceMarginFraction.IsZero() { + positionStats.MarginFraction = stats.MaintenanceMarginFraction.String() + } + if !stats.FreeCollateral.IsZero() { + positionStats.FreeCollateral = stats.FreeCollateral.String() + } + if !stats.TotalCollateral.IsZero() { + positionStats.TotalCollateral = stats.TotalCollateral.String() + } + if !stats.EstimatedLiquidationPrice.IsZero() { + positionStats.EstimatedLiquidationPrice = stats.EstimatedLiquidationPrice.String() + } + if !stats.FrozenBalance.IsZero() { + positionStats.FrozenBalance = stats.FrozenBalance.String() + } + if !stats.EquityOfCurrency.IsZero() { + positionStats.EquityOfCurrency = stats.EquityOfCurrency.String() + } + if !stats.AvailableEquity.IsZero() { + positionStats.AvailableEquity = stats.AvailableEquity.String() + } + if !stats.CashBalance.IsZero() { + positionStats.CashBalance = stats.CashBalance.String() + } + if !stats.DiscountEquity.IsZero() { + positionStats.DiscountEquity = stats.DiscountEquity.String() + } + if !stats.EquityUSD.IsZero() { + positionStats.EquityUsd = stats.EquityUSD.String() + } + if !stats.IsolatedEquity.IsZero() { + positionStats.IsolatedEquity = stats.IsolatedEquity.String() + } + if !stats.IsolatedLiabilities.IsZero() { + positionStats.IsolatedLiabilities = stats.IsolatedLiabilities.String() + } + if !stats.IsolatedUPL.IsZero() { + positionStats.IsolatedUpl = stats.IsolatedUPL.String() + } + if !stats.NotionalLeverage.IsZero() { + positionStats.NotionalLeverage = stats.NotionalLeverage.String() + } + if !stats.TotalEquity.IsZero() { + positionStats.TotalEquity = stats.TotalEquity.String() + } + if !stats.StrategyEquity.IsZero() { + positionStats.StrategyEquity = stats.StrategyEquity.String() + } + return &gctrpc.GetFuturesPositionsSummaryResponse{ + Exchange: exch.GetName(), + Asset: ai.String(), + Pair: &gctrpc.CurrencyPair{ + Delimiter: cp.Delimiter, + Base: cp.Base.String(), + Quote: cp.Quote.String(), + }, + PositionStats: positionStats, + }, nil +} + +// GetFuturesPositionsOrders returns futures position orders from exchange API +func (s *RPCServer) GetFuturesPositionsOrders(ctx context.Context, r *gctrpc.GetFuturesPositionsOrdersRequest) (*gctrpc.GetFuturesPositionsOrdersResponse, error) { + if r == nil { + return nil, fmt.Errorf("%w GetFuturesPositionsOrdersRequest", common.ErrNilPointer) + } + if r.Pair == nil { + return nil, currency.ErrCurrencyPairEmpty + } + exch, err := s.GetExchangeByName(r.Exchange) + if err != nil { + return nil, err + } + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.Positions { + return nil, fmt.Errorf("%w futures position tracking for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } + if r.SyncWithOrderManager && !feat.FuturesCapabilities.OrderManagerPositionTracking { + return nil, fmt.Errorf("%w OrderManagerPositionTracking", common.ErrFunctionNotSupported) + } + if !exch.IsEnabled() { + return nil, fmt.Errorf("%s %w", r.Exchange, errExchangeNotEnabled) + } + ai, err := asset.New(r.Asset) if err != nil { return nil, err } if !ai.IsFutures() { return nil, fmt.Errorf("%s %w", ai, order.ErrNotFuturesAsset) } + enabledPairs, err := exch.GetEnabledPairs(ai) + if err != nil { + return nil, err + } + cp, err := enabledPairs.DeriveFrom(r.Pair.Base + r.Pair.Quote) + if err != nil { + return nil, err + } var start, end time.Time if r.StartDate != "" { start, err = time.Parse(common.SimpleTimeFormatWithTimezone, r.StartDate) @@ -4418,230 +4573,64 @@ func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuture return nil, err } - b := exch.GetBase() - creds, err := b.GetCredentials(ctx) - if err != nil { - return nil, err - } - var subAccount string - if creds.SubAccount != "" { - subAccount = "for subaccount: " + creds.SubAccount - } - positionDetails, err := exch.GetFuturesPositions(ctx, &order.PositionsRequest{ - Asset: ai, - Pairs: currency.Pairs{cp}, - StartDate: start, + positionDetails, err := exch.GetFuturesPositionOrders(ctx, &order.PositionsRequest{ + Asset: ai, + Pairs: currency.Pairs{cp}, + StartDate: start, + EndDate: end, + RespectOrderHistoryLimits: r.RespectOrderHistoryLimits, }) if err != nil { - return nil, fmt.Errorf("%w %v", err, subAccount) - } - if len(positionDetails) != 1 { - return nil, errUnexpectedResponseSize - } - if r.Overwrite { - err = s.OrderManager.ClearFuturesTracking(r.Exchange, ai, cp) - if err != nil { - return nil, fmt.Errorf("cannot overwrite %w %v", err, subAccount) - } - } - for i := range positionDetails[0].Orders { - err = s.OrderManager.orderStore.futuresPositionController.TrackNewOrder(&positionDetails[0].Orders[i]) - if err != nil { - if !errors.Is(err, order.ErrPositionClosed) { - return nil, err - } - } - } - pos, err := s.OrderManager.GetFuturesPositionsForExchange(r.Exchange, ai, cp) - if err != nil { - return nil, fmt.Errorf("cannot GetFuturesPositionsForExchange %w %v", err, subAccount) - } - - response := &gctrpc.GetFuturesPositionsResponse{ - SubAccount: creds.SubAccount, + return nil, err } - var totalRealisedPNL, totalUnrealisedPNL decimal.Decimal - for i := range pos { - if r.Status != "" && pos[i].Status.String() != strings.ToUpper(r.Status) { - continue - } - if r.PositionLimit > 0 && len(response.Positions) >= int(r.PositionLimit) { - break - } - if pos[i].Status == order.Open { - var tick *ticker.Price - tick, err = exch.FetchTicker(ctx, pos[i].Pair, pos[i].Asset) - if err != nil { - return nil, fmt.Errorf("%w when fetching ticker data for %v %v %v %v", err, pos[i].Exchange, pos[i].Asset, pos[i].Pair, subAccount) - } - pos[i].UnrealisedPNL, err = s.OrderManager.UpdateOpenPositionUnrealisedPNL(pos[i].Exchange, pos[i].Asset, pos[i].Pair, tick.Last, tick.LastUpdated) - if err != nil { - return nil, fmt.Errorf("%w when updating unrealised PNL for %v %v %v %v", err, pos[i].Exchange, pos[i].Asset, pos[i].Pair, subAccount) - } - pos[i].LatestPrice = decimal.NewFromFloat(tick.Last) - } - response.TotalOrders += int64(len(pos[i].Orders)) + response := &gctrpc.GetFuturesPositionsOrdersResponse{} + positions := make([]*gctrpc.FuturePosition, len(positionDetails)) + var anyOrders bool + for i := range positionDetails { details := &gctrpc.FuturePosition{ - Exchange: pos[i].Exchange, - Asset: pos[i].Asset.String(), + Exchange: exch.GetName(), + Asset: positionDetails[i].Asset.String(), Pair: &gctrpc.CurrencyPair{ - Delimiter: pos[i].Pair.Delimiter, - Base: pos[i].Pair.Base.String(), - Quote: pos[i].Pair.Quote.String(), + Delimiter: positionDetails[i].Pair.Delimiter, + Base: positionDetails[i].Pair.Base.String(), + Quote: positionDetails[i].Pair.Quote.String(), }, - Status: pos[i].Status.String(), - OpeningDate: pos[i].OpeningDate.Format(common.SimpleTimeFormatWithTimezone), - OpeningDirection: pos[i].OpeningDirection.String(), - OpeningPrice: pos[i].OpeningPrice.String(), - OpeningSize: pos[i].OpeningSize.String(), - CurrentDirection: pos[i].LatestDirection.String(), - CurrentPrice: pos[i].LatestPrice.String(), - CurrentSize: pos[i].LatestSize.String(), - UnrealisedPnl: pos[i].UnrealisedPNL.String(), - RealisedPnl: pos[i].RealisedPNL.String(), - OrderCount: int64(len(pos[i].Orders)), - } - if !pos[i].UnrealisedPNL.IsZero() { - details.UnrealisedPnl = pos[i].UnrealisedPNL.String() - } - if !pos[i].RealisedPNL.IsZero() { - details.RealisedPnl = pos[i].RealisedPNL.String() - } - if pos[i].LatestDirection != order.UnknownSide { - details.CurrentDirection = pos[i].LatestDirection.String() - } - if len(pos[i].PNLHistory) > 0 { - details.OpeningDate = pos[i].PNLHistory[0].Time.Format(common.SimpleTimeFormatWithTimezone) - if pos[i].Status == order.Closed { - details.ClosingDate = pos[i].PNLHistory[len(pos[i].PNLHistory)-1].Time.Format(common.SimpleTimeFormatWithTimezone) + Orders: make([]*gctrpc.OrderDetails, len(positionDetails[i].Orders)), + } + for j := range positionDetails[i].Orders { + anyOrders = true + details.Orders[j] = &gctrpc.OrderDetails{ + Exchange: exch.GetName(), + Id: positionDetails[i].Orders[j].OrderID, + ClientOrderId: positionDetails[i].Orders[j].ClientOrderID, + BaseCurrency: positionDetails[i].Orders[j].Pair.Base.String(), + QuoteCurrency: positionDetails[i].Orders[j].Pair.Quote.String(), + AssetType: positionDetails[i].Orders[j].AssetType.String(), + OrderSide: positionDetails[i].Orders[j].Side.String(), + OrderType: positionDetails[i].Orders[j].Type.String(), + CreationTime: positionDetails[i].Orders[j].Date.Format(common.SimpleTimeFormatWithTimezone), + UpdateTime: positionDetails[i].Orders[j].LastUpdated.Format(common.SimpleTimeFormatWithTimezone), + Status: positionDetails[i].Orders[j].Status.String(), + Price: positionDetails[i].Orders[j].Price, + Amount: positionDetails[i].Orders[j].Amount, + OpenVolume: positionDetails[i].Orders[j].RemainingAmount, + Fee: positionDetails[i].Orders[j].Fee, + Cost: positionDetails[i].Orders[j].Cost, } } - totalRealisedPNL = totalRealisedPNL.Add(pos[i].RealisedPNL) - totalUnrealisedPNL = totalUnrealisedPNL.Add(pos[i].UnrealisedPNL) - if r.GetPositionStats { - var stats *order.PositionSummary - stats, err = exch.GetPositionSummary(ctx, &order.PositionSummaryRequest{ - Asset: pos[i].Asset, - Pair: pos[i].Pair, - }) - if err != nil { - return nil, fmt.Errorf("cannot GetPositionSummary %w %v", err, subAccount) - } - details.PositionStats = &gctrpc.FuturesPositionStats{ - MaintenanceMarginRequirement: stats.MaintenanceMarginRequirement.String(), - InitialMarginRequirement: stats.InitialMarginRequirement.String(), - CollateralUsed: stats.CollateralUsed.String(), - MarkPrice: stats.MarkPrice.String(), - CurrentSize: stats.CurrentSize.String(), - BreakEvenPrice: stats.BreakEvenPrice.String(), - AverageOpenPrice: stats.AverageOpenPrice.String(), - RecentPnl: stats.RecentPNL.String(), - MarginFraction: stats.MarginFraction.String(), - FreeCollateral: stats.FreeCollateral.String(), - TotalCollateral: stats.TotalCollateral.String(), - } - if !stats.EstimatedLiquidationPrice.IsZero() { - details.PositionStats.EstimatedLiquidationPrice = stats.EstimatedLiquidationPrice.String() - } - } - if r.GetFundingPayments { - var endDate = time.Now() - if pos[i].Status == order.Closed { - endDate = pos[i].Orders[len(pos[i].Orders)-1].Date - } - var fundingDetails *fundingrate.Rates - fundingDetails, err = exch.GetFundingRates(ctx, &fundingrate.RatesRequest{ - Asset: pos[i].Asset, - Pair: pos[i].Pair, - StartDate: pos[i].Orders[0].Date, - EndDate: endDate, - IncludePayments: r.GetFundingPayments, - IncludePredictedRate: r.IncludePredictedRate, - }) - if err != nil { - return nil, err - } - var funding []*gctrpc.FundingRate - if r.IncludeFullFundingRates { - for j := range fundingDetails.FundingRates { - funding = append(funding, &gctrpc.FundingRate{ - Date: fundingDetails.FundingRates[j].Time.Format(common.SimpleTimeFormatWithTimezone), - Rate: fundingDetails.FundingRates[j].Rate.String(), - Payment: fundingDetails.FundingRates[j].Payment.String(), - }) - } - } - fundingRates := &gctrpc.FundingData{ - Rates: funding, - PaymentSum: fundingDetails.PaymentSum.String(), - } - if r.IncludeFullFundingRates { - fundingRates.LatestRate = funding[len(fundingRates.Rates)-1] - } - if r.IncludePredictedRate && !fundingDetails.PredictedUpcomingRate.Time.IsZero() { - fundingRates.UpcomingRate = &gctrpc.FundingRate{ - Date: fundingDetails.PredictedUpcomingRate.Time.Format(common.SimpleTimeFormatWithTimezone), - Rate: fundingDetails.PredictedUpcomingRate.Rate.String(), - } - } - details.FundingData = fundingRates - err = s.OrderManager.orderStore.futuresPositionController.TrackFundingDetails(fundingDetails) + positions[i] = details + } + if !anyOrders { + return &gctrpc.GetFuturesPositionsOrdersResponse{}, nil + } + response.Positions = positions + if r.SyncWithOrderManager { + for i := range positionDetails { + err = s.OrderManager.processFuturesPositions(exch, &positionDetails[i]) if err != nil { return nil, err } } - if !r.IncludeFullOrderData { - response.Positions = append(response.Positions, details) - continue - } - for j := range pos[i].Orders { - var trades []*gctrpc.TradeHistory - for k := range pos[i].Orders[j].Trades { - trades = append(trades, &gctrpc.TradeHistory{ - CreationTime: pos[i].Orders[j].Trades[k].Timestamp.Unix(), - Id: pos[i].Orders[j].Trades[k].TID, - Price: pos[i].Orders[j].Trades[k].Price, - Amount: pos[i].Orders[j].Trades[k].Amount, - Exchange: pos[i].Orders[j].Trades[k].Exchange, - AssetType: pos[i].Asset.String(), - OrderSide: pos[i].Orders[j].Trades[k].Side.String(), - Fee: pos[i].Orders[j].Trades[k].Fee, - Total: pos[i].Orders[j].Trades[k].Total, - }) - } - od := &gctrpc.OrderDetails{ - Exchange: pos[i].Orders[j].Exchange, - Id: pos[i].Orders[j].OrderID, - ClientOrderId: pos[i].Orders[j].ClientOrderID, - BaseCurrency: pos[i].Orders[j].Pair.Base.String(), - QuoteCurrency: pos[i].Orders[j].Pair.Quote.String(), - AssetType: pos[i].Orders[j].AssetType.String(), - OrderSide: pos[i].Orders[j].Side.String(), - OrderType: pos[i].Orders[j].Type.String(), - CreationTime: pos[i].Orders[j].Date.Format(common.SimpleTimeFormatWithTimezone), - Status: pos[i].Orders[j].Status.String(), - Price: pos[i].Orders[j].Price, - Amount: pos[i].Orders[j].Amount, - Fee: pos[i].Orders[j].Fee, - Cost: pos[i].Orders[j].Cost, - Trades: trades, - } - if pos[i].Orders[j].LastUpdated.After(pos[i].Orders[j].Date) { - od.UpdateTime = pos[i].Orders[j].LastUpdated.Format(common.SimpleTimeFormatWithTimezone) - } - details.Orders = append(details.Orders, od) - } - response.Positions = append(response.Positions, details) - } - - if !totalUnrealisedPNL.IsZero() { - response.TotalUnrealisedPnl = totalUnrealisedPNL.String() - } - if !totalRealisedPNL.IsZero() { - response.TotalRealisedPnl = totalRealisedPNL.String() - } - if !totalUnrealisedPNL.IsZero() && !totalRealisedPNL.IsZero() { - response.TotalPnl = totalRealisedPNL.Add(totalUnrealisedPNL).String() } return response, nil } @@ -4649,13 +4638,16 @@ func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuture // GetFundingRates returns the funding rates for an exchange, asset, pair func (s *RPCServer) GetFundingRates(ctx context.Context, r *gctrpc.GetFundingRatesRequest) (*gctrpc.GetFundingRatesResponse, error) { if r == nil { - return nil, fmt.Errorf("%w GetFundingRateRequest", common.ErrNilPointer) + return nil, fmt.Errorf("%w GetFundingRatesRequest", common.ErrNilPointer) } exch, err := s.GetExchangeByName(r.Exchange) if err != nil { return nil, err } - + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.FundingRates { + return nil, fmt.Errorf("%w FundingRates for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } a, err := asset.New(r.Asset) if err != nil { return nil, err @@ -4826,6 +4818,10 @@ func (s *RPCServer) GetCollateral(ctx context.Context, r *gctrpc.GetCollateralRe if err != nil { return nil, err } + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.Collateral { + return nil, fmt.Errorf("%w Get Collateral for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } a, err := asset.New(r.Asset) if err != nil { @@ -4914,128 +4910,128 @@ func (s *RPCServer) GetCollateral(ctx context.Context, r *gctrpc.GetCollateralRe FetchPositions: true, } - collateral, err := exch.CalculateTotalCollateral(ctx, calc) + c, err := exch.CalculateTotalCollateral(ctx, calc) if err != nil { return nil, err } - var collateralDisplayCurrency = " " + collateral.CollateralCurrency.String() + var collateralDisplayCurrency = " " + c.CollateralCurrency.String() result := &gctrpc.GetCollateralResponse{ SubAccount: creds.SubAccount, - CollateralCurrency: collateral.CollateralCurrency.String(), - AvailableCollateral: collateral.AvailableCollateral.String() + collateralDisplayCurrency, - UsedCollateral: collateral.UsedCollateral.String() + collateralDisplayCurrency, + CollateralCurrency: c.CollateralCurrency.String(), + AvailableCollateral: c.AvailableCollateral.String() + collateralDisplayCurrency, + UsedCollateral: c.UsedCollateral.String() + collateralDisplayCurrency, } - if !collateral.CollateralContributedByPositiveSpotBalances.IsZero() { - result.CollateralContributedByPositiveSpotBalances = collateral.CollateralContributedByPositiveSpotBalances.String() + collateralDisplayCurrency + if !c.CollateralContributedByPositiveSpotBalances.IsZero() { + result.CollateralContributedByPositiveSpotBalances = c.CollateralContributedByPositiveSpotBalances.String() + collateralDisplayCurrency } - if !collateral.TotalValueOfPositiveSpotBalances.IsZero() { - result.TotalValueOfPositiveSpotBalances = collateral.TotalValueOfPositiveSpotBalances.String() + collateralDisplayCurrency + if !c.TotalValueOfPositiveSpotBalances.IsZero() { + result.TotalValueOfPositiveSpotBalances = c.TotalValueOfPositiveSpotBalances.String() + collateralDisplayCurrency } - if !collateral.AvailableMaintenanceCollateral.IsZero() { - result.MaintenanceCollateral = collateral.AvailableMaintenanceCollateral.String() + collateralDisplayCurrency + if !c.AvailableMaintenanceCollateral.IsZero() { + result.MaintenanceCollateral = c.AvailableMaintenanceCollateral.String() + collateralDisplayCurrency } - if !collateral.UnrealisedPNL.IsZero() { - result.UnrealisedPnl = collateral.UnrealisedPNL.String() + if !c.UnrealisedPNL.IsZero() { + result.UnrealisedPnl = c.UnrealisedPNL.String() } - if collateral.UsedBreakdown != nil { + if c.UsedBreakdown != nil { result.UsedBreakdown = &gctrpc.CollateralUsedBreakdown{} - if !collateral.UsedBreakdown.LockedInStakes.IsZero() { - result.UsedBreakdown.LockedInStakes = collateral.UsedBreakdown.LockedInStakes.String() + collateralDisplayCurrency + if !c.UsedBreakdown.LockedInStakes.IsZero() { + result.UsedBreakdown.LockedInStakes = c.UsedBreakdown.LockedInStakes.String() + collateralDisplayCurrency } - if !collateral.UsedBreakdown.LockedInNFTBids.IsZero() { - result.UsedBreakdown.LockedInNftBids = collateral.UsedBreakdown.LockedInNFTBids.String() + collateralDisplayCurrency + if !c.UsedBreakdown.LockedInNFTBids.IsZero() { + result.UsedBreakdown.LockedInNftBids = c.UsedBreakdown.LockedInNFTBids.String() + collateralDisplayCurrency } - if !collateral.UsedBreakdown.LockedInFeeVoucher.IsZero() { - result.UsedBreakdown.LockedInFeeVoucher = collateral.UsedBreakdown.LockedInFeeVoucher.String() + collateralDisplayCurrency + if !c.UsedBreakdown.LockedInFeeVoucher.IsZero() { + result.UsedBreakdown.LockedInFeeVoucher = c.UsedBreakdown.LockedInFeeVoucher.String() + collateralDisplayCurrency } - if !collateral.UsedBreakdown.LockedInSpotMarginFundingOffers.IsZero() { - result.UsedBreakdown.LockedInSpotMarginFundingOffers = collateral.UsedBreakdown.LockedInSpotMarginFundingOffers.String() + collateralDisplayCurrency + if !c.UsedBreakdown.LockedInSpotMarginFundingOffers.IsZero() { + result.UsedBreakdown.LockedInSpotMarginFundingOffers = c.UsedBreakdown.LockedInSpotMarginFundingOffers.String() + collateralDisplayCurrency } - if !collateral.UsedBreakdown.LockedInSpotOrders.IsZero() { - result.UsedBreakdown.LockedInSpotOrders = collateral.UsedBreakdown.LockedInSpotOrders.String() + collateralDisplayCurrency + if !c.UsedBreakdown.LockedInSpotOrders.IsZero() { + result.UsedBreakdown.LockedInSpotOrders = c.UsedBreakdown.LockedInSpotOrders.String() + collateralDisplayCurrency } - if !collateral.UsedBreakdown.LockedAsCollateral.IsZero() { - result.UsedBreakdown.LockedAsCollateral = collateral.UsedBreakdown.LockedAsCollateral.String() + collateralDisplayCurrency + if !c.UsedBreakdown.LockedAsCollateral.IsZero() { + result.UsedBreakdown.LockedAsCollateral = c.UsedBreakdown.LockedAsCollateral.String() + collateralDisplayCurrency } - if !collateral.UsedBreakdown.UsedInPositions.IsZero() { - result.UsedBreakdown.UsedInFutures = collateral.UsedBreakdown.UsedInPositions.String() + collateralDisplayCurrency + if !c.UsedBreakdown.UsedInPositions.IsZero() { + result.UsedBreakdown.UsedInFutures = c.UsedBreakdown.UsedInPositions.String() + collateralDisplayCurrency } - if !collateral.UsedBreakdown.UsedInSpotMarginBorrows.IsZero() { - result.UsedBreakdown.UsedInSpotMargin = collateral.UsedBreakdown.UsedInSpotMarginBorrows.String() + collateralDisplayCurrency + if !c.UsedBreakdown.UsedInSpotMarginBorrows.IsZero() { + result.UsedBreakdown.UsedInSpotMargin = c.UsedBreakdown.UsedInSpotMarginBorrows.String() + collateralDisplayCurrency } } if r.IncludeBreakdown { - for i := range collateral.BreakdownOfPositions { + for i := range c.BreakdownOfPositions { result.PositionBreakdown = append(result.PositionBreakdown, &gctrpc.CollateralByPosition{ - Currency: collateral.BreakdownOfPositions[i].PositionCurrency.String(), - Size: collateral.BreakdownOfPositions[i].Size.String(), - OpenOrderSize: collateral.BreakdownOfPositions[i].OpenOrderSize.String(), - PositionSize: collateral.BreakdownOfPositions[i].PositionSize.String(), - MarkPrice: collateral.BreakdownOfPositions[i].MarkPrice.String() + collateralDisplayCurrency, - RequiredMargin: collateral.BreakdownOfPositions[i].RequiredMargin.String(), - TotalCollateralUsed: collateral.BreakdownOfPositions[i].CollateralUsed.String() + collateralDisplayCurrency, + Currency: c.BreakdownOfPositions[i].PositionCurrency.String(), + Size: c.BreakdownOfPositions[i].Size.String(), + OpenOrderSize: c.BreakdownOfPositions[i].OpenOrderSize.String(), + PositionSize: c.BreakdownOfPositions[i].PositionSize.String(), + MarkPrice: c.BreakdownOfPositions[i].MarkPrice.String() + collateralDisplayCurrency, + RequiredMargin: c.BreakdownOfPositions[i].RequiredMargin.String(), + TotalCollateralUsed: c.BreakdownOfPositions[i].CollateralUsed.String() + collateralDisplayCurrency, }) } - for i := range collateral.BreakdownByCurrency { - if collateral.BreakdownByCurrency[i].TotalFunds.IsZero() && !r.IncludeZeroValues { + for i := range c.BreakdownByCurrency { + if c.BreakdownByCurrency[i].TotalFunds.IsZero() && !r.IncludeZeroValues { continue } - var originalDisplayCurrency = " " + collateral.BreakdownByCurrency[i].Currency.String() + var originalDisplayCurrency = " " + c.BreakdownByCurrency[i].Currency.String() cb := &gctrpc.CollateralForCurrency{ - Currency: collateral.BreakdownByCurrency[i].Currency.String(), - ExcludedFromCollateral: collateral.BreakdownByCurrency[i].SkipContribution, - TotalFunds: collateral.BreakdownByCurrency[i].TotalFunds.String() + originalDisplayCurrency, - AvailableForUseAsCollateral: collateral.BreakdownByCurrency[i].AvailableForUseAsCollateral.String() + originalDisplayCurrency, - ApproxFairMarketValue: collateral.BreakdownByCurrency[i].FairMarketValue.String() + collateralDisplayCurrency, - Weighting: collateral.BreakdownByCurrency[i].Weighting.String(), - CollateralContribution: collateral.BreakdownByCurrency[i].CollateralContribution.String() + collateralDisplayCurrency, - ScaledToCurrency: collateral.BreakdownByCurrency[i].ScaledCurrency.String(), + Currency: c.BreakdownByCurrency[i].Currency.String(), + ExcludedFromCollateral: c.BreakdownByCurrency[i].SkipContribution, + TotalFunds: c.BreakdownByCurrency[i].TotalFunds.String() + originalDisplayCurrency, + AvailableForUseAsCollateral: c.BreakdownByCurrency[i].AvailableForUseAsCollateral.String() + originalDisplayCurrency, + ApproxFairMarketValue: c.BreakdownByCurrency[i].FairMarketValue.String() + collateralDisplayCurrency, + Weighting: c.BreakdownByCurrency[i].Weighting.String(), + CollateralContribution: c.BreakdownByCurrency[i].CollateralContribution.String() + collateralDisplayCurrency, + ScaledToCurrency: c.BreakdownByCurrency[i].ScaledCurrency.String(), } - if !collateral.BreakdownByCurrency[i].AdditionalCollateralUsed.IsZero() { - cb.AdditionalCollateralUsed = collateral.BreakdownByCurrency[i].AdditionalCollateralUsed.String() + collateralDisplayCurrency + if !c.BreakdownByCurrency[i].AdditionalCollateralUsed.IsZero() { + cb.AdditionalCollateralUsed = c.BreakdownByCurrency[i].AdditionalCollateralUsed.String() + collateralDisplayCurrency } - if !collateral.BreakdownByCurrency[i].ScaledUsed.IsZero() { - cb.FundsInUse = collateral.BreakdownByCurrency[i].ScaledUsed.String() + collateralDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsed.IsZero() { + cb.FundsInUse = c.BreakdownByCurrency[i].ScaledUsed.String() + collateralDisplayCurrency } - if !collateral.BreakdownByCurrency[i].UnrealisedPNL.IsZero() { - cb.UnrealisedPnl = collateral.BreakdownByCurrency[i].UnrealisedPNL.String() + collateralDisplayCurrency + if !c.BreakdownByCurrency[i].UnrealisedPNL.IsZero() { + cb.UnrealisedPnl = c.BreakdownByCurrency[i].UnrealisedPNL.String() + collateralDisplayCurrency } - if collateral.BreakdownByCurrency[i].ScaledUsedBreakdown != nil { + if c.BreakdownByCurrency[i].ScaledUsedBreakdown != nil { breakDownDisplayCurrency := collateralDisplayCurrency - if collateral.BreakdownByCurrency[i].Weighting.IsZero() && collateral.BreakdownByCurrency[i].FairMarketValue.IsZero() { + if c.BreakdownByCurrency[i].Weighting.IsZero() && c.BreakdownByCurrency[i].FairMarketValue.IsZero() { // cannot determine value, show in like currency instead breakDownDisplayCurrency = originalDisplayCurrency } cb.UsedBreakdown = &gctrpc.CollateralUsedBreakdown{} - if !collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInStakes.IsZero() { - cb.UsedBreakdown.LockedInStakes = collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInStakes.String() + breakDownDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInStakes.IsZero() { + cb.UsedBreakdown.LockedInStakes = c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInStakes.String() + breakDownDisplayCurrency } - if !collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInNFTBids.IsZero() { - cb.UsedBreakdown.LockedInNftBids = collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInNFTBids.String() + breakDownDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInNFTBids.IsZero() { + cb.UsedBreakdown.LockedInNftBids = c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInNFTBids.String() + breakDownDisplayCurrency } - if !collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInFeeVoucher.IsZero() { - cb.UsedBreakdown.LockedInFeeVoucher = collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInFeeVoucher.String() + breakDownDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInFeeVoucher.IsZero() { + cb.UsedBreakdown.LockedInFeeVoucher = c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInFeeVoucher.String() + breakDownDisplayCurrency } - if !collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInSpotMarginFundingOffers.IsZero() { - cb.UsedBreakdown.LockedInSpotMarginFundingOffers = collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInSpotMarginFundingOffers.String() + breakDownDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInSpotMarginFundingOffers.IsZero() { + cb.UsedBreakdown.LockedInSpotMarginFundingOffers = c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInSpotMarginFundingOffers.String() + breakDownDisplayCurrency } - if !collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInSpotOrders.IsZero() { - cb.UsedBreakdown.LockedInSpotOrders = collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInSpotOrders.String() + breakDownDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInSpotOrders.IsZero() { + cb.UsedBreakdown.LockedInSpotOrders = c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedInSpotOrders.String() + breakDownDisplayCurrency } - if !collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedAsCollateral.IsZero() { - cb.UsedBreakdown.LockedAsCollateral = collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedAsCollateral.String() + breakDownDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedAsCollateral.IsZero() { + cb.UsedBreakdown.LockedAsCollateral = c.BreakdownByCurrency[i].ScaledUsedBreakdown.LockedAsCollateral.String() + breakDownDisplayCurrency } - if !collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.UsedInPositions.IsZero() { - cb.UsedBreakdown.UsedInFutures = collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.UsedInPositions.String() + breakDownDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsedBreakdown.UsedInPositions.IsZero() { + cb.UsedBreakdown.UsedInFutures = c.BreakdownByCurrency[i].ScaledUsedBreakdown.UsedInPositions.String() + breakDownDisplayCurrency } - if !collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.UsedInSpotMarginBorrows.IsZero() { - cb.UsedBreakdown.UsedInSpotMargin = collateral.BreakdownByCurrency[i].ScaledUsedBreakdown.UsedInSpotMarginBorrows.String() + breakDownDisplayCurrency + if !c.BreakdownByCurrency[i].ScaledUsedBreakdown.UsedInSpotMarginBorrows.IsZero() { + cb.UsedBreakdown.UsedInSpotMargin = c.BreakdownByCurrency[i].ScaledUsedBreakdown.UsedInSpotMarginBorrows.String() + breakDownDisplayCurrency } } - if collateral.BreakdownByCurrency[i].Error != nil { - cb.Error = collateral.BreakdownByCurrency[i].Error.Error() + if c.BreakdownByCurrency[i].Error != nil { + cb.Error = c.BreakdownByCurrency[i].Error.Error() } result.CurrencyBreakdown = append(result.CurrencyBreakdown, cb) } @@ -5220,7 +5216,7 @@ func (s *RPCServer) GetTechnicalAnalysis(ctx context.Context, r *gctrpc.GetTechn // GetMarginRatesHistory returns the margin lending or borrow rates for an exchange, asset, currency along with many customisable options func (s *RPCServer) GetMarginRatesHistory(ctx context.Context, r *gctrpc.GetMarginRatesHistoryRequest) (*gctrpc.GetMarginRatesHistoryResponse, error) { if r == nil { - return nil, fmt.Errorf("%w GetLendingRatesRequest", common.ErrNilPointer) + return nil, fmt.Errorf("%w GetMarginRatesHistoryRequest", common.ErrNilPointer) } exch, err := s.GetExchangeByName(r.Exchange) if err != nil { @@ -5618,3 +5614,310 @@ func (s *RPCServer) GetOrderbookAmountByImpact(_ context.Context, r *gctrpc.GetO AverageOrderCost: impact.AverageOrderCost, }, nil } + +// GetCollateralMode returns the collateral type for the account asset +func (s *RPCServer) GetCollateralMode(ctx context.Context, r *gctrpc.GetCollateralModeRequest) (*gctrpc.GetCollateralModeResponse, error) { + if r == nil { + return nil, fmt.Errorf("%w GetCollateralModeRequest", common.ErrNilPointer) + } + exch, err := s.GetExchangeByName(r.Exchange) + if err != nil { + return nil, err + } + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.CollateralMode { + return nil, fmt.Errorf("%w GetCollateralMode for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } + + item, err := asset.New(r.Asset) + if err != nil { + return nil, err + } + if !exch.IsEnabled() { + return nil, fmt.Errorf("%s %w", exch.GetName(), errExchangeNotEnabled) + } + if !item.IsValid() { + return nil, fmt.Errorf("%w %v", asset.ErrNotSupported, r.Asset) + } + b := exch.GetBase() + if b == nil { + return nil, fmt.Errorf("%s %w", exch.GetName(), errExchangeBaseNotFound) + } + err = b.CurrencyPairs.IsAssetEnabled(item) + if err != nil { + return nil, err + } + collateralMode, err := exch.GetCollateralMode(ctx, item) + if err != nil { + return nil, err + } + return &gctrpc.GetCollateralModeResponse{ + Exchange: r.Exchange, + Asset: r.Asset, + CollateralMode: collateralMode.String(), + }, nil +} + +// SetCollateralMode sets the collateral type for the account asset +func (s *RPCServer) SetCollateralMode(ctx context.Context, r *gctrpc.SetCollateralModeRequest) (*gctrpc.SetCollateralModeResponse, error) { + if r == nil { + return nil, fmt.Errorf("%w SetCollateralModeRequest", common.ErrNilPointer) + } + exch, err := s.GetExchangeByName(r.Exchange) + if err != nil { + return nil, err + } + if !exch.IsEnabled() { + return nil, fmt.Errorf("%s %w", exch.GetName(), errExchangeNotEnabled) + } + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.CollateralMode { + return nil, fmt.Errorf("%w SetCollateralMode for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } + item, err := asset.New(r.Asset) + if err != nil { + return nil, err + } + b := exch.GetBase() + if b == nil { + return nil, fmt.Errorf("%s %w", exch.GetName(), errExchangeBaseNotFound) + } + err = b.CurrencyPairs.IsAssetEnabled(item) + if err != nil { + return nil, fmt.Errorf("%v %w", item, err) + } + cm, err := collateral.StringToMode(r.CollateralMode) + if err != nil { + return nil, fmt.Errorf("%w %v", order.ErrCollateralInvalid, r.CollateralMode) + } + err = exch.SetCollateralMode(ctx, item, cm) + if err != nil { + return nil, err + } + return &gctrpc.SetCollateralModeResponse{ + Exchange: r.Exchange, + Asset: r.Asset, + Success: true, + }, nil +} + +// SetMarginType sets the margin type for the account asset pair +func (s *RPCServer) SetMarginType(ctx context.Context, r *gctrpc.SetMarginTypeRequest) (*gctrpc.SetMarginTypeResponse, error) { + if r == nil { + return nil, fmt.Errorf("%w SetMarginTypeRequest", common.ErrNilPointer) + } + if r.Pair == nil { + return nil, currency.ErrCurrencyPairEmpty + } + exch, err := s.GetExchangeByName(r.Exchange) + if err != nil { + return nil, err + } + if !exch.IsEnabled() { + return nil, fmt.Errorf("%s %w", r.Exchange, errExchangeNotEnabled) + } + ai, err := asset.New(r.Asset) + if err != nil { + return nil, err + } + enabledPairs, err := exch.GetEnabledPairs(ai) + if err != nil { + return nil, err + } + cp, err := enabledPairs.DeriveFrom(r.Pair.Base + r.Pair.Quote) + if err != nil { + return nil, err + } + + mt, err := margin.StringToMarginType(r.MarginType) + if err != nil { + return nil, err + } + + err = exch.SetMarginType(ctx, ai, cp, mt) + if err != nil { + return nil, err + } + + return &gctrpc.SetMarginTypeResponse{ + Exchange: r.Exchange, + Asset: r.Asset, + Pair: r.Pair, + Success: true, + }, nil +} + +// GetLeverage returns the leverage for the account asset pair +func (s *RPCServer) GetLeverage(ctx context.Context, r *gctrpc.GetLeverageRequest) (*gctrpc.GetLeverageResponse, error) { + if r == nil { + return nil, fmt.Errorf("%w GetLeverageRequest", common.ErrNilPointer) + } + if r.Pair == nil { + return nil, currency.ErrCurrencyPairEmpty + } + exch, err := s.GetExchangeByName(r.Exchange) + if err != nil { + return nil, err + } + if !exch.IsEnabled() { + return nil, fmt.Errorf("%s %w", r.Exchange, errExchangeNotEnabled) + } + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.Leverage { + return nil, fmt.Errorf("%w futures position tracking for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } + ai, err := asset.New(r.Asset) + if err != nil { + return nil, err + } + enabledPairs, err := exch.GetEnabledPairs(ai) + if err != nil { + return nil, err + } + cp, err := enabledPairs.DeriveFrom(r.Pair.Base + r.Pair.Quote) + if err != nil { + return nil, err + } + + mt, err := margin.StringToMarginType(r.MarginType) + if err != nil { + return nil, err + } + + var orderSide order.Side + if r.OrderSide != "" { + orderSide, err = order.StringToOrderSide(r.OrderSide) + if err != nil { + return nil, err + } + } + + leverage, err := exch.GetLeverage(ctx, ai, cp, mt, orderSide) + if err != nil { + return nil, err + } + + return &gctrpc.GetLeverageResponse{ + Exchange: r.Exchange, + Asset: r.Asset, + Pair: r.Pair, + MarginType: r.MarginType, + Leverage: leverage, + OrderSide: r.OrderSide, + }, nil +} + +// SetLeverage sets the leverage for the account asset pair +func (s *RPCServer) SetLeverage(ctx context.Context, r *gctrpc.SetLeverageRequest) (*gctrpc.SetLeverageResponse, error) { + if r == nil { + return nil, fmt.Errorf("%w SetLeverageRequest", common.ErrNilPointer) + } + if r.Pair == nil { + return nil, currency.ErrCurrencyPairEmpty + } + exch, err := s.GetExchangeByName(r.Exchange) + if err != nil { + return nil, err + } + if !exch.IsEnabled() { + return nil, fmt.Errorf("%s %w", r.Exchange, errExchangeNotEnabled) + } + feat := exch.GetSupportedFeatures() + if !feat.FuturesCapabilities.Leverage { + return nil, fmt.Errorf("%w futures position tracking for exchange %v", common.ErrFunctionNotSupported, exch.GetName()) + } + ai, err := asset.New(r.Asset) + if err != nil { + return nil, err + } + enabledPairs, err := exch.GetEnabledPairs(ai) + if err != nil { + return nil, err + } + cp, err := enabledPairs.DeriveFrom(r.Pair.Base + r.Pair.Quote) + if err != nil { + return nil, err + } + + mt, err := margin.StringToMarginType(r.MarginType) + if err != nil { + return nil, err + } + + var orderSide order.Side + if r.OrderSide != "" { + orderSide, err = order.StringToOrderSide(r.OrderSide) + if err != nil { + return nil, err + } + } + + err = exch.SetLeverage(ctx, ai, cp, mt, r.Leverage, orderSide) + if err != nil { + return nil, err + } + + return &gctrpc.SetLeverageResponse{ + Exchange: r.Exchange, + Asset: r.Asset, + Pair: r.Pair, + MarginType: r.MarginType, + OrderSide: r.OrderSide, + Success: true, + }, nil +} + +// ChangePositionMargin sets a position's margin +func (s *RPCServer) ChangePositionMargin(ctx context.Context, r *gctrpc.ChangePositionMarginRequest) (*gctrpc.ChangePositionMarginResponse, error) { + if r == nil { + return nil, fmt.Errorf("%w ChangePositionMarginRequest", common.ErrNilPointer) + } + if r.Pair == nil { + return nil, currency.ErrCurrencyPairEmpty + } + exch, err := s.GetExchangeByName(r.Exchange) + if err != nil { + return nil, err + } + if !exch.IsEnabled() { + return nil, fmt.Errorf("%s %w", r.Exchange, errExchangeNotEnabled) + } + ai, err := asset.New(r.Asset) + if err != nil { + return nil, err + } + enabledPairs, err := exch.GetEnabledPairs(ai) + if err != nil { + return nil, err + } + cp, err := enabledPairs.DeriveFrom(r.Pair.Base + r.Pair.Quote) + if err != nil { + return nil, err + } + + mt, err := margin.StringToMarginType(r.MarginType) + if err != nil { + return nil, err + } + resp, err := exch.ChangePositionMargin(ctx, &margin.PositionChangeRequest{ + Exchange: exch.GetName(), + Pair: cp, + Asset: ai, + MarginType: mt, + OriginalAllocatedMargin: r.OriginalAllocatedMargin, + NewAllocatedMargin: r.NewAllocatedMargin, + MarginSide: r.MarginSide, + }) + if err != nil { + return nil, err + } + + return &gctrpc.ChangePositionMarginResponse{ + Exchange: r.Exchange, + Asset: r.Asset, + Pair: r.Pair, + MarginType: r.MarginType, + NewAllocatedMargin: resp.AllocatedMargin, + MarginSide: r.MarginSide, + }, nil +} diff --git a/engine/rpcserver_test.go b/engine/rpcserver_test.go index b0ea29f120a..6ce9eac773a 100644 --- a/engine/rpcserver_test.go +++ b/engine/rpcserver_test.go @@ -28,6 +28,7 @@ import ( "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" "github.com/thrasher-corp/gocryptotrader/exchanges/binance" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/currencystate" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" @@ -58,7 +59,7 @@ type fExchange struct { exchange.IBotExchange } -func (f fExchange) GetPositionSummary(context.Context, *order.PositionSummaryRequest) (*order.PositionSummary, error) { +func (f fExchange) GetFuturesPositionSummary(context.Context, *order.PositionSummaryRequest) (*order.PositionSummary, error) { leet := decimal.NewFromInt(1337) return &order.PositionSummary{ MaintenanceMarginRequirement: leet, @@ -67,27 +68,55 @@ func (f fExchange) GetPositionSummary(context.Context, *order.PositionSummaryReq CollateralUsed: leet, MarkPrice: leet, CurrentSize: leet, - BreakEvenPrice: leet, AverageOpenPrice: leet, - RecentPNL: leet, - MarginFraction: leet, + PositionPNL: leet, + MaintenanceMarginFraction: leet, FreeCollateral: leet, TotalCollateral: leet, }, nil } -func (f fExchange) GetFuturesPositions(_ context.Context, req *order.PositionsRequest) ([]order.PositionDetails, error) { +func (f fExchange) ChangePositionMargin(_ context.Context, req *margin.PositionChangeRequest) (*margin.PositionChangeResponse, error) { + return &margin.PositionChangeResponse{ + Exchange: f.GetName(), + Pair: req.Pair, + Asset: req.Asset, + AllocatedMargin: req.NewAllocatedMargin, + MarginType: req.MarginType, + }, nil +} + +func (f fExchange) SetLeverage(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type, _ float64, _ order.Side) error { + return nil +} + +func (f fExchange) GetLeverage(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type, _ order.Side) (float64, error) { + return 1337, nil +} + +func (f fExchange) SetMarginType(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type) error { + return nil +} + +func (f fExchange) SetCollateralMode(_ context.Context, _ asset.Item, _ collateral.Mode) error { + return nil +} + +func (f fExchange) GetCollateralMode(_ context.Context, _ asset.Item) (collateral.Mode, error) { + return collateral.SingleMode, nil +} + +func (f fExchange) GetFuturesPositionOrders(_ context.Context, req *order.PositionsRequest) ([]order.PositionResponse, error) { id, err := uuid.NewV4() if err != nil { return nil, err } - resp := make([]order.PositionDetails, len(req.Pairs)) + resp := make([]order.PositionResponse, len(req.Pairs)) tt := time.Now() for i := range req.Pairs { - resp[i] = order.PositionDetails{ - Exchange: f.GetName(), - Asset: req.Asset, - Pair: req.Pairs[i], + resp[i] = order.PositionResponse{ + Asset: req.Asset, + Pair: req.Pairs[i], Orders: []order.Detail{ { Exchange: f.GetName(), @@ -288,7 +317,7 @@ func (f fExchange) CalculateTotalCollateral(context.Context, *order.TotalCollate CollateralCurrency: currency.USD, AvailableMaintenanceCollateral: decimal.NewFromInt(1338), AvailableCollateral: decimal.NewFromInt(1337), - UsedBreakdown: &order.UsedCollateralBreakdown{ + UsedBreakdown: &collateral.UsedBreakdown{ LockedInStakes: decimal.NewFromInt(3), LockedInNFTBids: decimal.NewFromInt(3), LockedInFeeVoucher: decimal.NewFromInt(3), @@ -296,7 +325,7 @@ func (f fExchange) CalculateTotalCollateral(context.Context, *order.TotalCollate LockedInSpotOrders: decimal.NewFromInt(3), LockedAsCollateral: decimal.NewFromInt(3), }, - BreakdownByCurrency: []order.CollateralByCurrency{ + BreakdownByCurrency: []collateral.ByCurrency{ { Currency: currency.USD, TotalFunds: decimal.NewFromInt(1330), @@ -307,7 +336,7 @@ func (f fExchange) CalculateTotalCollateral(context.Context, *order.TotalCollate Currency: currency.DOGE, TotalFunds: decimal.NewFromInt(1000), ScaledUsed: decimal.NewFromInt(6), - ScaledUsedBreakdown: &order.UsedCollateralBreakdown{ + ScaledUsedBreakdown: &collateral.UsedBreakdown{ LockedInStakes: decimal.NewFromInt(1), LockedInNFTBids: decimal.NewFromInt(1), LockedInFeeVoucher: decimal.NewFromInt(1), @@ -332,7 +361,7 @@ func (f fExchange) CalculateTotalCollateral(context.Context, *order.TotalCollate // to do the bare minimum required with no API calls or credentials required func (f fExchange) UpdateAccountInfo(_ context.Context, a asset.Item) (account.Holdings, error) { if a == asset.Futures { - return account.Holdings{}, errAssetTypeDisabled + return account.Holdings{}, asset.ErrNotSupported } return account.Holdings{ Exchange: f.GetName(), @@ -1249,8 +1278,8 @@ func TestUpdateAccountInfo(t *testing.T) { } _, err = s.UpdateAccountInfo(context.Background(), &gctrpc.GetAccountInfoRequest{Exchange: fakeExchangeName, AssetType: asset.Futures.String()}) - if !errors.Is(err, errAssetTypeDisabled) { - t.Errorf("received '%v', expected '%v'", err, errAssetTypeDisabled) + if !errors.Is(err, currency.ErrAssetNotFound) { + t.Errorf("received '%v', expected '%v'", err, currency.ErrAssetNotFound) } _, err = s.UpdateAccountInfo(context.Background(), &gctrpc.GetAccountInfoRequest{ @@ -1286,7 +1315,7 @@ func TestGetOrders(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - om, err := SetupOrderManager(em, engerino.CommunicationsManager, &wg, false, false, 0) + om, err := SetupOrderManager(em, engerino.CommunicationsManager, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -1396,7 +1425,7 @@ func TestGetOrder(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - om, err := SetupOrderManager(em, engerino.CommunicationsManager, &wg, false, false, 0) + om, err := SetupOrderManager(em, engerino.CommunicationsManager, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -1483,8 +1512,8 @@ func TestCheckVars(t *testing.T) { e.SetEnabled(true) err = checkParams("Binance", e, asset.Spot, currency.NewPair(currency.BTC, currency.USDT)) - if !errors.Is(err, errAssetTypeDisabled) { - t.Errorf("expected %v, got %v", errAssetTypeDisabled, err) + if !errors.Is(err, currency.ErrPairManagerNotInitialised) { + t.Errorf("expected %v, got %v", currency.ErrPairManagerNotInitialised, err) } fmt1 := currency.PairStore{ @@ -1935,7 +1964,7 @@ func TestGetManagedOrders(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - om, err := SetupOrderManager(em, engerino.CommunicationsManager, &wg, false, false, 0) + om, err := SetupOrderManager(em, engerino.CommunicationsManager, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -2256,7 +2285,7 @@ func TestCurrencyStateTradingPair(t *testing.T) { } } -func TestGetFuturesPositions(t *testing.T) { +func TestGetFuturesPositionsOrders(t *testing.T) { t.Parallel() em := NewExchangeManager() exch, err := em.NewExchangeByName("binance") @@ -2297,7 +2326,7 @@ func TestGetFuturesPositions(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, time.Hour) + om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -2313,61 +2342,7 @@ func TestGetFuturesPositions(t *testing.T) { }, } - _, err = s.GetFuturesPositions(context.Background(), &gctrpc.GetFuturesPositionsRequest{ - Exchange: fakeExchangeName, - Asset: asset.Futures.String(), - Pair: &gctrpc.CurrencyPair{ - Delimiter: currency.DashDelimiter, - Base: cp.Base.String(), - Quote: cp.Quote.String(), - }, - }) - if !errors.Is(err, exchange.ErrCredentialsAreEmpty) { - t.Fatalf("received '%v', expected '%v'", err, exchange.ErrCredentialsAreEmpty) - } - - ctx := account.DeployCredentialsToContext(context.Background(), - &account.Credentials{ - Key: "wow", - Secret: "super wow", - }, - ) - - _, err = s.GetFuturesPositions(ctx, &gctrpc.GetFuturesPositionsRequest{ - Exchange: "test", - Asset: asset.Futures.String(), - Pair: &gctrpc.CurrencyPair{ - Delimiter: currency.DashDelimiter, - Base: cp.Base.String(), - Quote: cp.Quote.String(), - }, - IncludeFullOrderData: true, - IncludeFullFundingRates: true, - IncludePredictedRate: true, - GetPositionStats: true, - GetFundingPayments: true, - }) - if !errors.Is(err, ErrExchangeNotFound) { - t.Errorf("received '%v', expected '%v'", err, ErrExchangeNotFound) - } - - od := &order.Detail{ - Price: 1337, - Amount: 1337, - Fee: 1.337, - Exchange: fakeExchangeName, - OrderID: "test", - Side: order.Long, - Status: order.Open, - AssetType: asset.Futures, - Date: time.Now(), - Pair: cp, - } - err = s.OrderManager.orderStore.futuresPositionController.TrackNewOrder(od) - if !errors.Is(err, nil) { - t.Fatalf("received '%v', expected '%v'", err, nil) - } - _, err = s.GetFuturesPositions(ctx, &gctrpc.GetFuturesPositionsRequest{ + _, err = s.GetFuturesPositionsOrders(context.Background(), &gctrpc.GetFuturesPositionsOrdersRequest{ Exchange: fakeExchangeName, Asset: asset.Futures.String(), Pair: &gctrpc.CurrencyPair{ @@ -2375,13 +2350,12 @@ func TestGetFuturesPositions(t *testing.T) { Base: cp.Base.String(), Quote: cp.Quote.String(), }, - IncludeFullOrderData: true, }) if !errors.Is(err, nil) { t.Fatalf("received '%v', expected '%v'", err, nil) } - _, err = s.GetFuturesPositions(ctx, &gctrpc.GetFuturesPositionsRequest{ + _, err = s.GetFuturesPositionsOrders(context.Background(), &gctrpc.GetFuturesPositionsOrdersRequest{ Exchange: fakeExchangeName, Asset: asset.Spot.String(), Pair: &gctrpc.CurrencyPair{ @@ -2424,6 +2398,7 @@ func TestGetCollateral(t *testing.T) { Available: currency.Pairs{cp}, Enabled: currency.Pairs{cp}, } + b.Features.Supports.FuturesCapabilities.Collateral = true fakeExchange := fExchange{ IBotExchange: exch, } @@ -2965,6 +2940,7 @@ func TestGetFundingRates(t *testing.T) { Available: currency.Pairs{cp}, Enabled: currency.Pairs{cp}, } + b.Features.Supports.FuturesCapabilities.FundingRates = true fakeExchange := fExchange{ IBotExchange: exch, } @@ -2973,7 +2949,7 @@ func TestGetFundingRates(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, time.Hour) + om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -3073,7 +3049,7 @@ func TestGetLatestFundingRate(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, time.Hour) + om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -3164,6 +3140,7 @@ func TestGetManagedPosition(t *testing.T) { Available: currency.Pairs{cp, cp2}, Enabled: currency.Pairs{cp, cp2}, } + b.Features.Supports.FuturesCapabilities.OrderManagerPositionTracking = true fakeExchange := fExchange{ IBotExchange: exch, } @@ -3172,7 +3149,7 @@ func TestGetManagedPosition(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, time.Hour) + om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -3221,7 +3198,7 @@ func TestGetManagedPosition(t *testing.T) { } request.Asset = asset.Futures.String() - s.OrderManager, err = SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, time.Hour) + s.OrderManager, err = SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -3314,7 +3291,7 @@ func TestGetAllManagedPositions(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } var wg sync.WaitGroup - om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, time.Hour) + om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -3335,7 +3312,7 @@ func TestGetAllManagedPositions(t *testing.T) { } request := &gctrpc.GetAllManagedPositionsRequest{} - s.OrderManager, err = SetupOrderManager(em, &CommunicationManager{}, &wg, false, true, time.Hour) + s.OrderManager, err = SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour, ActivelyTrackFuturesPositions: true}) if !errors.Is(err, nil) { t.Errorf("received '%v', expected '%v'", err, nil) } @@ -3706,3 +3683,383 @@ func TestGetOrderbookAmountByImpact(t *testing.T) { t.Fatalf("received: '%v' but expected: '%v'", impact.AmountRequired, 1) } } + +func TestChangePositionMargin(t *testing.T) { + t.Parallel() + em := NewExchangeManager() + exch, err := em.NewExchangeByName("binance") + if err != nil { + t.Fatal(err) + } + exch.SetDefaults() + b := exch.GetBase() + b.Name = fakeExchangeName + b.Enabled = true + + cp, err := currency.NewPairFromString("btc-mad") + if err != nil { + t.Fatal(err) + } + + b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore) + b.CurrencyPairs.Pairs[asset.USDTMarginedFutures] = ¤cy.PairStore{ + AssetEnabled: convert.BoolPtr(true), + ConfigFormat: ¤cy.PairFormat{Delimiter: "/"}, + RequestFormat: ¤cy.PairFormat{Delimiter: "/"}, + Available: currency.Pairs{cp}, + Enabled: currency.Pairs{cp}, + } + + fakeExchange := fExchange{ + IBotExchange: exch, + } + err = em.Add(fakeExchange) + if !errors.Is(err, nil) { + t.Fatalf("received: '%v' but expected: '%v'", err, nil) + } + + s := RPCServer{Engine: &Engine{ExchangeManager: em}} + _, err = s.ChangePositionMargin(context.Background(), nil) + if !errors.Is(err, common.ErrNilPointer) { + t.Errorf("received '%v' expected '%v'", err, common.ErrNilPointer) + } + + req := &gctrpc.ChangePositionMarginRequest{} + _, err = s.ChangePositionMargin(context.Background(), req) + if !errors.Is(err, currency.ErrCurrencyPairEmpty) { + t.Errorf("received '%v' expected '%v'", err, currency.ErrCurrencyPairEmpty) + } + + req.Exchange = fakeExchangeName + req.Pair = &gctrpc.CurrencyPair{ + Delimiter: "-", + Base: cp.Base.String(), + Quote: cp.Quote.String(), + } + req.Asset = asset.USDTMarginedFutures.String() + req.MarginSide = "BOTH" + req.OriginalAllocatedMargin = 1337 + req.NewAllocatedMargin = 1338 + req.MarginType = "isolated" + _, err = s.ChangePositionMargin(context.Background(), req) + if !errors.Is(err, nil) { + t.Errorf("received '%v' expected '%v'", err, nil) + } +} + +func TestSetLeverage(t *testing.T) { + t.Parallel() + em := NewExchangeManager() + exch, err := em.NewExchangeByName("binance") + if err != nil { + t.Fatal(err) + } + exch.SetDefaults() + b := exch.GetBase() + b.Name = fakeExchangeName + b.Enabled = true + + cp, err := currency.NewPairFromString("btc-mad") + if err != nil { + t.Fatal(err) + } + + b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore) + b.CurrencyPairs.Pairs[asset.USDTMarginedFutures] = ¤cy.PairStore{ + AssetEnabled: convert.BoolPtr(true), + ConfigFormat: ¤cy.PairFormat{Delimiter: "/"}, + RequestFormat: ¤cy.PairFormat{Delimiter: "/"}, + Available: currency.Pairs{cp}, + Enabled: currency.Pairs{cp}, + } + + fakeExchange := fExchange{ + IBotExchange: exch, + } + err = em.Add(fakeExchange) + if !errors.Is(err, nil) { + t.Fatalf("received: '%v' but expected: '%v'", err, nil) + } + + s := RPCServer{Engine: &Engine{ExchangeManager: em}} + _, err = s.SetLeverage(context.Background(), nil) + if !errors.Is(err, common.ErrNilPointer) { + t.Errorf("received '%v' expected '%v'", err, common.ErrNilPointer) + } + + req := &gctrpc.SetLeverageRequest{} + _, err = s.SetLeverage(context.Background(), req) + if !errors.Is(err, currency.ErrCurrencyPairEmpty) { + t.Error(err) + } + + req.Exchange = fakeExchangeName + req.Pair = &gctrpc.CurrencyPair{ + Delimiter: "-", + Base: cp.Base.String(), + Quote: cp.Quote.String(), + } + req.UnderlyingPair = &gctrpc.CurrencyPair{ + Delimiter: "-", + Base: cp.Base.String(), + Quote: cp.Quote.String(), + } + req.Asset = asset.USDTMarginedFutures.String() + req.MarginType = "isolated" + req.Leverage = 1337 + _, err = s.SetLeverage(context.Background(), req) + if !errors.Is(err, nil) { + t.Error(err) + } + + req.OrderSide = "lol" + _, err = s.SetLeverage(context.Background(), req) + if !errors.Is(err, order.ErrSideIsInvalid) { + t.Error(err) + } + + req.OrderSide = order.Long.String() + _, err = s.SetLeverage(context.Background(), req) + if !errors.Is(err, nil) { + t.Error(err) + } +} + +func TestGetLeverage(t *testing.T) { + t.Parallel() + em := NewExchangeManager() + exch, err := em.NewExchangeByName("binance") + if err != nil { + t.Fatal(err) + } + exch.SetDefaults() + b := exch.GetBase() + b.Name = fakeExchangeName + b.Enabled = true + + cp, err := currency.NewPairFromString("btc-mad") + if err != nil { + t.Fatal(err) + } + + b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore) + b.CurrencyPairs.Pairs[asset.USDTMarginedFutures] = ¤cy.PairStore{ + AssetEnabled: convert.BoolPtr(true), + ConfigFormat: ¤cy.PairFormat{Delimiter: "/"}, + RequestFormat: ¤cy.PairFormat{Delimiter: "/"}, + Available: currency.Pairs{cp}, + Enabled: currency.Pairs{cp}, + } + + fakeExchange := fExchange{ + IBotExchange: exch, + } + err = em.Add(fakeExchange) + if !errors.Is(err, nil) { + t.Fatalf("received: '%v' but expected: '%v'", err, nil) + } + + s := RPCServer{Engine: &Engine{ExchangeManager: em}} + _, err = s.GetLeverage(context.Background(), nil) + if !errors.Is(err, common.ErrNilPointer) { + t.Errorf("received '%v' expected '%v'", err, common.ErrNilPointer) + } + + req := &gctrpc.GetLeverageRequest{} + _, err = s.GetLeverage(context.Background(), req) + if !errors.Is(err, currency.ErrCurrencyPairEmpty) { + t.Error(err) + } + + req.Exchange = fakeExchangeName + req.Pair = &gctrpc.CurrencyPair{ + Delimiter: "-", + Base: cp.Base.String(), + Quote: cp.Quote.String(), + } + req.UnderlyingPair = &gctrpc.CurrencyPair{ + Delimiter: "-", + Base: cp.Base.String(), + Quote: cp.Quote.String(), + } + req.Asset = asset.USDTMarginedFutures.String() + req.MarginType = "isolated" + lev, err := s.GetLeverage(context.Background(), req) + if !errors.Is(err, nil) { + t.Error(err) + } + if lev.Leverage != 1337 { + t.Errorf("received '%v' expected '%v'", lev, 1337) + } + + req.OrderSide = "lol" + _, err = s.GetLeverage(context.Background(), req) + if !errors.Is(err, order.ErrSideIsInvalid) { + t.Error(err) + } + + req.OrderSide = order.Long.String() + _, err = s.GetLeverage(context.Background(), req) + if !errors.Is(err, nil) { + t.Error(err) + } +} + +func TestSetMarginType(t *testing.T) { + t.Parallel() + em := NewExchangeManager() + exch, err := em.NewExchangeByName("binance") + if err != nil { + t.Fatal(err) + } + exch.SetDefaults() + b := exch.GetBase() + b.Name = fakeExchangeName + b.Enabled = true + + cp, err := currency.NewPairFromString("btc-mad") + if err != nil { + t.Fatal(err) + } + + b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore) + b.CurrencyPairs.Pairs[asset.USDTMarginedFutures] = ¤cy.PairStore{ + AssetEnabled: convert.BoolPtr(true), + ConfigFormat: ¤cy.PairFormat{Delimiter: "/"}, + RequestFormat: ¤cy.PairFormat{Delimiter: "/"}, + Available: currency.Pairs{cp}, + Enabled: currency.Pairs{cp}, + } + + fakeExchange := fExchange{ + IBotExchange: exch, + } + err = em.Add(fakeExchange) + if !errors.Is(err, nil) { + t.Fatalf("received: '%v' but expected: '%v'", err, nil) + } + + s := RPCServer{Engine: &Engine{ExchangeManager: em}} + _, err = s.SetMarginType(context.Background(), nil) + if !errors.Is(err, common.ErrNilPointer) { + t.Errorf("received '%v' expected '%v'", err, common.ErrNilPointer) + } + + req := &gctrpc.SetMarginTypeRequest{} + _, err = s.SetMarginType(context.Background(), req) + if !errors.Is(err, currency.ErrCurrencyPairEmpty) { + t.Error(err) + } + + req.Exchange = fakeExchangeName + req.Pair = &gctrpc.CurrencyPair{ + Delimiter: "-", + Base: cp.Base.String(), + Quote: cp.Quote.String(), + } + req.Asset = asset.USDTMarginedFutures.String() + req.MarginType = "isolated" + _, err = s.SetMarginType(context.Background(), req) + if !errors.Is(err, nil) { + t.Error(err) + } +} + +func TestSetCollateralMode(t *testing.T) { + t.Parallel() + em := NewExchangeManager() + exch, err := em.NewExchangeByName("binance") + if err != nil { + t.Fatal(err) + } + exch.SetDefaults() + b := exch.GetBase() + b.Name = fakeExchangeName + b.Enabled = true + + cp, err := currency.NewPairFromString("btc-mad") + if err != nil { + t.Fatal(err) + } + + b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore) + b.CurrencyPairs.Pairs[asset.USDTMarginedFutures] = ¤cy.PairStore{ + AssetEnabled: convert.BoolPtr(true), + ConfigFormat: ¤cy.PairFormat{Delimiter: "/"}, + RequestFormat: ¤cy.PairFormat{Delimiter: "/"}, + Available: currency.Pairs{cp}, + Enabled: currency.Pairs{cp}, + } + + fakeExchange := fExchange{ + IBotExchange: exch, + } + err = em.Add(fakeExchange) + if !errors.Is(err, nil) { + t.Fatalf("received: '%v' but expected: '%v'", err, nil) + } + + s := RPCServer{Engine: &Engine{ExchangeManager: em}} + _, err = s.SetCollateralMode(context.Background(), nil) + if !errors.Is(err, common.ErrNilPointer) { + t.Errorf("received '%v' expected '%v'", err, common.ErrNilPointer) + } + + req := &gctrpc.SetCollateralModeRequest{} + _, err = s.SetCollateralMode(context.Background(), req) + if !errors.Is(err, ErrExchangeNameIsEmpty) { + t.Error(err) + } + + req.Exchange = fakeExchangeName + req.Asset = asset.USDTMarginedFutures.String() + req.CollateralMode = "single" + _, err = s.SetCollateralMode(context.Background(), req) + if !errors.Is(err, nil) { + t.Error(err) + } +} + +func TestGetCollateralMode(t *testing.T) { + t.Parallel() + em := NewExchangeManager() + exch, err := em.NewExchangeByName("binance") + if err != nil { + t.Fatal(err) + } + exch.SetDefaults() + b := exch.GetBase() + b.Name = fakeExchangeName + b.Enabled = true + b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore) + b.CurrencyPairs.Pairs[asset.USDTMarginedFutures] = ¤cy.PairStore{ + AssetEnabled: convert.BoolPtr(true), + } + + fakeExchange := fExchange{ + IBotExchange: exch, + } + err = em.Add(fakeExchange) + if !errors.Is(err, nil) { + t.Fatalf("received: '%v' but expected: '%v'", err, nil) + } + + s := RPCServer{Engine: &Engine{ExchangeManager: em}} + _, err = s.GetCollateralMode(context.Background(), nil) + if !errors.Is(err, common.ErrNilPointer) { + t.Errorf("received '%v' expected '%v'", err, common.ErrNilPointer) + } + + req := &gctrpc.GetCollateralModeRequest{} + _, err = s.GetCollateralMode(context.Background(), req) + if !errors.Is(err, ErrExchangeNameIsEmpty) { + t.Error(err) + } + + req.Exchange = fakeExchangeName + req.Asset = asset.USDTMarginedFutures.String() + _, err = s.GetCollateralMode(context.Background(), req) + if !errors.Is(err, nil) { + t.Error(err) + } +} diff --git a/engine/websocketroutine_manager_test.go b/engine/websocketroutine_manager_test.go index a864d52a289..6428d47e870 100644 --- a/engine/websocketroutine_manager_test.go +++ b/engine/websocketroutine_manager_test.go @@ -7,6 +7,7 @@ import ( "testing" "time" + "github.com/thrasher-corp/gocryptotrader/config" "github.com/thrasher-corp/gocryptotrader/currency" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" "github.com/thrasher-corp/gocryptotrader/exchanges/order" @@ -133,7 +134,7 @@ func TestWebsocketRoutineManagerHandleData(t *testing.T) { if !errors.Is(err, nil) { t.Fatalf("received: '%v' but expected: '%v'", err, nil) } - om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, false, false, 0) + om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{}) if !errors.Is(err, nil) { t.Errorf("error '%v', expected '%v'", err, nil) } diff --git a/exchanges/asset/asset.go b/exchanges/asset/asset.go index 6c8ae1bd2c2..3256695d419 100644 --- a/exchanges/asset/asset.go +++ b/exchanges/asset/asset.go @@ -51,6 +51,7 @@ const ( binary = "binary" perpetualContract = "perpetualcontract" perpetualSwap = "perpetualswap" + swap = "swap" futures = "futures" deliveryFutures = "delivery" upsideProfitContract = "upsideprofitcontract" @@ -190,7 +191,7 @@ func New(input string) (Item, error) { return Binary, nil case perpetualContract: return PerpetualContract, nil - case perpetualSwap: + case perpetualSwap, swap: return PerpetualSwap, nil case futures: return Futures, nil diff --git a/exchanges/binance/binance.go b/exchanges/binance/binance.go index 7f95c5f7a55..36eade2d2f5 100644 --- a/exchanges/binance/binance.go +++ b/exchanges/binance/binance.go @@ -911,6 +911,9 @@ func (b *Binance) SendAuthHTTPRequest(ctx context.Context, ePath exchange.URL, m return errors.New(errCap.Message) } } + if result == nil { + return nil + } return json.Unmarshal(interim, result) } diff --git a/exchanges/binance/binance_cfutures.go b/exchanges/binance/binance_cfutures.go index 72551c86f5e..a346663e5ab 100644 --- a/exchanges/binance/binance_cfutures.go +++ b/exchanges/binance/binance_cfutures.go @@ -89,7 +89,7 @@ func (b *Binance) GetFuturesOrderbook(ctx context.Context, symbol currency.Pair, params := url.Values{} params.Set("symbol", symbolValue) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -156,7 +156,7 @@ func (b *Binance) GetFuturesPublicTrades(ctx context.Context, symbol currency.Pa return resp, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp, b.SendHTTPRequest(ctx, exchange.RestCoinMargined, cfuturesRecentTrades+params.Encode(), cFuturesDefaultRate, &resp) @@ -174,7 +174,7 @@ func (b *Binance) GetFuturesHistoricalTrades(ctx context.Context, symbol currenc if fromID != "" { params.Set("fromID", fromID) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp, b.SendAuthHTTPRequest(ctx, exchange.RestCoinMargined, http.MethodGet, cfuturesHistoricalTrades, params, cFuturesHistoricalTradesRate, &resp) @@ -189,7 +189,7 @@ func (b *Binance) GetPastPublicTrades(ctx context.Context, symbol currency.Pair, return resp, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if fromID != 0 { @@ -207,7 +207,7 @@ func (b *Binance) GetFuturesAggregatedTradesList(ctx context.Context, symbol cur return resp, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if fromID != 0 { @@ -246,7 +246,7 @@ func (b *Binance) GetFuturesKlineData(ctx context.Context, symbol currency.Pair, } params.Set("symbol", symbolValue) } - if limit > 0 && limit <= 1500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -365,7 +365,7 @@ func (b *Binance) GetContinuousKlineData(ctx context.Context, pair, contractType return nil, errors.New("invalid contractType") } params.Set("contractType", contractType) - if limit > 0 && limit <= 1500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -480,7 +480,7 @@ func (b *Binance) GetContinuousKlineData(ctx context.Context, pair, contractType func (b *Binance) GetIndexPriceKlines(ctx context.Context, pair, interval string, limit int64, startTime, endTime time.Time) ([]FuturesCandleStick, error) { params := url.Values{} params.Set("pair", pair) - if limit > 0 && limit <= 1500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -599,7 +599,7 @@ func (b *Binance) GetMarkPriceKline(ctx context.Context, symbol currency.Pair, i } params := url.Values{} params.Set("symbol", symbolValue) - if limit > 0 && limit <= 1500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -755,7 +755,7 @@ func (b *Binance) FuturesGetFundingHistory(ctx context.Context, symbol currency. } params.Set("symbol", symbolValue) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -833,7 +833,7 @@ func (b *Binance) GetOpenInterestStats(ctx context.Context, pair, contractType, return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -855,7 +855,7 @@ func (b *Binance) GetTraderFuturesAccountRatio(ctx context.Context, pair, period return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -877,7 +877,7 @@ func (b *Binance) GetTraderFuturesPositionsRatio(ctx context.Context, pair, peri return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -899,7 +899,7 @@ func (b *Binance) GetMarketRatio(ctx context.Context, pair, period string, limit return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -921,7 +921,7 @@ func (b *Binance) GetFuturesTakerVolume(ctx context.Context, pair, contractType, return resp, errors.New("invalid contractType") } params.Set("contractType", contractType) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, period) { @@ -947,7 +947,7 @@ func (b *Binance) GetFuturesBasisData(ctx context.Context, pair, contractType, p return resp, errors.New("invalid contractType") } params.Set("contractType", contractType) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, period) { @@ -1198,7 +1198,7 @@ func (b *Binance) GetFuturesAllOpenOrders(ctx context.Context, symbol currency.P } // GetAllFuturesOrders gets all orders active cancelled or filled -func (b *Binance) GetAllFuturesOrders(ctx context.Context, symbol currency.Pair, pair string, startTime, endTime time.Time, orderID, limit int64) ([]FuturesOrderData, error) { +func (b *Binance) GetAllFuturesOrders(ctx context.Context, symbol, pair currency.Pair, startTime, endTime time.Time, orderID, limit int64) ([]FuturesOrderData, error) { var resp []FuturesOrderData params := url.Values{} rateLimit := cFuturesPairOrdersRate @@ -1210,13 +1210,13 @@ func (b *Binance) GetAllFuturesOrders(ctx context.Context, symbol currency.Pair, } params.Set("symbol", symbolValue) } - if pair != "" { - params.Set("pair", pair) + if !pair.IsEmpty() { + params.Set("pair", pair.String()) } if orderID != 0 { params.Set("orderID", strconv.FormatInt(orderID, 10)) } - if limit > 0 && limit <= 100 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -1242,7 +1242,7 @@ func (b *Binance) GetFuturesAccountInfo(ctx context.Context) (FuturesAccountInfo } // FuturesChangeInitialLeverage changes initial leverage for the account -func (b *Binance) FuturesChangeInitialLeverage(ctx context.Context, symbol currency.Pair, leverage int64) (FuturesLeverageData, error) { +func (b *Binance) FuturesChangeInitialLeverage(ctx context.Context, symbol currency.Pair, leverage float64) (FuturesLeverageData, error) { var resp FuturesLeverageData params := url.Values{} symbolValue, err := b.FormatSymbol(symbol, asset.CoinMarginedFutures) @@ -1253,7 +1253,7 @@ func (b *Binance) FuturesChangeInitialLeverage(ctx context.Context, symbol curre if leverage < 1 || leverage > 125 { return resp, errors.New("invalid leverage") } - params.Set("leverage", strconv.FormatInt(leverage, 10)) + params.Set("leverage", strconv.FormatFloat(leverage, 'f', -1, 64)) return resp, b.SendAuthHTTPRequest(ctx, exchange.RestCoinMargined, http.MethodPost, cfuturesChangeInitialLeverage, params, cFuturesDefaultRate, &resp) } @@ -1274,18 +1274,20 @@ func (b *Binance) FuturesChangeMarginType(ctx context.Context, symbol currency.P } // ModifyIsolatedPositionMargin changes margin for an isolated position -func (b *Binance) ModifyIsolatedPositionMargin(ctx context.Context, symbol currency.Pair, positionSide, changeType string, amount float64) (GenericAuthResponse, error) { - var resp GenericAuthResponse +func (b *Binance) ModifyIsolatedPositionMargin(ctx context.Context, symbol currency.Pair, positionSide, changeType string, amount float64) (FuturesMarginUpdatedResponse, error) { + var resp FuturesMarginUpdatedResponse params := url.Values{} symbolValue, err := b.FormatSymbol(symbol, asset.CoinMarginedFutures) if err != nil { return resp, err } params.Set("symbol", symbolValue) - if !common.StringDataCompare(validPositionSide, positionSide) { - return resp, errors.New("invalid positionSide") + if positionSide != "" { + if !common.StringDataCompare(validPositionSide, positionSide) { + return resp, errors.New("invalid positionSide") + } + params.Set("positionSide", positionSide) } - params.Set("positionSide", positionSide) cType, ok := validMarginChange[changeType] if !ok { return resp, errors.New("invalid changeType") @@ -1323,15 +1325,19 @@ func (b *Binance) FuturesMarginChangeHistory(ctx context.Context, symbol currenc } // FuturesPositionsInfo gets futures positions info +// "pair" for coinmarginedfutures in GCT terms is the pair base +// eg ADAUSD_PERP the "pair" parameter is ADAUSD func (b *Binance) FuturesPositionsInfo(ctx context.Context, marginAsset, pair string) ([]FuturesPositionInformation, error) { var resp []FuturesPositionInformation params := url.Values{} if marginAsset != "" { params.Set("marginAsset", marginAsset) } + if pair != "" { params.Set("pair", pair) } + return resp, b.SendAuthHTTPRequest(ctx, exchange.RestCoinMargined, http.MethodGet, cfuturesPositionInfo, params, cFuturesDefaultRate, &resp) } diff --git a/exchanges/binance/binance_live_test.go b/exchanges/binance/binance_live_test.go index a703f2cb052..8af87084393 100644 --- a/exchanges/binance/binance_live_test.go +++ b/exchanges/binance/binance_live_test.go @@ -28,6 +28,7 @@ func TestMain(m *testing.M) { if err != nil { log.Fatal("Binance Setup() init error", err) } + binanceConfig.API.AuthenticatedSupport = true binanceConfig.API.Credentials.Key = apiKey binanceConfig.API.Credentials.Secret = apiSecret diff --git a/exchanges/binance/binance_test.go b/exchanges/binance/binance_test.go index 8240c01a208..9eea21d95cb 100644 --- a/exchanges/binance/binance_test.go +++ b/exchanges/binance/binance_test.go @@ -15,8 +15,10 @@ import ( "github.com/thrasher-corp/gocryptotrader/currency" exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues" "github.com/thrasher-corp/gocryptotrader/portfolio/withdraw" @@ -56,7 +58,7 @@ func getTime() (start, end time.Time) { } tn := time.Now() - offset := time.Hour * 24 * 30 + offset := time.Hour * 24 * 6 return tn.Add(-offset), tn } @@ -71,6 +73,7 @@ func TestStart(t *testing.T) { if err != nil { t.Fatal(err) } + testWg.Wait() } @@ -216,7 +219,7 @@ func TestUFuturesOrderbook(t *testing.T) { func TestURecentTrades(t *testing.T) { t.Parallel() - _, err := b.URecentTrades(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "", 5) + _, err := b.URecentTrades(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "", 1000) if err != nil { t.Error(err) } @@ -972,7 +975,7 @@ func TestGetFuturesAllOpenOrders(t *testing.T) { func TestGetAllFuturesOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, b) - _, err := b.GetAllFuturesOrders(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "", time.Time{}, time.Time{}, 0, 2) + _, err := b.GetAllFuturesOrders(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), currency.EMPTYPAIR, time.Time{}, time.Time{}, 0, 2) if err != nil { t.Error(err) } @@ -1035,7 +1038,7 @@ func TestFuturesMarginChangeHistory(t *testing.T) { func TestFuturesPositionsInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, b) - _, err := b.FuturesPositionsInfo(context.Background(), "BTCUSD_PERP", "") + _, err := b.FuturesPositionsInfo(context.Background(), "BTCUSD", "") if err != nil { t.Error(err) } @@ -1106,8 +1109,8 @@ func TestGetExchangeInfo(t *testing.T) { } if mockTests { serverTime := time.Date(2022, 2, 25, 3, 50, 40, int(601*time.Millisecond), time.UTC) - if !info.Servertime.Equal(serverTime) { - t.Errorf("Expected %v, got %v", serverTime, info.Servertime) + if !info.ServerTime.Equal(serverTime) { + t.Errorf("Expected %v, got %v", serverTime, info.ServerTime) } } } @@ -2378,17 +2381,23 @@ func TestBinance_FormatExchangeKlineInterval(t *testing.T) { func TestGetRecentTrades(t *testing.T) { t.Parallel() - bAssets := b.GetAssetTypes(false) - for i := range bAssets { - cps, err := b.GetAvailablePairs(bAssets[i]) - if err != nil { - t.Error(err) - } - _, err = b.GetRecentTrades(context.Background(), - cps[0], bAssets[i]) - if err != nil { - t.Error(err) - } + pair := currency.NewPair(currency.BTC, currency.USDT) + _, err := b.GetRecentTrades(context.Background(), + pair, asset.Spot) + if err != nil { + t.Error(err) + } + _, err = b.GetRecentTrades(context.Background(), + pair, asset.USDTMarginedFutures) + if err != nil { + t.Error(err) + } + pair.Base = currency.NewCode("BTCUSD") + pair.Quote = currency.PERP + _, err = b.GetRecentTrades(context.Background(), + pair, asset.CoinMarginedFutures) + if err != nil { + t.Error(err) } } @@ -2728,7 +2737,6 @@ func TestFetchSpotExchangeLimits(t *testing.T) { func TestUpdateOrderExecutionLimits(t *testing.T) { t.Parallel() - tests := map[asset.Item]currency.Pair{ asset.Spot: currency.NewPair(currency.BTC, currency.USDT), asset.Margin: currency.NewPair(currency.ETH, currency.BTC), @@ -2939,6 +2947,229 @@ func TestGetUserMarginInterestHistory(t *testing.T) { } } +func TestSetAssetsMode(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + is, err := b.GetAssetsMode(context.Background()) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } + + err = b.SetAssetsMode(context.Background(), !is) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } + + err = b.SetAssetsMode(context.Background(), is) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } +} + +func TestGetAssetsMode(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + _, err := b.GetAssetsMode(context.Background()) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } +} + +func TestGetCollateralMode(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) + _, err := b.GetCollateralMode(context.Background(), asset.Spot) + if !errors.Is(err, asset.ErrNotSupported) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } + _, err = b.GetCollateralMode(context.Background(), asset.CoinMarginedFutures) + if !errors.Is(err, asset.ErrNotSupported) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } + _, err = b.GetCollateralMode(context.Background(), asset.USDTMarginedFutures) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } +} + +func TestSetCollateralMode(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) + err := b.SetCollateralMode(context.Background(), asset.Spot, collateral.SingleMode) + if !errors.Is(err, asset.ErrNotSupported) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } + err = b.SetCollateralMode(context.Background(), asset.CoinMarginedFutures, collateral.SingleMode) + if !errors.Is(err, asset.ErrNotSupported) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } + err = b.SetCollateralMode(context.Background(), asset.USDTMarginedFutures, collateral.MultiMode) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } + err = b.SetCollateralMode(context.Background(), asset.USDTMarginedFutures, collateral.PortfolioMode) + if !errors.Is(err, order.ErrCollateralInvalid) { + t.Errorf("received '%v', expected '%v'", err, order.ErrCollateralInvalid) + } +} + +func TestChangePositionMargin(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) + _, err := b.ChangePositionMargin(context.Background(), &margin.PositionChangeRequest{ + Pair: currency.NewBTCUSDT(), + Asset: asset.USDTMarginedFutures, + MarginType: margin.Isolated, + OriginalAllocatedMargin: 1337, + NewAllocatedMargin: 1333337, + }) + if err != nil { + t.Error(err) + } +} + +func TestGetPositionSummary(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + + bb := currency.NewBTCUSDT() + _, err := b.GetFuturesPositionSummary(context.Background(), &order.PositionSummaryRequest{ + Asset: asset.USDTMarginedFutures, + Pair: bb, + }) + if err != nil { + t.Error(err) + } + + bb.Quote = currency.BUSD + _, err = b.GetFuturesPositionSummary(context.Background(), &order.PositionSummaryRequest{ + Asset: asset.USDTMarginedFutures, + Pair: bb, + }) + if err != nil { + t.Error(err) + } + + p, err := currency.NewPairFromString("BTCUSD_PERP") + if err != nil { + t.Fatal(err) + } + bb.Quote = currency.USD + _, err = b.GetFuturesPositionSummary(context.Background(), &order.PositionSummaryRequest{ + Asset: asset.CoinMarginedFutures, + Pair: p, + UnderlyingPair: bb, + }) + if err != nil { + t.Error(err) + } + + _, err = b.GetFuturesPositionSummary(context.Background(), &order.PositionSummaryRequest{ + Asset: asset.Spot, + Pair: p, + UnderlyingPair: bb, + }) + if !errors.Is(err, asset.ErrNotSupported) { + t.Error(err) + } +} + +func TestGetFuturesPositionOrders(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + _, err := b.GetFuturesPositionOrders(context.Background(), &order.PositionsRequest{ + Asset: asset.USDTMarginedFutures, + Pairs: []currency.Pair{currency.NewBTCUSDT()}, + StartDate: time.Now().Add(-time.Hour * 24 * 70), + RespectOrderHistoryLimits: true, + }) + if err != nil { + t.Error(err) + } + + p, err := currency.NewPairFromString("ADAUSD_PERP") + if err != nil { + t.Fatal(err) + } + _, err = b.GetFuturesPositionOrders(context.Background(), &order.PositionsRequest{ + Asset: asset.CoinMarginedFutures, + Pairs: []currency.Pair{p}, + StartDate: time.Now().Add(time.Hour * 24 * -70), + RespectOrderHistoryLimits: true, + }) + if err != nil { + t.Error(err) + } +} + +func TestSetMarginType(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) + + err := b.SetMarginType(context.Background(), asset.USDTMarginedFutures, currency.NewPair(currency.BTC, currency.USDT), margin.Isolated) + if !errors.Is(err, nil) { + t.Error(err) + } + + p, err := currency.NewPairFromString("BTCUSD_PERP") + if err != nil { + t.Fatal(err) + } + err = b.SetMarginType(context.Background(), asset.CoinMarginedFutures, p, margin.Isolated) + if !errors.Is(err, nil) { + t.Error(err) + } + + err = b.SetMarginType(context.Background(), asset.Spot, currency.NewPair(currency.BTC, currency.USDT), margin.Isolated) + if !errors.Is(err, asset.ErrNotSupported) { + t.Error(err) + } +} + +func TestGetLeverage(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + _, err := b.GetLeverage(context.Background(), asset.USDTMarginedFutures, currency.NewBTCUSDT(), 0, order.UnknownSide) + if err != nil { + t.Error(err) + } + + p, err := currency.NewPairFromString("BTCUSD_PERP") + if err != nil { + t.Fatal(err) + } + _, err = b.GetLeverage(context.Background(), asset.CoinMarginedFutures, p, 0, order.UnknownSide) + if err != nil { + t.Error(err) + } + _, err = b.GetLeverage(context.Background(), asset.Spot, currency.NewBTCUSDT(), 0, order.UnknownSide) + if !errors.Is(err, asset.ErrNotSupported) { + t.Error(err) + } +} + +func TestSetLeverage(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) + err := b.SetLeverage(context.Background(), asset.USDTMarginedFutures, currency.NewBTCUSDT(), margin.Multi, 5, order.UnknownSide) + if err != nil { + t.Error(err) + } + + p, err := currency.NewPairFromString("BTCUSD_PERP") + if err != nil { + t.Fatal(err) + } + err = b.SetLeverage(context.Background(), asset.CoinMarginedFutures, p, margin.Multi, 5, order.UnknownSide) + if err != nil { + t.Error(err) + } + err = b.SetLeverage(context.Background(), asset.Spot, p, margin.Multi, 5, order.UnknownSide) + if !errors.Is(err, asset.ErrNotSupported) { + t.Error(err) + } +} + func TestGetCryptoLoansIncomeHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, b) diff --git a/exchanges/binance/binance_types.go b/exchanges/binance/binance_types.go index e45981c556b..700a288d252 100644 --- a/exchanges/binance/binance_types.go +++ b/exchanges/binance/binance_types.go @@ -43,7 +43,7 @@ type ExchangeInfo struct { Code int `json:"code"` Msg string `json:"msg"` Timezone string `json:"timezone"` - Servertime time.Time `json:"serverTime"` + ServerTime time.Time `json:"serverTime"` RateLimits []struct { RateLimitType string `json:"rateLimitType"` Interval string `json:"interval"` diff --git a/exchanges/binance/binance_ufutures.go b/exchanges/binance/binance_ufutures.go index 85adeca5da9..6643529a07e 100644 --- a/exchanges/binance/binance_ufutures.go +++ b/exchanges/binance/binance_ufutures.go @@ -57,11 +57,13 @@ const ( ufuturesModifyMargin = "/fapi/v1/positionMargin" ufuturesMarginChangeHistory = "/fapi/v1/positionMargin/history" ufuturesPositionInfo = "/fapi/v2/positionRisk" + ufuturesCommissionRate = "/fapi/v1/commissionRate" ufuturesAccountTradeList = "/fapi/v1/userTrades" ufuturesIncomeHistory = "/fapi/v1/income" ufuturesNotionalBracket = "/fapi/v1/leverageBracket" ufuturesUsersForceOrders = "/fapi/v1/forceOrders" ufuturesADLQuantile = "/fapi/v1/adlQuantile" + uFuturesMultiAssetsMargin = "/fapi/v1/multiAssetsMargin" ) // UServerTime gets the server time @@ -168,7 +170,7 @@ func (b *Binance) URecentTrades(ctx context.Context, symbol currency.Pair, fromI if fromID != "" { params.Set("fromID", fromID) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp, b.SendHTTPRequest(ctx, exchange.RestUSDTMargined, ufuturesRecentTrades+params.Encode(), uFuturesDefaultRate, &resp) @@ -186,7 +188,7 @@ func (b *Binance) UFuturesHistoricalTrades(ctx context.Context, symbol currency. if fromID != "" { params.Set("fromID", fromID) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp, b.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodGet, ufuturesHistoricalTrades, params, uFuturesHistoricalTradesRate, &resp) @@ -204,7 +206,7 @@ func (b *Binance) UCompressedTrades(ctx context.Context, symbol currency.Pair, f if fromID != "" { params.Set("fromID", fromID) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -229,7 +231,7 @@ func (b *Binance) UKlineData(ctx context.Context, symbol currency.Pair, interval return nil, errors.New("invalid interval") } params.Set("interval", interval) - if limit > 0 && limit <= 1500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -489,7 +491,7 @@ func (b *Binance) UOpenInterestStats(ctx context.Context, symbol currency.Pair, return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -515,7 +517,7 @@ func (b *Binance) UTopAcccountsLongShortRatio(ctx context.Context, symbol curren return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit < 500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -541,7 +543,7 @@ func (b *Binance) UTopPostionsLongShortRatio(ctx context.Context, symbol currenc return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit < 500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -567,7 +569,7 @@ func (b *Binance) UGlobalLongShortRatio(ctx context.Context, symbol currency.Pai return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit < 500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -593,7 +595,7 @@ func (b *Binance) UTakerBuySellVol(ctx context.Context, symbol currency.Pair, pe return resp, errors.New("invalid period") } params.Set("period", period) - if limit > 0 && limit < 500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -859,14 +861,13 @@ func (b *Binance) UAllAccountOrders(ctx context.Context, symbol currency.Pair, o if orderID != 0 { params.Set("orderId", strconv.FormatInt(orderID, 10)) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } - if !startTime.IsZero() && !endTime.IsZero() { - if startTime.After(endTime) { - return resp, errors.New("startTime cannot be after endTime") - } + if !startTime.IsZero() { params.Set("startTime", strconv.FormatInt(startTime.UnixMilli(), 10)) + } + if !endTime.IsZero() { params.Set("endTime", strconv.FormatInt(endTime.UnixMilli(), 10)) } return resp, b.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodGet, ufuturesAllOrders, params, uFuturesGetAllOrdersRate, &resp) @@ -885,7 +886,7 @@ func (b *Binance) UAccountInformationV2(ctx context.Context) (UAccountInformatio } // UChangeInitialLeverageRequest sends a request to change account's initial leverage -func (b *Binance) UChangeInitialLeverageRequest(ctx context.Context, symbol currency.Pair, leverage int64) (UChangeInitialLeverage, error) { +func (b *Binance) UChangeInitialLeverageRequest(ctx context.Context, symbol currency.Pair, leverage float64) (UChangeInitialLeverage, error) { var resp UChangeInitialLeverage params := url.Values{} symbolValue, err := b.FormatSymbol(symbol, asset.USDTMarginedFutures) @@ -896,7 +897,7 @@ func (b *Binance) UChangeInitialLeverageRequest(ctx context.Context, symbol curr if leverage < 1 || leverage > 125 { return resp, errors.New("invalid leverage") } - params.Set("leverage", strconv.FormatInt(leverage, 10)) + params.Set("leverage", strconv.FormatFloat(leverage, 'f', -1, 64)) return resp, b.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodPost, ufuturesChangeInitialLeverage, params, uFuturesDefaultRate, &resp) } @@ -924,16 +925,14 @@ func (b *Binance) UModifyIsolatedPositionMarginReq(ctx context.Context, symbol c return resp, err } params.Set("symbol", symbolValue) - if positionSide != "" { - if !common.StringDataCompare(validPositionSide, positionSide) { - return resp, errors.New("invalid margin changeType") - } - } cType, ok := validMarginChange[changeType] if !ok { return resp, errors.New("invalid margin changeType") } params.Set("type", strconv.FormatInt(cType, 10)) + if positionSide != "" { + params.Set("positionSide", positionSide) + } params.Set("amount", strconv.FormatFloat(amount, 'f', -1, 64)) return resp, b.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodPost, ufuturesModifyMargin, params, uFuturesDefaultRate, &resp) } @@ -952,7 +951,7 @@ func (b *Binance) UPositionMarginChangeHistory(ctx context.Context, symbol curre return resp, errors.New("invalid margin changeType") } params.Set("type", strconv.FormatInt(cType, 10)) - if limit > 0 && limit < 500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -979,6 +978,20 @@ func (b *Binance) UPositionsInfoV2(ctx context.Context, symbol currency.Pair) ([ return resp, b.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodGet, ufuturesPositionInfo, params, uFuturesDefaultRate, &resp) } +// UGetCommissionRates returns the commission rates for USDTMarginedFutures +func (b *Binance) UGetCommissionRates(ctx context.Context, symbol currency.Pair) ([]UPositionInformationV2, error) { + var resp []UPositionInformationV2 + params := url.Values{} + if !symbol.IsEmpty() { + symbolValue, err := b.FormatSymbol(symbol, asset.USDTMarginedFutures) + if err != nil { + return resp, err + } + params.Set("symbol", symbolValue) + } + return resp, b.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodGet, ufuturesCommissionRate, params, uFuturesDefaultRate, &resp) +} + // UAccountTradesHistory gets account's trade history data for USDTMarginedFutures func (b *Binance) UAccountTradesHistory(ctx context.Context, symbol currency.Pair, fromID string, limit int64, startTime, endTime time.Time) ([]UAccountTradeHistory, error) { var resp []UAccountTradeHistory @@ -991,7 +1004,7 @@ func (b *Binance) UAccountTradesHistory(ctx context.Context, symbol currency.Pai if fromID != "" { params.Set("fromID", fromID) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -1019,7 +1032,7 @@ func (b *Binance) UAccountIncomeHistory(ctx context.Context, symbol currency.Pai } params.Set("incomeType", incomeType) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -1079,7 +1092,7 @@ func (b *Binance) UAccountForcedOrders(ctx context.Context, symbol currency.Pair } params.Set("autoCloseType", autoCloseType) } - if limit > 0 && limit < 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !startTime.IsZero() && !endTime.IsZero() { @@ -1140,3 +1153,19 @@ func (b *Binance) FetchUSDTMarginExchangeLimits(ctx context.Context) ([]order.Mi } return limits, nil } + +// SetAssetsMode sets the current asset margin type, true for multi, false for single +func (b *Binance) SetAssetsMode(ctx context.Context, multiMargin bool) error { + params := url.Values{ + "multiAssetsMargin": {strconv.FormatBool(multiMargin)}, + } + return b.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodPost, uFuturesMultiAssetsMargin, params, uFuturesDefaultRate, nil) +} + +// GetAssetsMode returns the current asset margin type, true for multi, false for single +func (b *Binance) GetAssetsMode(ctx context.Context) (bool, error) { + var result struct { + MultiAssetsMargin bool `json:"multiAssetsMargin"` + } + return result.MultiAssetsMargin, b.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodGet, uFuturesMultiAssetsMargin, nil, uFuturesDefaultRate, &result) +} diff --git a/exchanges/binance/binance_wrapper.go b/exchanges/binance/binance_wrapper.go index 80ae010b688..3905166eb29 100644 --- a/exchanges/binance/binance_wrapper.go +++ b/exchanges/binance/binance_wrapper.go @@ -17,9 +17,11 @@ import ( exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/deposit" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/exchanges/orderbook" "github.com/thrasher-corp/gocryptotrader/exchanges/protocol" @@ -120,8 +122,9 @@ func (b *Binance) SetDefaults() { } b.Features = exchange.Features{ Supports: exchange.FeaturesSupported{ - REST: true, - Websocket: true, + REST: true, + Websocket: true, + MaximumOrderHistory: kline.OneDay.Duration() * 7, RESTCapabilities: protocol.Features{ TickerBatching: true, TickerFetching: true, @@ -165,6 +168,9 @@ func (b *Binance) SetDefaults() { Intervals: true, }, FuturesCapabilities: exchange.FuturesCapabilities{ + Positions: true, + Leverage: true, + CollateralMode: true, FundingRates: true, FundingRateFrequency: kline.EightHour.Duration(), }, @@ -972,6 +978,9 @@ func (b *Binance) SubmitOrder(ctx context.Context, s *order.Submit) (*order.Subm var orderID string status := order.New var trades []order.TradeHistory + if s.Leverage != 0 && s.Leverage != 1 { + return nil, fmt.Errorf("%w received '%v'", order.ErrSubmitLeverageNotSupported, s.Leverage) + } switch s.AssetType { case asset.Spot, asset.Margin: var sideType string @@ -1618,7 +1627,7 @@ func (b *Binance) GetOrderHistory(ctx context.Context, req *order.MultiOrderRequ return nil, fmt.Errorf("can only fetch orders 30 days out") } orderHistory, err = b.GetAllFuturesOrders(ctx, - req.Pairs[i], "", req.StartTime, req.EndTime, 0, 0) + req.Pairs[i], currency.EMPTYPAIR, req.StartTime, req.EndTime, 0, 0) if err != nil { return nil, err } @@ -1628,7 +1637,7 @@ func (b *Binance) GetOrderHistory(ctx context.Context, req *order.MultiOrderRequ return nil, err } orderHistory, err = b.GetAllFuturesOrders(ctx, - req.Pairs[i], "", time.Time{}, time.Time{}, fromID, 0) + req.Pairs[i], currency.EMPTYPAIR, time.Time{}, time.Time{}, fromID, 0) if err != nil { return nil, err } @@ -2051,7 +2060,7 @@ func (b *Binance) GetServerTime(ctx context.Context, ai asset.Item) (time.Time, if err != nil { return time.Time{}, err } - return info.Servertime, nil + return info.ServerTime, nil case asset.CoinMarginedFutures: info, err := b.FuturesExchangeInfo(ctx) if err != nil { @@ -2260,3 +2269,568 @@ func (b *Binance) IsPerpetualFutureCurrency(a asset.Item, cp currency.Pair) (boo } return false, nil } + +// SetCollateralMode sets the account's collateral mode for the asset type +func (b *Binance) SetCollateralMode(ctx context.Context, a asset.Item, collateralMode collateral.Mode) error { + if a != asset.USDTMarginedFutures { + return fmt.Errorf("%w %v", asset.ErrNotSupported, a) + } + if collateralMode != collateral.MultiMode && collateralMode != collateral.SingleMode { + return fmt.Errorf("%w %v", order.ErrCollateralInvalid, collateralMode) + } + return b.SetAssetsMode(ctx, collateralMode == collateral.MultiMode) +} + +// GetCollateralMode returns the account's collateral mode for the asset type +func (b *Binance) GetCollateralMode(ctx context.Context, a asset.Item) (collateral.Mode, error) { + if a != asset.USDTMarginedFutures { + return collateral.UnknownMode, fmt.Errorf("%w %v", asset.ErrNotSupported, a) + } + isMulti, err := b.GetAssetsMode(ctx) + if err != nil { + return collateral.UnknownMode, err + } + if isMulti { + return collateral.MultiMode, nil + } + return collateral.SingleMode, nil +} + +// SetMarginType sets the default margin type for when opening a new position +func (b *Binance) SetMarginType(ctx context.Context, item asset.Item, pair currency.Pair, tp margin.Type) error { + if item != asset.USDTMarginedFutures && item != asset.CoinMarginedFutures { + return fmt.Errorf("%w %v", asset.ErrNotSupported, item) + } + if !tp.Valid() { + return fmt.Errorf("%w %v", margin.ErrInvalidMarginType, tp) + } + mt, err := b.marginTypeToString(tp) + if err != nil { + return err + } + switch item { + case asset.CoinMarginedFutures: + _, err = b.FuturesChangeMarginType(ctx, pair, mt) + case asset.USDTMarginedFutures: + err = b.UChangeInitialMarginType(ctx, pair, mt) + } + if err != nil { + return err + } + + return nil +} + +// ChangePositionMargin will modify a position/currencies margin parameters +func (b *Binance) ChangePositionMargin(ctx context.Context, req *margin.PositionChangeRequest) (*margin.PositionChangeResponse, error) { + if req == nil { + return nil, fmt.Errorf("%w PositionChangeRequest", common.ErrNilPointer) + } + if req.Asset != asset.USDTMarginedFutures && req.Asset != asset.CoinMarginedFutures { + return nil, fmt.Errorf("%w %v", asset.ErrNotSupported, req.Asset) + } + if req.NewAllocatedMargin == 0 { + return nil, fmt.Errorf("%w %v %v", margin.ErrNewAllocatedMarginRequired, req.Asset, req.Pair) + } + if req.OriginalAllocatedMargin == 0 { + return nil, fmt.Errorf("%w %v %v", margin.ErrOriginalPositionMarginRequired, req.Asset, req.Pair) + } + if req.MarginType == margin.Multi { + return nil, fmt.Errorf("%w %v %v", margin.ErrMarginTypeUnsupported, req.Asset, req.Pair) + } + + marginType := "add" + if req.NewAllocatedMargin < req.OriginalAllocatedMargin { + marginType = "reduce" + } + var side string + if req.MarginSide != "" { + side = req.MarginSide + } + var err error + switch req.Asset { + case asset.CoinMarginedFutures: + _, err = b.ModifyIsolatedPositionMargin(ctx, req.Pair, side, marginType, req.NewAllocatedMargin) + case asset.USDTMarginedFutures: + _, err = b.UModifyIsolatedPositionMarginReq(ctx, req.Pair, side, marginType, req.NewAllocatedMargin) + } + if err != nil { + return nil, err + } + + return &margin.PositionChangeResponse{ + Exchange: b.Name, + Pair: req.Pair, + Asset: req.Asset, + MarginType: req.MarginType, + AllocatedMargin: req.NewAllocatedMargin, + }, nil +} + +// marginTypeToString converts the GCT margin type to Binance's string +func (b *Binance) marginTypeToString(mt margin.Type) (string, error) { + switch mt { + case margin.Isolated: + return margin.Isolated.Upper(), nil + case margin.Multi: + return "CROSSED", nil + } + return "", fmt.Errorf("%w %v", margin.ErrInvalidMarginType, mt) +} + +// GetFuturesPositionSummary returns the account's position summary for the asset type and pair +// it can be used to calculate potential positions +func (b *Binance) GetFuturesPositionSummary(ctx context.Context, req *order.PositionSummaryRequest) (*order.PositionSummary, error) { + if req == nil { + return nil, fmt.Errorf("%w GetFuturesPositionSummary", common.ErrNilPointer) + } + if req.CalculateOffline { + return nil, common.ErrCannotCalculateOffline + } + fPair, err := b.FormatExchangeCurrency(req.Pair, req.Asset) + if err != nil { + return nil, err + } + switch req.Asset { + case asset.USDTMarginedFutures: + ai, err := b.UAccountInformationV2(ctx) + if err != nil { + return nil, err + } + collateralMode := collateral.SingleMode + if ai.MultiAssetsMargin { + collateralMode = collateral.MultiMode + } + var accountPosition *UPosition + var leverage, maintenanceMargin, initialMargin, + liquidationPrice, markPrice, positionSize, + collateralTotal, collateralUsed, collateralAvailable, + pnl, openPrice, isolatedMargin float64 + + for i := range ai.Positions { + if ai.Positions[i].Symbol != fPair.String() { + continue + } + accountPosition = &ai.Positions[i] + break + } + if accountPosition == nil { + return nil, fmt.Errorf("%w %v %v position info", currency.ErrCurrencyNotFound, req.Asset, req.Pair) + } + + var usdtAsset, busdAsset *UAsset + for i := range ai.Assets { + if usdtAsset != nil && busdAsset != nil { + break + } + if strings.EqualFold(ai.Assets[i].Asset, currency.USDT.Item.Symbol) { + usdtAsset = &ai.Assets[i] + continue + } + if strings.EqualFold(ai.Assets[i].Asset, currency.BUSD.Item.Symbol) { + busdAsset = &ai.Assets[i] + } + } + if usdtAsset == nil && busdAsset == nil { + return nil, fmt.Errorf("%w %v %v asset info", currency.ErrCurrencyNotFound, req.Asset, req.Pair) + } + + leverage = accountPosition.Leverage + openPrice = accountPosition.EntryPrice + maintenanceMargin = accountPosition.MaintenanceMargin + initialMargin = accountPosition.PositionInitialMargin + marginType := margin.Multi + if accountPosition.Isolated { + marginType = margin.Isolated + } + + var c currency.Code + if collateralMode == collateral.SingleMode { + var collateralAsset *UAsset + if strings.Contains(accountPosition.Symbol, usdtAsset.Asset) { + collateralAsset = usdtAsset + } else if strings.Contains(accountPosition.Symbol, busdAsset.Asset) { + collateralAsset = busdAsset + } + collateralTotal = collateralAsset.WalletBalance + collateralAvailable = collateralAsset.AvailableBalance + pnl = collateralAsset.UnrealizedProfit + c = currency.NewCode(collateralAsset.Asset) + if marginType == margin.Multi { + isolatedMargin = collateralAsset.CrossUnPnl + collateralUsed = collateralTotal + isolatedMargin + } else { + isolatedMargin = accountPosition.IsolatedWallet + collateralUsed = isolatedMargin + } + } else if collateralMode == collateral.MultiMode { + collateralTotal = ai.TotalWalletBalance + collateralUsed = ai.TotalWalletBalance - ai.AvailableBalance + collateralAvailable = ai.AvailableBalance + pnl = accountPosition.UnrealisedProfit + } + + var maintenanceMarginFraction decimal.Decimal + if collateralTotal != 0 { + maintenanceMarginFraction = decimal.NewFromFloat(maintenanceMargin).Div(decimal.NewFromFloat(collateralTotal)).Mul(decimal.NewFromInt32(100)) + } + + // binance so fun, some prices exclusively here + positionsInfo, err := b.UPositionsInfoV2(ctx, fPair) + if err != nil { + return nil, err + } + var relevantPosition *UPositionInformationV2 + for i := range positionsInfo { + if positionsInfo[i].Symbol != fPair.String() { + continue + } + relevantPosition = &positionsInfo[i] + } + if relevantPosition == nil { + return nil, fmt.Errorf("%w %v %v", order.ErrNoPositionsFound, req.Asset, req.Pair) + } + + return &order.PositionSummary{ + Pair: req.Pair, + Asset: req.Asset, + MarginType: marginType, + CollateralMode: collateralMode, + Currency: c, + IsolatedMargin: decimal.NewFromFloat(isolatedMargin), + Leverage: decimal.NewFromFloat(leverage), + MaintenanceMarginRequirement: decimal.NewFromFloat(maintenanceMargin), + InitialMarginRequirement: decimal.NewFromFloat(initialMargin), + EstimatedLiquidationPrice: decimal.NewFromFloat(liquidationPrice), + CollateralUsed: decimal.NewFromFloat(collateralUsed), + MarkPrice: decimal.NewFromFloat(markPrice), + CurrentSize: decimal.NewFromFloat(positionSize), + AverageOpenPrice: decimal.NewFromFloat(openPrice), + PositionPNL: decimal.NewFromFloat(pnl), + MaintenanceMarginFraction: maintenanceMarginFraction, + FreeCollateral: decimal.NewFromFloat(collateralAvailable), + TotalCollateral: decimal.NewFromFloat(collateralTotal), + NotionalSize: decimal.NewFromFloat(positionSize).Mul(decimal.NewFromFloat(markPrice)), + }, nil + case asset.CoinMarginedFutures: + ai, err := b.GetFuturesAccountInfo(ctx) + if err != nil { + return nil, err + } + collateralMode := collateral.SingleMode + var leverage, maintenanceMargin, initialMargin, + liquidationPrice, markPrice, positionSize, + collateralTotal, collateralUsed, collateralAvailable, + pnl, openPrice, isolatedMargin float64 + + var accountPosition *FuturesAccountInformationPosition + for i := range ai.Positions { + if ai.Positions[i].Symbol != fPair.String() { + continue + } + accountPosition = &ai.Positions[i] + break + } + if accountPosition == nil { + return nil, fmt.Errorf("%w %v %v position info", currency.ErrCurrencyNotFound, req.Asset, req.Pair) + } + var accountAsset *FuturesAccountAsset + for i := range ai.Assets { + // TODO: utilise contract data to discern the underlying currency + // instead of having a user provide it + if ai.Assets[i].Asset != req.UnderlyingPair.Base.Upper().String() { + continue + } + accountAsset = &ai.Assets[i] + break + } + if accountAsset == nil { + return nil, fmt.Errorf("could not get asset info: %w %v %v, please verify underlying pair: '%v'", currency.ErrCurrencyNotFound, req.Asset, req.Pair, req.UnderlyingPair) + } + + leverage = accountPosition.Leverage + openPrice = accountPosition.EntryPrice + maintenanceMargin = accountPosition.MaintenanceMargin + initialMargin = accountPosition.PositionInitialMargin + marginType := margin.Multi + if accountPosition.Isolated { + marginType = margin.Isolated + } + collateralTotal = accountAsset.WalletBalance + frozenBalance := decimal.NewFromFloat(accountAsset.WalletBalance).Sub(decimal.NewFromFloat(accountAsset.AvailableBalance)) + collateralAvailable = accountAsset.AvailableBalance + pnl = accountAsset.UnrealizedProfit + if marginType == margin.Multi { + isolatedMargin = accountAsset.CrossUnPNL + collateralUsed = collateralTotal + isolatedMargin + } else { + isolatedMargin = accountPosition.IsolatedWallet + collateralUsed = isolatedMargin + } + + // binance so fun, some prices exclusively here + positionsInfo, err := b.FuturesPositionsInfo(ctx, "", req.Pair.Base.String()) + if err != nil { + return nil, err + } + if len(positionsInfo) == 0 { + return nil, fmt.Errorf("%w %v", order.ErrNoPositionsFound, fPair) + } + var relevantPosition *FuturesPositionInformation + for i := range positionsInfo { + if positionsInfo[i].Symbol != fPair.String() { + continue + } + relevantPosition = &positionsInfo[i] + } + if relevantPosition == nil { + return nil, fmt.Errorf("%w %v %v", order.ErrNoPositionsFound, req.Asset, req.Pair) + } + liquidationPrice = relevantPosition.LiquidationPrice + markPrice = relevantPosition.MarkPrice + positionSize = relevantPosition.PositionAmount + var mmf, tc decimal.Decimal + if collateralTotal != 0 { + tc = decimal.NewFromFloat(collateralTotal) + mmf = decimal.NewFromFloat(maintenanceMargin).Div(tc).Mul(decimal.NewFromInt(100)) + } + + return &order.PositionSummary{ + Pair: req.Pair, + Asset: req.Asset, + MarginType: marginType, + CollateralMode: collateralMode, + Currency: currency.NewCode(accountAsset.Asset), + IsolatedMargin: decimal.NewFromFloat(isolatedMargin), + NotionalSize: decimal.NewFromFloat(positionSize).Mul(decimal.NewFromFloat(markPrice)), + Leverage: decimal.NewFromFloat(leverage), + MaintenanceMarginRequirement: decimal.NewFromFloat(maintenanceMargin), + InitialMarginRequirement: decimal.NewFromFloat(initialMargin), + EstimatedLiquidationPrice: decimal.NewFromFloat(liquidationPrice), + CollateralUsed: decimal.NewFromFloat(collateralUsed), + MarkPrice: decimal.NewFromFloat(markPrice), + CurrentSize: decimal.NewFromFloat(positionSize), + AverageOpenPrice: decimal.NewFromFloat(openPrice), + PositionPNL: decimal.NewFromFloat(pnl), + MaintenanceMarginFraction: mmf, + FreeCollateral: decimal.NewFromFloat(collateralAvailable), + TotalCollateral: tc, + FrozenBalance: frozenBalance, + }, nil + default: + return nil, fmt.Errorf("%w %v", asset.ErrNotSupported, req.Asset) + } +} + +// GetFuturesPositionOrders returns the orders for futures positions +func (b *Binance) GetFuturesPositionOrders(ctx context.Context, req *order.PositionsRequest) ([]order.PositionResponse, error) { + if req == nil { + return nil, fmt.Errorf("%w GetFuturesPositionOrders", common.ErrNilPointer) + } + if len(req.Pairs) == 0 { + return nil, currency.ErrCurrencyPairsEmpty + } + if time.Since(req.StartDate) > b.Features.Supports.MaximumOrderHistory+time.Hour { + if req.RespectOrderHistoryLimits { + req.StartDate = time.Now().Add(-b.Features.Supports.MaximumOrderHistory) + } else { + return nil, fmt.Errorf("%w max lookup %v", order.ErrOrderHistoryTooLarge, time.Now().Add(-b.Features.Supports.MaximumOrderHistory)) + } + } + if req.EndDate.IsZero() { + req.EndDate = time.Now() + } + + var resp []order.PositionResponse + sd := req.StartDate + switch req.Asset { + case asset.USDTMarginedFutures: + var orderLimit = 1000 + for x := range req.Pairs { + fPair, err := b.FormatExchangeCurrency(req.Pairs[x], req.Asset) + if err != nil { + return nil, err + } + result, err := b.UPositionsInfoV2(ctx, fPair) + if err != nil { + return nil, err + } + for y := range result { + currencyPosition := order.PositionResponse{ + Asset: req.Asset, + Pair: req.Pairs[x], + } + for { + var orders []UFuturesOrderData + orders, err = b.UAllAccountOrders(ctx, fPair, 0, int64(orderLimit), sd, req.EndDate) + if err != nil { + return nil, err + } + for i := range orders { + if orders[i].Time.After(req.EndDate) { + continue + } + orderVars := compatibleOrderVars(orders[i].Side, orders[i].Status, orders[i].OrderType) + var mt margin.Type + mt, err = margin.StringToMarginType(result[y].MarginType) + if err != nil { + if !errors.Is(err, margin.ErrInvalidMarginType) { + return nil, err + } + } + currencyPosition.Orders = append(currencyPosition.Orders, order.Detail{ + ReduceOnly: orders[i].ClosePosition, + Price: orders[i].Price, + Amount: orders[i].ExecutedQty, + TriggerPrice: orders[i].ActivatePrice, + AverageExecutedPrice: orders[i].AvgPrice, + ExecutedAmount: orders[i].ExecutedQty, + RemainingAmount: orders[i].OrigQty - orders[i].ExecutedQty, + CostAsset: req.Pairs[x].Quote, + Leverage: result[y].Leverage, + Exchange: b.Name, + OrderID: strconv.FormatInt(orders[i].OrderID, 10), + ClientOrderID: orders[i].ClientOrderID, + Type: orderVars.OrderType, + Side: orderVars.Side, + Status: orderVars.Status, + AssetType: asset.USDTMarginedFutures, + Date: orders[i].Time, + LastUpdated: orders[i].UpdateTime, + Pair: req.Pairs[x], + MarginType: mt, + }) + } + if len(orders) < orderLimit { + break + } + sd = currencyPosition.Orders[len(currencyPosition.Orders)-1].Date + } + resp = append(resp, currencyPosition) + } + } + case asset.CoinMarginedFutures: + var orderLimit = 100 + for x := range req.Pairs { + fPair, err := b.FormatExchangeCurrency(req.Pairs[x], req.Asset) + if err != nil { + return nil, err + } + // "pair" for coinmarginedfutures is the pair.Base + // eg ADAUSD_PERP the pair is ADAUSD + result, err := b.FuturesPositionsInfo(ctx, "", fPair.Base.String()) + if err != nil { + return nil, err + } + currencyPosition := order.PositionResponse{ + Asset: req.Asset, + Pair: req.Pairs[x], + } + for y := range result { + if result[y].PositionAmount == 0 { + continue + } + for { + var orders []FuturesOrderData + orders, err = b.GetAllFuturesOrders(ctx, fPair, currency.EMPTYPAIR, sd, req.EndDate, 0, int64(orderLimit)) + if err != nil { + return nil, err + } + for i := range orders { + if orders[i].Time.After(req.EndDate) { + continue + } + var orderPair currency.Pair + orderPair, err = currency.NewPairFromString(orders[i].Pair) + if err != nil { + return nil, err + } + orderVars := compatibleOrderVars(orders[i].Side, orders[i].Status, orders[i].OrderType) + var mt margin.Type + mt, err = margin.StringToMarginType(result[y].MarginType) + if err != nil { + if !errors.Is(err, margin.ErrInvalidMarginType) { + return nil, err + } + } + currencyPosition.Orders = append(currencyPosition.Orders, order.Detail{ + ReduceOnly: orders[i].ClosePosition, + Price: orders[i].Price, + Amount: orders[i].ExecutedQty, + TriggerPrice: orders[i].ActivatePrice, + AverageExecutedPrice: orders[i].AvgPrice, + ExecutedAmount: orders[i].ExecutedQty, + RemainingAmount: orders[i].OrigQty - orders[i].ExecutedQty, + Leverage: result[y].Leverage, + CostAsset: orderPair.Base, + Exchange: b.Name, + OrderID: strconv.FormatInt(orders[i].OrderID, 10), + ClientOrderID: orders[i].ClientOrderID, + Type: orderVars.OrderType, + Side: orderVars.Side, + Status: orderVars.Status, + AssetType: asset.CoinMarginedFutures, + Date: orders[i].Time, + LastUpdated: orders[i].UpdateTime, + Pair: req.Pairs[x], + MarginType: mt, + }) + } + if len(orders) < orderLimit { + break + } + sd = currencyPosition.Orders[len(currencyPosition.Orders)-1].Date + } + resp = append(resp, currencyPosition) + } + } + default: + return nil, fmt.Errorf("%w %v", asset.ErrNotSupported, req.Asset) + } + return resp, nil +} + +// SetLeverage sets the account's initial leverage for the asset type and pair +func (b *Binance) SetLeverage(ctx context.Context, item asset.Item, pair currency.Pair, _ margin.Type, amount float64, _ order.Side) error { + switch item { + case asset.USDTMarginedFutures: + _, err := b.UChangeInitialLeverageRequest(ctx, pair, amount) + return err + case asset.CoinMarginedFutures: + _, err := b.FuturesChangeInitialLeverage(ctx, pair, amount) + return err + default: + return fmt.Errorf("%w %v", asset.ErrNotSupported, item) + } +} + +// GetLeverage gets the account's initial leverage for the asset type and pair +func (b *Binance) GetLeverage(ctx context.Context, item asset.Item, pair currency.Pair, _ margin.Type, _ order.Side) (float64, error) { + if pair.IsEmpty() { + return -1, currency.ErrCurrencyPairEmpty + } + switch item { + case asset.USDTMarginedFutures: + resp, err := b.UPositionsInfoV2(ctx, pair) + if err != nil { + return -1, err + } + if len(resp) == 0 { + return -1, fmt.Errorf("%w %v %v", order.ErrPositionNotFound, item, pair) + } + // leverage is the same across positions + return resp[0].Leverage, nil + case asset.CoinMarginedFutures: + resp, err := b.FuturesPositionsInfo(ctx, "", pair.Base.String()) + if err != nil { + return -1, err + } + if len(resp) == 0 { + return -1, fmt.Errorf("%w %v %v", order.ErrPositionNotFound, item, pair) + } + // leverage is the same across positions + return resp[0].Leverage, nil + default: + return -1, fmt.Errorf("%w %v", asset.ErrNotSupported, item) + } +} diff --git a/exchanges/binance/cfutures_types.go b/exchanges/binance/cfutures_types.go index c4983362110..d9a8d2f6a96 100644 --- a/exchanges/binance/cfutures_types.go +++ b/exchanges/binance/cfutures_types.go @@ -359,12 +359,12 @@ type FuturesAccountBalanceData struct { UpdateTime int64 `json:"updateTime"` } -// FuturesAccountInformationPositions holds account position data -type FuturesAccountInformationPositions struct { +// FuturesAccountInformationPosition holds account position data +type FuturesAccountInformationPosition struct { Symbol string `json:"symbol"` Amount float64 `json:"positionAmt,string"` InitialMargin float64 `json:"initialMargin,string"` - MaintMargin float64 `json:"maintMargin,string"` + MaintenanceMargin float64 `json:"maintMargin,string"` UnrealizedProfit float64 `json:"unrealizedProfit,string"` PositionInitialMargin float64 `json:"positionInitialMargin,string"` OpenOrderInitialMargin float64 `json:"openOrderInitialMargin,string"` @@ -380,26 +380,29 @@ type FuturesAccountInformationPositions struct { // FuturesAccountInformation stores account information for futures account type FuturesAccountInformation struct { - Assets []struct { - Asset string `json:"asset"` - WalletBalance float64 `json:"walletBalance,string"` - UnrealizedProfit float64 `json:"unrealizedProfit,string"` - MarginBalance float64 `json:"marginBalance,string"` - MaintMargin float64 `json:"maintMargin,string"` - InitialMargin float64 `json:"initialMargin,string"` - PositionInitialMargin float64 `json:"positionInitialMargin,string"` - OpenOrderInitialMargin float64 `json:"openOrderInitialMargin,string"` - MaxWithdrawAmount float64 `json:"maxWithdrawAmount,string"` - CrossWalletBalance float64 `json:"crossWalletBalance,string"` - CrossUnPNL float64 `json:"crossUnPnl,string"` - AvailableBalance float64 `json:"availableBalance,string"` - } `json:"assets"` - Positions []FuturesAccountInformationPositions `json:"positions"` - CanDeposit bool `json:"canDeposit"` - CanTrade bool `json:"canTrade"` - CanWithdraw bool `json:"canWithdraw"` - FeeTier int64 `json:"feeTier"` - UpdateTime time.Time `json:"updateTime"` + Assets []FuturesAccountAsset `json:"assets"` + Positions []FuturesAccountInformationPosition `json:"positions"` + CanDeposit bool `json:"canDeposit"` + CanTrade bool `json:"canTrade"` + CanWithdraw bool `json:"canWithdraw"` + FeeTier int64 `json:"feeTier"` + UpdateTime time.Time `json:"updateTime"` +} + +// FuturesAccountAsset holds account asset information +type FuturesAccountAsset struct { + Asset string `json:"asset"` + WalletBalance float64 `json:"walletBalance,string"` + UnrealizedProfit float64 `json:"unrealizedProfit,string"` + MarginBalance float64 `json:"marginBalance,string"` + MaintenanceMargin float64 `json:"maintMargin,string"` + InitialMargin float64 `json:"initialMargin,string"` + PositionInitialMargin float64 `json:"positionInitialMargin,string"` + OpenOrderInitialMargin float64 `json:"openOrderInitialMargin,string"` + MaxWithdrawAmount float64 `json:"maxWithdrawAmount,string"` + CrossWalletBalance float64 `json:"crossWalletBalance,string"` + CrossUnPNL float64 `json:"crossUnPnl,string"` + AvailableBalance float64 `json:"availableBalance,string"` } // GenericAuthResponse is a general data response for a post auth request @@ -408,6 +411,13 @@ type GenericAuthResponse struct { Msg string `json:"msg"` } +// FuturesMarginUpdatedResponse stores margin update response data +type FuturesMarginUpdatedResponse struct { + Amount float64 `json:"amount"` + Type int `json:"type"` + GenericAuthResponse +} + // FuturesLeverageData stores leverage data for futures type FuturesLeverageData struct { Leverage int64 `json:"leverage"` @@ -435,18 +445,21 @@ type GetPositionMarginChangeHistoryData struct { // FuturesPositionInformation stores futures position info type FuturesPositionInformation struct { - Symbol string `json:"symbol"` - PositionAmount float64 `json:"positionAmt,string"` - EntryPrice float64 `json:"entryPrice,string"` - MarkPrice float64 `json:"markPrice,string"` - UnrealizedProfit float64 `json:"unRealizedProfit,string"` - LiquidationPrice float64 `json:"liquidation,string"` - Leverage int64 `json:"leverage"` - MaxQty float64 `json:"maxQty"` - MarginType string `json:"marginType"` - IsolatedMargin float64 `json:"isolatedMargin,string"` - IsAutoAddMargin bool `json:"isAutoAddMargin"` - PositionSide string `json:"positionSide"` + Symbol string `json:"symbol"` + PositionAmount float64 `json:"positionAmt,string"` + EntryPrice float64 `json:"entryPrice,string"` + MarkPrice float64 `json:"markPrice,string"` + UnRealizedProfit float64 `json:"unRealizedProfit,string"` + LiquidationPrice float64 `json:"liquidationPrice,string"` + Leverage float64 `json:"leverage,string"` + MaxQty float64 `json:"maxQty,string"` + MarginType string `json:"marginType"` + IsolatedMargin float64 `json:"isolatedMargin,string"` + IsAutoAddMargin bool `json:"isAutoAddMargin,string"` + PositionSide string `json:"positionSide"` + NotionalValue float64 `json:"notionalValue,string"` + IsolatedWallet float64 `json:"isolatedWallet,string"` + UpdateTime binanceTime `json:"updateTime"` } // FuturesAccountTradeList stores account trade list data diff --git a/exchanges/binance/ratelimit.go b/exchanges/binance/ratelimit.go index 165cdaf50ac..c56f16038ca 100644 --- a/exchanges/binance/ratelimit.go +++ b/exchanges/binance/ratelimit.go @@ -92,6 +92,8 @@ const ( cFuturesAccountInformationRate cFuturesOrderbookTickerAllRate cFuturesOrdersDefaultRate + uFuturesMultiAssetMarginRate + uFuturesSetMultiAssetMarginRate ) // RateLimit implements the request.Limiter interface @@ -211,6 +213,10 @@ func (r *RateLimit) Limit(ctx context.Context, f request.EndpointLimit) error { limiter, tokens = r.CFuturesRate, 20 case cFuturesDefaultRate: limiter, tokens = r.CFuturesRate, 1 + case uFuturesMultiAssetMarginRate: + limiter, tokens = r.UFuturesRate, 30 + case uFuturesSetMultiAssetMarginRate: + limiter, tokens = r.UFuturesRate, 1 default: limiter, tokens = r.SpotRate, 1 } diff --git a/exchanges/binance/type_convert.go b/exchanges/binance/type_convert.go index 6de53fdccbf..35c7d5527b6 100644 --- a/exchanges/binance/type_convert.go +++ b/exchanges/binance/type_convert.go @@ -53,7 +53,7 @@ func (a *ExchangeInfo) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &aux); err != nil { return err } - a.Servertime = aux.Servertime.Time() + a.ServerTime = aux.Servertime.Time() return nil } @@ -458,8 +458,8 @@ func (u *UFuturesSymbolInfo) UnmarshalJSON(data []byte) error { } // UnmarshalJSON deserialises the JSON info, including the timestamp -func (a *FuturesAccountInformationPositions) UnmarshalJSON(data []byte) error { - type Alias FuturesAccountInformationPositions +func (a *FuturesAccountInformationPosition) UnmarshalJSON(data []byte) error { + type Alias FuturesAccountInformationPosition aux := &struct { UpdateTime binanceTime `json:"updateTime"` diff --git a/exchanges/binance/ufutures_types.go b/exchanges/binance/ufutures_types.go index 1e7a192e86d..dbd66dda1d0 100644 --- a/exchanges/binance/ufutures_types.go +++ b/exchanges/binance/ufutures_types.go @@ -251,49 +251,61 @@ type UAccountBalanceV2Data struct { // UAccountInformationV2Data stores account info for ufutures type UAccountInformationV2Data struct { - FeeTier int64 `json:"feeTier"` - CanTrade bool `json:"canTrade"` - CanDeposit bool `json:"canDeposit"` - CanWithdraw bool `json:"canWithdraw"` - UpdateTime int64 `json:"updateTime"` - TotalInitialMargin float64 `json:"totalInitialMargin,string"` - TotalMaintenance float64 `json:"totalMaintMargin,string"` - TotalWalletBalance float64 `json:"totalWalletBalance,string"` - TotalUnrealizedProfit float64 `json:"totalUnrealizedProfit,string"` - TotalMarginBalance float64 `json:"totalMarginBalance,string"` - TotalPositionInitialMargin float64 `json:"totalPositionInitialMargin,string"` - TotalOpenOrderInitialMargin float64 `json:"totalOpenOrderInitialMargin,string"` - TotalCrossWalletBalance float64 `json:"totalCrossWalletBalance,string"` - TotalCrossUnrealizedPNL float64 `json:"totalCrossUnPnl,string"` - AvailableBalance float64 `json:"availableBalance,string"` - MaxWithdrawAmount float64 `json:"maxWithdrawAmount,string"` - Assets []struct { - Asset string `json:"asset"` - WalletBalance float64 `json:"walletBalance,string"` - UnrealizedProfit float64 `json:"unrealizedProfit,string"` - MarginBalance float64 `json:"marginBalance,string"` - MaintMargin float64 `json:"maintMargin,string"` - InitialMargin float64 `json:"initialMargin,string"` - PositionInitialMargin float64 `json:"positionInitialMargin,string"` - OpenOrderInitialMargin float64 `json:"openOrderInitialMargin,string"` - CrossWalletBalance float64 `json:"crossWalletBalance,string"` - CrossUnPnl float64 `json:"crossUnPnl,string"` - AvailableBalance float64 `json:"availableBalance,string"` - MaxWithdrawAmount float64 `json:"maxWithdrawAmount,string"` - } `json:"assets"` - Positions []struct { - Symbol string `json:"symbol"` - InitialMargin float64 `json:"initialMargin,string"` - MaintenanceMargin float64 `json:"maintMargin,string"` - UnrealizedProfit float64 `json:"unrealizedProfit,string"` - PositionInitialMargin float64 `json:"positionInitialMargin,string"` - OpenOrderInitialMargin float64 `json:"openOrderInitialMargin,string"` - Leverage float64 `json:"leverage,string"` - Isolated bool `json:"isolated"` - EntryPrice float64 `json:"entryPrice,string"` - MaxNotional float64 `json:"maxNotional,string"` - PositionSide string `json:"positionSide"` - } `json:"positions"` + FeeTier int64 `json:"feeTier"` + CanTrade bool `json:"canTrade"` + CanDeposit bool `json:"canDeposit"` + CanWithdraw bool `json:"canWithdraw"` + UpdateTime int64 `json:"updateTime"` + MultiAssetsMargin bool `json:"multiAssetsMargin"` + TotalInitialMargin float64 `json:"totalInitialMargin,string"` + TotalMaintenanceMargin float64 `json:"totalMaintMargin,string"` + TotalWalletBalance float64 `json:"totalWalletBalance,string"` + TotalUnrealizedProfit float64 `json:"totalUnrealizedProfit,string"` + TotalMarginBalance float64 `json:"totalMarginBalance,string"` + TotalPositionInitialMargin float64 `json:"totalPositionInitialMargin,string"` + TotalOpenOrderInitialMargin float64 `json:"totalOpenOrderInitialMargin,string"` + TotalCrossWalletBalance float64 `json:"totalCrossWalletBalance,string"` + TotalCrossUnrealizedPNL float64 `json:"totalCrossUnPnl,string"` + AvailableBalance float64 `json:"availableBalance,string"` + MaxWithdrawAmount float64 `json:"maxWithdrawAmount,string"` + Assets []UAsset `json:"assets"` + Positions []UPosition `json:"positions"` +} + +// UAsset holds account asset information +type UAsset struct { + Asset string `json:"asset"` + WalletBalance float64 `json:"walletBalance,string"` + UnrealizedProfit float64 `json:"unrealizedProfit,string"` + MarginBalance float64 `json:"marginBalance,string"` + MaintenanceMargin float64 `json:"maintMargin,string"` + InitialMargin float64 `json:"initialMargin,string"` + PositionInitialMargin float64 `json:"positionInitialMargin,string"` + OpenOrderInitialMargin float64 `json:"openOrderInitialMargin,string"` + CrossWalletBalance float64 `json:"crossWalletBalance,string"` + CrossUnPnl float64 `json:"crossUnPnl,string"` + AvailableBalance float64 `json:"availableBalance,string"` + MaxWithdrawAmount float64 `json:"maxWithdrawAmount,string"` +} + +// UPosition holds account position information +type UPosition struct { + Symbol string `json:"symbol"` + InitialMargin float64 `json:"initialMargin,string"` + MaintenanceMargin float64 `json:"maintMargin,string"` + UnrealisedProfit float64 `json:"unrealizedProfit,string"` + PositionInitialMargin float64 `json:"positionInitialMargin,string"` + OpenOrderInitialMargin float64 `json:"openOrderInitialMargin,string"` + Leverage float64 `json:"leverage,string"` + Isolated bool `json:"isolated"` + IsolatedWallet float64 `json:"isolatedWallet,string"` + EntryPrice float64 `json:"entryPrice,string"` + MaxNotional float64 `json:"maxNotional,string"` + BidNotional float64 `json:"bidNotional,string"` + AskNotional float64 `json:"askNotional,string"` + PositionSide string `json:"positionSide"` + PositionAmount float64 `json:"positionAmt,string"` + UpdateTime binanceTime `json:"updateTime"` } // UChangeInitialLeverage stores leverage change data @@ -321,18 +333,21 @@ type UPositionMarginChangeHistoryData struct { // UPositionInformationV2 stores positions data type UPositionInformationV2 struct { - EntryPrice float64 `json:"entryPrice,string"` - MarginType string `json:"marginType"` - AutoAddMarginEnabled bool `json:"isAutoAddMargin,string"` - IsolatedMargin float64 `json:"isolatedMargin,string"` - Leverage float64 `json:"leverage,string"` - LiquidationPrice float64 `json:"liquidationPrice,string"` - MarkPrice float64 `json:"markPrice,string"` - MaxNotionalValue float64 `json:"maxNotionalValue,string"` - PositionAmount float64 `json:"positionAmt,string"` - Symbol string `json:"symbol"` - UnrealizedProfit float64 `json:"unrealizedProfit,string"` - PositionSide string `json:"positionSide"` + Symbol string `json:"symbol"` + PositionAmount float64 `json:"positionAmt,string"` + EntryPrice float64 `json:"entryPrice,string"` + MarkPrice float64 `json:"markPrice,string"` + UnrealizedProfit float64 `json:"unrealizedProfit,string"` + LiquidationPrice float64 `json:"liquidationPrice,string"` + Leverage float64 `json:"leverage,string"` + MaxNotionalValue float64 `json:"maxNotionalValue,string"` + MarginType string `json:"marginType"` + IsAutoAddMargin bool `json:"isAutoAddMargin,string"` + PositionSide string `json:"positionSide"` + Notional float64 `json:"notional,string"` + IsolatedWallet float64 `json:"isolatedWallet,string"` + IsolatedMargin float64 `json:"isolatedMargin,string"` + UpdateTime binanceTime `json:"updateTime"` } // UAccountTradeHistory stores trade data for the users account diff --git a/exchanges/bybit/bybit.go b/exchanges/bybit/bybit.go index 8a9facf5e78..c2261c8ce5f 100644 --- a/exchanges/bybit/bybit.go +++ b/exchanges/bybit/bybit.go @@ -174,7 +174,7 @@ func (by *Bybit) GetTrades(ctx context.Context, symbol string, limit int64) ([]T params.Set("symbol", symbol) strLimit := "60" // default limit - if limit > 0 && limit < 60 { + if limit > 0 { strLimit = strconv.FormatInt(limit, 10) } params.Set("limit", strLimit) diff --git a/exchanges/bybit/bybit_cfutures.go b/exchanges/bybit/bybit_cfutures.go index 2ebc5590b9a..04d7fc7d9ac 100644 --- a/exchanges/bybit/bybit_cfutures.go +++ b/exchanges/bybit/bybit_cfutures.go @@ -131,7 +131,7 @@ func (by *Bybit) GetFuturesKlineData(ctx context.Context, symbol currency.Pair, } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -178,7 +178,7 @@ func (by *Bybit) GetPublicTrades(ctx context.Context, symbol currency.Pair, limi return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -208,7 +208,7 @@ func (by *Bybit) GetMarkPriceKline(ctx context.Context, symbol currency.Pair, in return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -237,7 +237,7 @@ func (by *Bybit) GetIndexPriceKline(ctx context.Context, symbol currency.Pair, i return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -266,7 +266,7 @@ func (by *Bybit) GetPremiumIndexPriceKline(ctx context.Context, symbol currency. return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -295,7 +295,7 @@ func (by *Bybit) GetOpenInterest(ctx context.Context, symbol currency.Pair, peri return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesPeriods, period) { @@ -320,7 +320,7 @@ func (by *Bybit) GetLatestBigDeal(ctx context.Context, symbol currency.Pair, lim return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -341,7 +341,7 @@ func (by *Bybit) GetAccountRatio(ctx context.Context, symbol currency.Pair, peri return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesPeriods, period) { @@ -491,7 +491,7 @@ func (by *Bybit) GetActiveCoinFuturesOrders(ctx context.Context, symbol currency if direction != "" { params.Set("direction", direction) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if cursor != "" { @@ -709,7 +709,7 @@ func (by *Bybit) GetConditionalCoinFuturesOrders(ctx context.Context, symbol cur if direction != "" { params.Set("direction", direction) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if cursor != "" { @@ -999,7 +999,7 @@ func (by *Bybit) GetCoinTradeRecords(ctx context.Context, symbol currency.Pair, if page != 0 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -1036,7 +1036,7 @@ func (by *Bybit) GetClosedCoinTrades(ctx context.Context, symbol currency.Pair, if page > 0 && page <= 50 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -1247,7 +1247,7 @@ func (by *Bybit) GetWalletFundRecords(ctx context.Context, startDate, endDate, c if page != 0 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -1280,7 +1280,7 @@ func (by *Bybit) GetWalletWithdrawalRecords(ctx context.Context, startDate, endD if page != 0 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -1303,7 +1303,7 @@ func (by *Bybit) GetAssetExchangeRecords(ctx context.Context, direction string, if from != 0 { params.Set("from", strconv.FormatInt(from, 10)) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } diff --git a/exchanges/bybit/bybit_futures.go b/exchanges/bybit/bybit_futures.go index dc7f44dc5b9..6ee6d823695 100644 --- a/exchanges/bybit/bybit_futures.go +++ b/exchanges/bybit/bybit_futures.go @@ -122,7 +122,7 @@ func (by *Bybit) GetActiveFuturesOrders(ctx context.Context, symbol currency.Pai if direction != "" { params.Set("direction", direction) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if cursor != "" { @@ -345,7 +345,7 @@ func (by *Bybit) GetConditionalFuturesOrders(ctx context.Context, symbol currenc if direction != "" { params.Set("direction", direction) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if cursor != "" { @@ -583,8 +583,8 @@ func (by *Bybit) SetTradingAndStop(ctx context.Context, positionMode int64, symb return resp.Result, by.SendAuthHTTPRequest(ctx, exchange.RestFutures, http.MethodPost, futuresSetTradingStop, params, nil, &resp, futuresSetTradingStopRate) } -// SetLeverage sets leverage -func (by *Bybit) SetLeverage(ctx context.Context, symbol currency.Pair, buyLeverage, sellLeverage float64) (float64, error) { +// SetLeverageLevel sets leverage +func (by *Bybit) SetLeverageLevel(ctx context.Context, symbol currency.Pair, buyLeverage, sellLeverage float64) (float64, error) { resp := struct { Result float64 `json:"result"` Error @@ -685,7 +685,7 @@ func (by *Bybit) GetTradeRecords(ctx context.Context, symbol currency.Pair, orde if page != 0 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -721,7 +721,7 @@ func (by *Bybit) GetClosedTrades(ctx context.Context, symbol currency.Pair, exec if page > 0 && page <= 50 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } diff --git a/exchanges/bybit/bybit_test.go b/exchanges/bybit/bybit_test.go index 10658e8c242..a8972cc1874 100644 --- a/exchanges/bybit/bybit_test.go +++ b/exchanges/bybit/bybit_test.go @@ -1870,7 +1870,7 @@ func TestSetLeverage(t *testing.T) { t.Fatal(err) } - _, err = b.SetLeverage(context.Background(), pair, 10, 10) + _, err = b.SetLeverageLevel(context.Background(), pair, 10, 10) if err != nil { t.Error(err) } diff --git a/exchanges/bybit/bybit_ufutures.go b/exchanges/bybit/bybit_ufutures.go index 220cc731e16..a779ab98454 100644 --- a/exchanges/bybit/bybit_ufutures.go +++ b/exchanges/bybit/bybit_ufutures.go @@ -72,7 +72,7 @@ func (by *Bybit) GetUSDTFuturesKlineData(ctx context.Context, symbol currency.Pa } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -101,7 +101,7 @@ func (by *Bybit) GetUSDTPublicTrades(ctx context.Context, symbol currency.Pair, return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 1000 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -122,7 +122,7 @@ func (by *Bybit) GetUSDTMarkPriceKline(ctx context.Context, symbol currency.Pair return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -151,7 +151,7 @@ func (by *Bybit) GetUSDTIndexPriceKline(ctx context.Context, symbol currency.Pai return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -180,7 +180,7 @@ func (by *Bybit) GetUSDTPremiumIndexPriceKline(ctx context.Context, symbol curre return resp.Data, err } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if !common.StringDataCompare(validFuturesIntervals, interval) { @@ -327,7 +327,7 @@ func (by *Bybit) GetActiveUSDTFuturesOrders(ctx context.Context, symbol currency if page > 0 && page <= 50 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if orderID != "" { @@ -559,7 +559,7 @@ func (by *Bybit) GetConditionalUSDTFuturesOrders(ctx context.Context, symbol cur if direction != "" { params.Set("order", direction) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } if page != 0 { @@ -940,7 +940,7 @@ func (by *Bybit) GetUSDTTradeRecords(ctx context.Context, symbol currency.Pair, if page != 0 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data.Trades, by.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodGet, ufuturesGetTrades, params, nil, &resp, uFuturesGetTradesRate) @@ -975,7 +975,7 @@ func (by *Bybit) GetClosedUSDTTrades(ctx context.Context, symbol currency.Pair, if page > 0 && page <= 50 { params.Set("page", strconv.FormatInt(page, 10)) } - if limit > 0 && limit <= 50 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data.Trades, by.SendAuthHTTPRequest(ctx, exchange.RestUSDTMargined, http.MethodGet, ufuturesGetClosedTrades, params, nil, &resp, uFuturesGetClosedTradesRate) diff --git a/exchanges/bybit/bybit_usdcfutures.go b/exchanges/bybit/bybit_usdcfutures.go index 516b883f1c4..352db1935fd 100644 --- a/exchanges/bybit/bybit_usdcfutures.go +++ b/exchanges/bybit/bybit_usdcfutures.go @@ -115,7 +115,7 @@ func (by *Bybit) GetUSDCContracts(ctx context.Context, symbol currency.Pair, dir if direction != "" { params.Set("direction", direction) } - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } @@ -169,7 +169,7 @@ func (by *Bybit) GetUSDCKlines(ctx context.Context, symbol currency.Pair, period } params.Set("startTime", strconv.FormatInt(startTime.Unix(), 10)) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data, by.SendHTTPRequest(ctx, exchange.RestUSDCMargined, common.EncodeURLValues(usdcfuturesGetKlines, params), usdcPublicRate, &resp) @@ -202,7 +202,7 @@ func (by *Bybit) GetUSDCMarkPriceKlines(ctx context.Context, symbol currency.Pai } params.Set("startTime", strconv.FormatInt(startTime.Unix(), 10)) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data, by.SendHTTPRequest(ctx, exchange.RestUSDCMargined, common.EncodeURLValues(usdcfuturesGetMarkPriceKlines, params), usdcPublicRate, &resp) @@ -235,7 +235,7 @@ func (by *Bybit) GetUSDCIndexPriceKlines(ctx context.Context, symbol currency.Pa } params.Set("startTime", strconv.FormatInt(startTime.Unix(), 10)) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data, by.SendHTTPRequest(ctx, exchange.RestUSDCMargined, common.EncodeURLValues(usdcfuturesGetIndexPriceKlines, params), usdcPublicRate, &resp) @@ -268,7 +268,7 @@ func (by *Bybit) GetUSDCPremiumIndexKlines(ctx context.Context, symbol currency. } params.Set("startTime", strconv.FormatInt(startTime.Unix(), 10)) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data, by.SendHTTPRequest(ctx, exchange.RestUSDCMargined, common.EncodeURLValues(usdcfuturesGetPremiumIndexKlines, params), usdcPublicRate, &resp) @@ -296,7 +296,7 @@ func (by *Bybit) GetUSDCOpenInterest(ctx context.Context, symbol currency.Pair, } params.Set("period", period) - if limit > 0 && limit <= 200 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data, by.SendHTTPRequest(ctx, exchange.RestUSDCMargined, common.EncodeURLValues(usdcfuturesGetOpenInterest, params), usdcPublicRate, &resp) @@ -319,7 +319,7 @@ func (by *Bybit) GetUSDCLargeOrders(ctx context.Context, symbol currency.Pair, l } params.Set("symbol", symbolValue) - if limit > 0 && limit <= 100 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data, by.SendHTTPRequest(ctx, exchange.RestUSDCMargined, common.EncodeURLValues(usdcfuturesGetLargeOrders, params), usdcPublicRate, &resp) @@ -347,7 +347,7 @@ func (by *Bybit) GetUSDCAccountRatio(ctx context.Context, symbol currency.Pair, } params.Set("period", period) - if limit > 0 && limit <= 500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Data, by.SendHTTPRequest(ctx, exchange.RestUSDCMargined, common.EncodeURLValues(usdcfuturesGetAccountRatio, params), usdcPublicRate, &resp) @@ -378,7 +378,7 @@ func (by *Bybit) GetUSDCLatestTrades(ctx context.Context, symbol currency.Pair, params.Set("symbol", symbolValue) } - if limit > 0 && limit <= 500 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) } return resp.Result.Data, by.SendHTTPRequest(ctx, exchange.RestUSDCMargined, common.EncodeURLValues(usdcfuturesGetLatestTrades, params), usdcPublicRate, &resp) @@ -749,7 +749,7 @@ func (by *Bybit) GetUSDCTradeHistory(ctx context.Context, symbol currency.Pair, req["direction"] = direction } - if limit > 0 && limit <= 50 { + if limit > 0 { req["limit"] = strconv.FormatInt(limit, 10) } @@ -792,7 +792,7 @@ func (by *Bybit) GetUSDCTransactionLog(ctx context.Context, startTime, endTime t req["direction"] = direction } - if limit > 0 && limit <= 50 { + if limit > 0 { req["limit"] = strconv.FormatInt(limit, 10) } @@ -875,7 +875,7 @@ func (by *Bybit) GetUSDCPosition(ctx context.Context, symbol currency.Pair, cate req["direction"] = direction } - if limit > 0 && limit <= 50 { + if limit > 0 { req["limit"] = strconv.FormatInt(limit, 10) } @@ -939,7 +939,7 @@ func (by *Bybit) GetUSDCSettlementHistory(ctx context.Context, symbol currency.P req["direction"] = direction } - if limit > 0 && limit <= 50 { + if limit > 0 { req["limit"] = strconv.FormatInt(limit, 10) } diff --git a/exchanges/collateral/collateral.go b/exchanges/collateral/collateral.go new file mode 100644 index 00000000000..77b045b2a4e --- /dev/null +++ b/exchanges/collateral/collateral.go @@ -0,0 +1,71 @@ +package collateral + +import ( + "encoding/json" + "fmt" + "strings" +) + +// Valid returns whether the collateral mode is valid +func (t Mode) Valid() bool { + return t != UnsetMode && supportedCollateralModes&t == t +} + +// UnmarshalJSON converts json into collateral mode +func (t *Mode) UnmarshalJSON(d []byte) error { + var mode string + err := json.Unmarshal(d, &mode) + if err != nil { + return err + } + *t, err = StringToMode(mode) + return err +} + +// String returns the string representation of the collateral mode in lowercase +// the absence of a lower func should hopefully highlight that String is lower +func (t Mode) String() string { + switch t { + case UnsetMode: + return unsetCollateralStr + case SingleMode: + return singleCollateralStr + case MultiMode: + return multiCollateralStr + case PortfolioMode: + return portfolioCollateralStr + case UnknownMode: + return unknownCollateralStr + } + return "" +} + +// Upper returns the upper case string representation of the collateral mode +func (t Mode) Upper() string { + return strings.ToUpper(t.String()) +} + +// IsValidCollateralModeString checks to see if the supplied string is a valid collateral mode +func IsValidCollateralModeString(m string) bool { + switch strings.ToLower(m) { + case singleCollateralStr, multiCollateralStr, portfolioCollateralStr, unsetCollateralStr: + return true + } + return false +} + +// StringToMode converts a string to a collateral mode +// doesn't error, just returns unknown if the string is not recognised +func StringToMode(m string) (Mode, error) { + switch strings.ToLower(m) { + case singleCollateralStr: + return SingleMode, nil + case multiCollateralStr: + return MultiMode, nil + case portfolioCollateralStr: + return PortfolioMode, nil + case "": + return UnsetMode, nil + } + return UnknownMode, fmt.Errorf("%w %v", ErrInvalidCollateralMode, m) +} diff --git a/exchanges/collateral/collateral_test.go b/exchanges/collateral/collateral_test.go new file mode 100644 index 00000000000..60aae825a53 --- /dev/null +++ b/exchanges/collateral/collateral_test.go @@ -0,0 +1,180 @@ +package collateral + +import ( + "encoding/json" + "errors" + "strings" + "testing" +) + +func TestValidCollateralType(t *testing.T) { + t.Parallel() + if !SingleMode.Valid() { + t.Fatal("expected 'true', received 'false'") + } + if !MultiMode.Valid() { + t.Fatal("expected 'true', received 'false'") + } + if !PortfolioMode.Valid() { + t.Fatal("expected 'true', received 'false'") + } + if UnsetMode.Valid() { + t.Fatal("expected 'false', received 'true'") + } + if UnknownMode.Valid() { + t.Fatal("expected 'false', received 'true'") + } + if Mode(137).Valid() { + t.Fatal("expected 'false', received 'true'") + } +} + +func TestUnmarshalJSONCollateralType(t *testing.T) { + t.Parallel() + type martian struct { + M Mode `json:"collateral"` + } + + var alien martian + jason := []byte(`{"collateral":"single"}`) + err := json.Unmarshal(jason, &alien) + if err != nil { + t.Error(err) + } + if alien.M != SingleMode { + t.Errorf("received '%v' expected 'single'", alien.M) + } + + jason = []byte(`{"collateral":"multi"}`) + err = json.Unmarshal(jason, &alien) + if err != nil { + t.Error(err) + } + if alien.M != MultiMode { + t.Errorf("received '%v' expected 'Multi'", alien.M) + } + + jason = []byte(`{"collateral":"portfolio"}`) + err = json.Unmarshal(jason, &alien) + if err != nil { + t.Error(err) + } + if alien.M != PortfolioMode { + t.Errorf("received '%v' expected 'Portfolio'", alien.M) + } + + jason = []byte(`{"collateral":"hello moto"}`) + err = json.Unmarshal(jason, &alien) + if !errors.Is(err, ErrInvalidCollateralMode) { + t.Error(err) + } + if alien.M != UnknownMode { + t.Errorf("received '%v' expected 'UnknownMode'", alien.M) + } +} + +func TestStringCollateralType(t *testing.T) { + t.Parallel() + if UnknownMode.String() != unknownCollateralStr { + t.Errorf("received '%v' expected '%v'", UnknownMode.String(), unknownCollateralStr) + } + if SingleMode.String() != singleCollateralStr { + t.Errorf("received '%v' expected '%v'", SingleMode.String(), singleCollateralStr) + } + if MultiMode.String() != multiCollateralStr { + t.Errorf("received '%v' expected '%v'", MultiMode.String(), multiCollateralStr) + } + if PortfolioMode.String() != portfolioCollateralStr { + t.Errorf("received '%v' expected '%v'", PortfolioMode.String(), portfolioCollateralStr) + } + if UnsetMode.String() != unsetCollateralStr { + t.Errorf("received '%v' expected '%v'", UnsetMode.String(), unsetCollateralStr) + } +} + +func TestUpperCollateralType(t *testing.T) { + t.Parallel() + if UnknownMode.Upper() != strings.ToUpper(unknownCollateralStr) { + t.Errorf("received '%v' expected '%v'", UnknownMode.Upper(), strings.ToUpper(unknownCollateralStr)) + } + if SingleMode.Upper() != strings.ToUpper(singleCollateralStr) { + t.Errorf("received '%v' expected '%v'", SingleMode.Upper(), strings.ToUpper(singleCollateralStr)) + } + if MultiMode.Upper() != strings.ToUpper(multiCollateralStr) { + t.Errorf("received '%v' expected '%v'", MultiMode.Upper(), strings.ToUpper(multiCollateralStr)) + } + if PortfolioMode.Upper() != strings.ToUpper(portfolioCollateralStr) { + t.Errorf("received '%v' expected '%v'", PortfolioMode.Upper(), strings.ToUpper(portfolioCollateralStr)) + } + if UnsetMode.Upper() != strings.ToUpper(unsetCollateralStr) { + t.Errorf("received '%v' expected '%v'", UnsetMode.Upper(), strings.ToUpper(unsetCollateralStr)) + } +} + +func TestIsValidCollateralTypeString(t *testing.T) { + t.Parallel() + if IsValidCollateralModeString("lol") { + t.Fatal("expected 'false', received 'true'") + } + if !IsValidCollateralModeString("single") { + t.Fatal("expected 'true', received 'false'") + } + if !IsValidCollateralModeString("multi") { + t.Fatal("expected 'true', received 'false'") + } + if !IsValidCollateralModeString("portfolio") { + t.Fatal("expected 'true', received 'false'") + } + if !IsValidCollateralModeString("unset") { + t.Fatal("expected 'true', received 'false'") + } + if IsValidCollateralModeString("") { + t.Fatal("expected 'false', received 'true'") + } + if IsValidCollateralModeString("unknown") { + t.Fatal("expected 'false', received 'true'") + } +} + +func TestStringToCollateralType(t *testing.T) { + t.Parallel() + resp, err := StringToMode("lol") + if !errors.Is(err, ErrInvalidCollateralMode) { + t.Error(err) + } + if resp != UnknownMode { + t.Errorf("received '%v' expected '%v'", resp, UnknownMode) + } + + resp, err = StringToMode("") + if err != nil { + t.Error(err) + } + if resp != UnsetMode { + t.Errorf("received '%v' expected '%v'", resp, UnsetMode) + } + + resp, err = StringToMode("single") + if err != nil { + t.Error(err) + } + if resp != SingleMode { + t.Errorf("received '%v' expected '%v'", resp, SingleMode) + } + + resp, err = StringToMode("multi") + if err != nil { + t.Error(err) + } + if resp != MultiMode { + t.Errorf("received '%v' expected '%v'", resp, MultiMode) + } + + resp, err = StringToMode("portfolio") + if err != nil { + t.Error(err) + } + if resp != PortfolioMode { + t.Errorf("received '%v' expected '%v'", resp, PortfolioMode) + } +} diff --git a/exchanges/collateral/collateral_types.go b/exchanges/collateral/collateral_types.go new file mode 100644 index 00000000000..a0229d46a93 --- /dev/null +++ b/exchanges/collateral/collateral_types.go @@ -0,0 +1,85 @@ +package collateral + +import ( + "errors" + + "github.com/shopspring/decimal" + "github.com/thrasher-corp/gocryptotrader/currency" +) + +// Mode defines the different collateral types supported by exchanges +// For example, FTX had a global collateral pool +// Binance has either singular position collateral calculation +// or cross aka asset level collateral calculation +type Mode uint8 + +const ( + // UnsetMode is the default value + UnsetMode Mode = 0 + // SingleMode has allocated collateral per position + SingleMode Mode = 1 << (iota - 1) + // MultiMode has collateral allocated across the whole asset + MultiMode + // PortfolioMode has collateral allocated across account + PortfolioMode + // UnknownMode has collateral allocated in an unknown manner at present, but is not unset + UnknownMode +) + +const ( + unsetCollateralStr = "unset" + singleCollateralStr = "single" + multiCollateralStr = "multi" + portfolioCollateralStr = "portfolio" + unknownCollateralStr = "unknown" +) + +// ErrInvalidCollateralMode is returned when converting invalid string to collateral mode +var ErrInvalidCollateralMode = errors.New("invalid collateral mode") + +var supportedCollateralModes = SingleMode | MultiMode | PortfolioMode + +// ByPosition shows how much collateral is used +// from positions +type ByPosition struct { + PositionCurrency currency.Pair + Size decimal.Decimal + OpenOrderSize decimal.Decimal + PositionSize decimal.Decimal + MarkPrice decimal.Decimal + RequiredMargin decimal.Decimal + CollateralUsed decimal.Decimal +} + +// ByCurrency individual collateral contribution +// along with what the potentially scaled collateral +// currency it is represented as +// eg in Bybit ScaledCurrency is USDC +type ByCurrency struct { + Currency currency.Code + SkipContribution bool + TotalFunds decimal.Decimal + AvailableForUseAsCollateral decimal.Decimal + CollateralContribution decimal.Decimal + AdditionalCollateralUsed decimal.Decimal + FairMarketValue decimal.Decimal + Weighting decimal.Decimal + ScaledCurrency currency.Code + UnrealisedPNL decimal.Decimal + ScaledUsed decimal.Decimal + ScaledUsedBreakdown *UsedBreakdown + Error error +} + +// UsedBreakdown provides a detailed +// breakdown of where collateral is currently being allocated +type UsedBreakdown struct { + LockedInStakes decimal.Decimal + LockedInNFTBids decimal.Decimal + LockedInFeeVoucher decimal.Decimal + LockedInSpotMarginFundingOffers decimal.Decimal + LockedInSpotOrders decimal.Decimal + LockedAsCollateral decimal.Decimal + UsedInPositions decimal.Decimal + UsedInSpotMarginBorrows decimal.Decimal +} diff --git a/exchanges/exchange.go b/exchanges/exchange.go index 3f0d881bedc..fcafff35868 100644 --- a/exchanges/exchange.go +++ b/exchanges/exchange.go @@ -16,6 +16,7 @@ import ( "github.com/thrasher-corp/gocryptotrader/currency" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/currencystate" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" @@ -1458,81 +1459,17 @@ func (b *Base) GetAvailableTransferChains(_ context.Context, _ currency.Code) ([ return nil, common.ErrFunctionNotSupported } -// CalculatePNL is an overridable function to allow PNL to be calculated on an -// open position -// It will also determine whether the position is considered to be liquidated -// For live trading, an overriding function may wish to confirm the liquidation by -// requesting the status of the asset -func (b *Base) CalculatePNL(context.Context, *order.PNLCalculatorRequest) (*order.PNLResult, error) { - return nil, common.ErrNotYetImplemented -} - -// ScaleCollateral is an overridable function to determine how much -// collateral is usable in futures positions -func (b *Base) ScaleCollateral(context.Context, *order.CollateralCalculator) (*order.CollateralByCurrency, error) { - return nil, common.ErrNotYetImplemented -} - -// CalculateTotalCollateral takes in n collateral calculators to determine an overall -// standing in a singular currency -func (b *Base) CalculateTotalCollateral(_ context.Context, _ *order.TotalCollateralCalculator) (*order.TotalCollateralResponse, error) { - return nil, common.ErrNotYetImplemented -} - -// GetCollateralCurrencyForContract returns the collateral currency for an asset and contract pair -func (b *Base) GetCollateralCurrencyForContract(_ asset.Item, _ currency.Pair) (currency.Code, asset.Item, error) { - return currency.Code{}, asset.Empty, common.ErrNotYetImplemented -} - -// GetCurrencyForRealisedPNL returns where to put realised PNL -// example 1: Bybit universal margin PNL is paid out in USD to your spot wallet -// example 2: Binance coin margined futures pays returns using the same currency eg BTC -func (b *Base) GetCurrencyForRealisedPNL(_ asset.Item, _ currency.Pair) (currency.Code, asset.Item, error) { - return currency.Code{}, asset.Empty, common.ErrNotYetImplemented -} - // HasAssetTypeAccountSegregation returns if the accounts are divided into asset // types instead of just being denoted as spot holdings. func (b *Base) HasAssetTypeAccountSegregation() bool { return b.Features.Supports.RESTCapabilities.HasAssetTypeAccountSegregation } -// GetMarginRatesHistory returns the margin rate history for the supplied currency -func (b *Base) GetMarginRatesHistory(context.Context, *margin.RateHistoryRequest) (*margin.RateHistoryResponse, error) { - return nil, common.ErrNotYetImplemented -} - // GetPositionSummary returns stats for a future position func (b *Base) GetPositionSummary(context.Context, *order.PositionSummaryRequest) (*order.PositionSummary, error) { return nil, common.ErrNotYetImplemented } -// GetFundingPaymentDetails returns funding payment details for a future for a specific time period -func (b *Base) GetFundingPaymentDetails(context.Context, *fundingrate.RatesRequest) (*fundingrate.Rates, error) { - return nil, common.ErrNotYetImplemented -} - -// GetFuturesPositions returns futures positions for all currencies -func (b *Base) GetFuturesPositions(context.Context, *order.PositionsRequest) ([]order.PositionDetails, error) { - return nil, common.ErrNotYetImplemented -} - -// GetLatestFundingRate returns the latest funding rate based on request data -func (b *Base) GetLatestFundingRate(context.Context, *fundingrate.LatestRateRequest) (*fundingrate.LatestRateResponse, error) { - return nil, common.ErrNotYetImplemented -} - -// GetFundingRates returns funding rates based on request data -func (b *Base) GetFundingRates(context.Context, *fundingrate.RatesRequest) (*fundingrate.Rates, error) { - return nil, common.ErrNotYetImplemented -} - -// IsPerpetualFutureCurrency ensures a given asset and currency is a perpetual future -// differs by exchange -func (b *Base) IsPerpetualFutureCurrency(asset.Item, currency.Pair) (bool, error) { - return false, common.ErrNotYetImplemented -} - // GetKlineRequest returns a helper for the fetching of candle/kline data for // a single request within a pre-determined time window. func (b *Base) GetKlineRequest(pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time, fixedAPICandleLength bool) (*kline.Request, error) { @@ -1688,3 +1625,109 @@ func (b *Base) GetStandardConfig() (*config.Exchange, error) { return exchCfg, nil } + +// Futures section + +// CalculatePNL is an overridable function to allow PNL to be calculated on an +// open position +// It will also determine whether the position is considered to be liquidated +// For live trading, an overriding function may wish to confirm the liquidation by +// requesting the status of the asset +func (b *Base) CalculatePNL(context.Context, *order.PNLCalculatorRequest) (*order.PNLResult, error) { + return nil, common.ErrNotYetImplemented +} + +// ScaleCollateral is an overridable function to determine how much +// collateral is usable in futures positions +func (b *Base) ScaleCollateral(context.Context, *order.CollateralCalculator) (*collateral.ByCurrency, error) { + return nil, common.ErrNotYetImplemented +} + +// CalculateTotalCollateral takes in n collateral calculators to determine an overall +// standing in a singular currency +func (b *Base) CalculateTotalCollateral(_ context.Context, _ *order.TotalCollateralCalculator) (*order.TotalCollateralResponse, error) { + return nil, common.ErrNotYetImplemented +} + +// GetCollateralCurrencyForContract returns the collateral currency for an asset and contract pair +func (b *Base) GetCollateralCurrencyForContract(_ asset.Item, _ currency.Pair) (currency.Code, asset.Item, error) { + return currency.Code{}, asset.Empty, common.ErrNotYetImplemented +} + +// GetCurrencyForRealisedPNL returns where to put realised PNL +// example 1: Bybit universal margin PNL is paid out in USD to your spot wallet +// example 2: Binance coin margined futures pays returns using the same currency eg BTC +func (b *Base) GetCurrencyForRealisedPNL(_ asset.Item, _ currency.Pair) (currency.Code, asset.Item, error) { + return currency.Code{}, asset.Empty, common.ErrNotYetImplemented +} + +// GetMarginRatesHistory returns the margin rate history for the supplied currency +func (b *Base) GetMarginRatesHistory(context.Context, *margin.RateHistoryRequest) (*margin.RateHistoryResponse, error) { + return nil, common.ErrNotYetImplemented +} + +// GetFuturesPositionSummary returns stats for a future position +func (b *Base) GetFuturesPositionSummary(context.Context, *order.PositionSummaryRequest) (*order.PositionSummary, error) { + return nil, common.ErrNotYetImplemented +} + +// GetFundingPaymentDetails returns funding payment details for a future for a specific time period +func (b *Base) GetFundingPaymentDetails(context.Context, *fundingrate.RatesRequest) (*fundingrate.Rates, error) { + return nil, common.ErrNotYetImplemented +} + +// GetFuturesPositions returns futures positions for all currencies +func (b *Base) GetFuturesPositions(context.Context, *order.PositionsRequest) ([]order.PositionDetails, error) { + return nil, common.ErrNotYetImplemented +} + +// GetFuturesPositionOrders returns futures positions orders +func (b *Base) GetFuturesPositionOrders(context.Context, *order.PositionsRequest) ([]order.PositionResponse, error) { + return nil, common.ErrNotYetImplemented +} + +// GetLatestFundingRate returns the latest funding rate based on request data +func (b *Base) GetLatestFundingRate(context.Context, *fundingrate.LatestRateRequest) (*fundingrate.LatestRateResponse, error) { + return nil, common.ErrNotYetImplemented +} + +// GetFundingRates returns funding rates based on request data +func (b *Base) GetFundingRates(context.Context, *fundingrate.RatesRequest) (*fundingrate.Rates, error) { + return nil, common.ErrNotYetImplemented +} + +// IsPerpetualFutureCurrency ensures a given asset and currency is a perpetual future +// differs by exchange +func (b *Base) IsPerpetualFutureCurrency(asset.Item, currency.Pair) (bool, error) { + return false, common.ErrNotYetImplemented +} + +// SetCollateralMode sets the account's collateral mode for the asset type +func (b *Base) SetCollateralMode(_ context.Context, _ asset.Item, _ collateral.Mode) error { + return common.ErrNotYetImplemented +} + +// GetCollateralMode returns the account's collateral mode for the asset type +func (b *Base) GetCollateralMode(_ context.Context, _ asset.Item) (collateral.Mode, error) { + return 0, common.ErrNotYetImplemented +} + +// SetMarginType sets the account's margin type for the asset type +func (b *Base) SetMarginType(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type) error { + return common.ErrNotYetImplemented +} + +// ChangePositionMargin changes the margin type for a position +func (b *Base) ChangePositionMargin(_ context.Context, _ *margin.PositionChangeRequest) (*margin.PositionChangeResponse, error) { + return nil, common.ErrNotYetImplemented +} + +// SetLeverage sets the account's initial leverage for the asset type and pair +func (b *Base) SetLeverage(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type, _ float64, _ order.Side) error { + return common.ErrNotYetImplemented +} + +// GetLeverage gets the account's initial leverage for the asset type and pair +func (b *Base) GetLeverage(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type, _ order.Side) (float64, error) { + return -1, common.ErrNotYetImplemented +} diff --git a/exchanges/exchange_test.go b/exchanges/exchange_test.go index 8d910f84ace..fed98ae7e4a 100644 --- a/exchanges/exchange_test.go +++ b/exchanges/exchange_test.go @@ -12,7 +12,10 @@ import ( "github.com/thrasher-corp/gocryptotrader/config" "github.com/thrasher-corp/gocryptotrader/currency" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" + "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/exchanges/protocol" "github.com/thrasher-corp/gocryptotrader/exchanges/request" "github.com/thrasher-corp/gocryptotrader/exchanges/stream" @@ -2505,7 +2508,7 @@ func TestGetMarginRateHistory(t *testing.T) { func TestGetPositionSummary(t *testing.T) { t.Parallel() var b Base - if _, err := b.GetPositionSummary(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) { + if _, err := b.GetFuturesPositionSummary(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) { t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented) } } @@ -2513,7 +2516,7 @@ func TestGetPositionSummary(t *testing.T) { func TestGetFuturesPositions(t *testing.T) { t.Parallel() var b Base - if _, err := b.GetFuturesPositions(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) { + if _, err := b.GetFuturesPositionOrders(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) { t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented) } } @@ -2954,6 +2957,60 @@ func TestGetKlineExtendedRequest(t *testing.T) { } } +func TestSetCollateralMode(t *testing.T) { + t.Parallel() + b := Base{} + err := b.SetCollateralMode(context.Background(), asset.Spot, collateral.SingleMode) + if !errors.Is(err, common.ErrNotYetImplemented) { + t.Error(err) + } +} + +func TestGetCollateralMode(t *testing.T) { + t.Parallel() + b := Base{} + _, err := b.GetCollateralMode(context.Background(), asset.Spot) + if !errors.Is(err, common.ErrNotYetImplemented) { + t.Error(err) + } +} + +func TestSetMarginType(t *testing.T) { + t.Parallel() + b := Base{} + err := b.SetMarginType(context.Background(), asset.Spot, currency.NewBTCUSD(), margin.Multi) + if !errors.Is(err, common.ErrNotYetImplemented) { + t.Error(err) + } +} + +func TestChangePositionMargin(t *testing.T) { + t.Parallel() + b := Base{} + _, err := b.ChangePositionMargin(context.Background(), nil) + if !errors.Is(err, common.ErrNotYetImplemented) { + t.Error(err) + } +} + +func TestSetLeverage(t *testing.T) { + t.Parallel() + b := Base{} + err := b.SetLeverage(context.Background(), asset.Spot, currency.NewBTCUSD(), margin.Multi, 1, order.UnknownSide) + if !errors.Is(err, common.ErrNotYetImplemented) { + t.Error(err) + } +} + +func TestGetLeverage(t *testing.T) { + t.Parallel() + b := Base{} + _, err := b.GetLeverage(context.Background(), asset.Spot, currency.NewBTCUSD(), margin.Multi, order.UnknownSide) + if !errors.Is(err, common.ErrNotYetImplemented) { + t.Error(err) + } +} + func TestEnsureOnePairEnabled(t *testing.T) { t.Parallel() b := Base{Name: "test"} diff --git a/exchanges/exchange_types.go b/exchanges/exchange_types.go index 25ac66b6b8c..651a2bb95e4 100644 --- a/exchanges/exchange_types.go +++ b/exchanges/exchange_types.go @@ -178,13 +178,20 @@ type FeaturesSupported struct { // FuturesCapabilities stores the exchange's futures capabilities type FuturesCapabilities struct { FundingRates bool - MaximumFundingRateHistory time.Duration - FundingRateFrequency time.Duration Positions bool OrderManagerPositionTracking bool Collateral bool CollateralMode bool Leverage bool + MaximumFundingRateHistory time.Duration + FundingRateFrequency time.Duration +} + +// MarginCapabilities stores the exchange's margin capabilities +type MarginCapabilities struct { + SetMarginType bool + ChangePositionMargin bool + GetMarginRateHistory bool } // Endpoints stores running url endpoints for exchanges diff --git a/exchanges/interfaces.go b/exchanges/interfaces.go index 21153313463..ba142c0b979 100644 --- a/exchanges/interfaces.go +++ b/exchanges/interfaces.go @@ -9,6 +9,7 @@ import ( "github.com/thrasher-corp/gocryptotrader/currency" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/currencystate" "github.com/thrasher-corp/gocryptotrader/exchanges/deposit" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" @@ -31,6 +32,8 @@ type IBotExchange interface { Shutdown() error GetName() string SetEnabled(bool) + GetEnabledFeatures() FeaturesEnabled + GetSupportedFeatures() FeaturesSupported FetchTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) UpdateTickers(ctx context.Context, a asset.Item) error @@ -92,6 +95,7 @@ type IBotExchange interface { OrderManagement CurrencyStateManagement FuturesManagement + MarginManagement } // OrderManagement defines functionality for order management @@ -141,14 +145,26 @@ type FunctionalityChecker interface { // FuturesManagement manages futures orders, pnl and collateral calculations type FuturesManagement interface { - GetPositionSummary(context.Context, *order.PositionSummaryRequest) (*order.PositionSummary, error) - ScaleCollateral(ctx context.Context, calculator *order.CollateralCalculator) (*order.CollateralByCurrency, error) + ScaleCollateral(ctx context.Context, calculator *order.CollateralCalculator) (*collateral.ByCurrency, error) CalculateTotalCollateral(context.Context, *order.TotalCollateralCalculator) (*order.TotalCollateralResponse, error) GetFuturesPositions(context.Context, *order.PositionsRequest) ([]order.PositionDetails, error) GetFundingRates(context.Context, *fundingrate.RatesRequest) (*fundingrate.Rates, error) GetLatestFundingRate(context.Context, *fundingrate.LatestRateRequest) (*fundingrate.LatestRateResponse, error) IsPerpetualFutureCurrency(asset.Item, currency.Pair) (bool, error) GetCollateralCurrencyForContract(asset.Item, currency.Pair) (currency.Code, asset.Item, error) - GetMarginRatesHistory(context.Context, *margin.RateHistoryRequest) (*margin.RateHistoryResponse, error) order.PNLCalculation + + GetFuturesPositionSummary(context.Context, *order.PositionSummaryRequest) (*order.PositionSummary, error) + GetFuturesPositionOrders(context.Context, *order.PositionsRequest) ([]order.PositionResponse, error) + SetCollateralMode(ctx context.Context, item asset.Item, mode collateral.Mode) error + GetCollateralMode(ctx context.Context, item asset.Item) (collateral.Mode, error) + SetLeverage(ctx context.Context, item asset.Item, pair currency.Pair, marginType margin.Type, amount float64, orderSide order.Side) error + GetLeverage(ctx context.Context, item asset.Item, pair currency.Pair, marginType margin.Type, orderSide order.Side) (float64, error) +} + +// MarginManagement manages margin positions and rates +type MarginManagement interface { + SetMarginType(ctx context.Context, item asset.Item, pair currency.Pair, tp margin.Type) error + ChangePositionMargin(ctx context.Context, change *margin.PositionChangeRequest) (*margin.PositionChangeResponse, error) + GetMarginRatesHistory(context.Context, *margin.RateHistoryRequest) (*margin.RateHistoryResponse, error) } diff --git a/exchanges/margin/margin.go b/exchanges/margin/margin.go new file mode 100644 index 00000000000..bba28157506 --- /dev/null +++ b/exchanges/margin/margin.go @@ -0,0 +1,67 @@ +package margin + +import ( + "encoding/json" + "fmt" + "strings" +) + +// Valid returns whether the margin type is valid +func (t Type) Valid() bool { + return t != Unset && supported&t == t +} + +// UnmarshalJSON converts json into margin type +func (t *Type) UnmarshalJSON(d []byte) error { + var marginType string + err := json.Unmarshal(d, &marginType) + if err != nil { + return err + } + *t, err = StringToMarginType(marginType) + return err +} + +// String returns the string representation of the margin type in lowercase +// the absence of a lower func should hopefully highlight that String is lower +func (t Type) String() string { + switch t { + case Unset: + return unsetStr + case Isolated: + return isolatedStr + case Multi: + return multiStr + case Unknown: + return unknownStr + } + return "" +} + +// Upper returns the upper case string representation of the margin type +func (t Type) Upper() string { + return strings.ToUpper(t.String()) +} + +// IsValidString checks to see if the supplied string is a valid margin type +func IsValidString(m string) bool { + switch strings.ToLower(m) { + case isolatedStr, multiStr, unsetStr, crossedStr, crossStr: + return true + } + return false +} + +// StringToMarginType converts a string to a margin type +// doesn't error, just returns unknown if the string is not recognised +func StringToMarginType(m string) (Type, error) { + switch strings.ToLower(m) { + case isolatedStr: + return Isolated, nil + case multiStr, crossedStr, crossStr: + return Multi, nil + case "": + return Unset, nil + } + return Unknown, fmt.Errorf("%w %v", ErrInvalidMarginType, m) +} diff --git a/exchanges/margin/margin_test.go b/exchanges/margin/margin_test.go new file mode 100644 index 00000000000..2c14b6ffeaa --- /dev/null +++ b/exchanges/margin/margin_test.go @@ -0,0 +1,162 @@ +package margin + +import ( + "encoding/json" + "errors" + "strings" + "testing" +) + +func TestValid(t *testing.T) { + t.Parallel() + if !Isolated.Valid() { + t.Fatal("expected 'true', received 'false'") + } + if !Multi.Valid() { + t.Fatal("expected 'true', received 'false'") + } + if Unset.Valid() { + t.Fatal("expected 'false', received 'true'") + } + if Unknown.Valid() { + t.Fatal("expected 'false', received 'true'") + } + if Type(137).Valid() { + t.Fatal("expected 'false', received 'true'") + } +} + +func TestUnmarshalJSON(t *testing.T) { + t.Parallel() + type martian struct { + M Type `json:"margin"` + } + + var alien martian + jason := []byte(`{"margin":"isolated"}`) + err := json.Unmarshal(jason, &alien) + if err != nil { + t.Error(err) + } + if alien.M != Isolated { + t.Errorf("received '%v' expected 'isolated'", alien.M) + } + + jason = []byte(`{"margin":"cross"}`) + err = json.Unmarshal(jason, &alien) + if err != nil { + t.Error(err) + } + if alien.M != Multi { + t.Errorf("received '%v' expected 'Multi'", alien.M) + } + + jason = []byte(`{"margin":"hello moto"}`) + err = json.Unmarshal(jason, &alien) + if !errors.Is(err, ErrInvalidMarginType) { + t.Error(err) + } + if alien.M != Unknown { + t.Errorf("received '%v' expected 'isolated'", alien.M) + } +} + +func TestString(t *testing.T) { + t.Parallel() + if Unknown.String() != unknownStr { + t.Errorf("received '%v' expected '%v'", Unknown.String(), unknownStr) + } + if Isolated.String() != isolatedStr { + t.Errorf("received '%v' expected '%v'", Isolated.String(), isolatedStr) + } + if Multi.String() != multiStr { + t.Errorf("received '%v' expected '%v'", Multi.String(), multiStr) + } + if Unset.String() != unsetStr { + t.Errorf("received '%v' expected '%v'", Unset.String(), unsetStr) + } +} + +func TestUpper(t *testing.T) { + t.Parallel() + if Unknown.Upper() != strings.ToUpper(unknownStr) { + t.Errorf("received '%v' expected '%v'", Unknown.String(), strings.ToUpper(unknownStr)) + } + if Isolated.Upper() != strings.ToUpper(isolatedStr) { + t.Errorf("received '%v' expected '%v'", Isolated.String(), strings.ToUpper(isolatedStr)) + } + if Multi.Upper() != strings.ToUpper(multiStr) { + t.Errorf("received '%v' expected '%v'", Multi.String(), strings.ToUpper(multiStr)) + } + if Unset.Upper() != strings.ToUpper(unsetStr) { + t.Errorf("received '%v' expected '%v'", Unset.String(), strings.ToUpper(unsetStr)) + } +} + +func TestIsValidString(t *testing.T) { + t.Parallel() + if IsValidString("lol") { + t.Fatal("expected 'false', received 'true'") + } + if !IsValidString("isolated") { + t.Fatal("expected 'true', received 'false'") + } + if !IsValidString("cross") { + t.Fatal("expected 'true', received 'false'") + } + if !IsValidString("multi") { + t.Fatal("expected 'true', received 'false'") + } + if !IsValidString("unset") { + t.Fatal("expected 'true', received 'false'") + } + if IsValidString("") { + t.Fatal("expected 'false', received 'true'") + } + if IsValidString("unknown") { + t.Fatal("expected 'false', received 'true'") + } +} + +func TestStringToMarginType(t *testing.T) { + t.Parallel() + resp, err := StringToMarginType("lol") + if !errors.Is(err, ErrInvalidMarginType) { + t.Error(err) + } + if resp != Unknown { + t.Errorf("received '%v' expected '%v'", resp, Unknown) + } + + resp, err = StringToMarginType("") + if err != nil { + t.Error(err) + } + if resp != Unset { + t.Errorf("received '%v' expected '%v'", resp, Unset) + } + + resp, err = StringToMarginType("cross") + if err != nil { + t.Error(err) + } + if resp != Multi { + t.Errorf("received '%v' expected '%v'", resp, Multi) + } + + resp, err = StringToMarginType("multi") + if err != nil { + t.Error(err) + } + if resp != Multi { + t.Errorf("received '%v' expected '%v'", resp, Multi) + } + + resp, err = StringToMarginType("isolated") + if err != nil { + t.Error(err) + } + if resp != Isolated { + t.Errorf("received '%v' expected '%v'", resp, Isolated) + } +} diff --git a/exchanges/margin/margin_types.go b/exchanges/margin/margin_types.go index d069b9d899f..1d566b11022 100644 --- a/exchanges/margin/margin_types.go +++ b/exchanges/margin/margin_types.go @@ -1,6 +1,7 @@ package margin import ( + "errors" "time" "github.com/shopspring/decimal" @@ -8,6 +9,17 @@ import ( "github.com/thrasher-corp/gocryptotrader/exchanges/asset" ) +var ( + // ErrInvalidMarginType returned when the margin type is invalid + ErrInvalidMarginType = errors.New("invalid margin type") + // ErrMarginTypeUnsupported returned when the margin type is unsupported + ErrMarginTypeUnsupported = errors.New("unsupported margin type") + // ErrNewAllocatedMarginRequired returned when the new allocated margin is missing and is required + ErrNewAllocatedMarginRequired = errors.New("new allocated margin required") + // ErrOriginalPositionMarginRequired is returned when original position margin is empty and is required + ErrOriginalPositionMarginRequired = errors.New("original allocated margin required") +) + // RateHistoryRequest is used to request a funding rate type RateHistoryRequest struct { Exchange string @@ -32,6 +44,55 @@ type RateHistoryRequest struct { Rates []Rate } +// PositionChangeRequest used for wrapper functions to change margin fields for a position +type PositionChangeRequest struct { + // Required fields + Exchange string + Pair currency.Pair + Asset asset.Item + // Optional fields depending on desired outcome/exchange requirements + MarginType Type + OriginalAllocatedMargin float64 + NewAllocatedMargin float64 + MarginSide string +} + +// PositionChangeResponse holds response data for margin change requests +type PositionChangeResponse struct { + Exchange string + Pair currency.Pair + Asset asset.Item + AllocatedMargin float64 + MarginType Type +} + +// Type defines the different margin types supported by exchanges +type Type uint8 + +// Margin types +const ( + // Unset is the default value + Unset = Type(0) + // Isolated means a margin trade is isolated from other margin trades + Isolated Type = 1 << (iota - 1) + // Multi means a margin trade is not isolated from other margin trades + // it can sometimes be referred to as "cross" + Multi + // Unknown is an unknown margin type but is not unset + Unknown +) + +var supported = Isolated | Multi + +const ( + unsetStr = "unset" + isolatedStr = "isolated" + multiStr = "multi" + crossedStr = "crossed" + crossStr = "cross" + unknownStr = "unknown" +) + // RateHistoryResponse has the funding rate details type RateHistoryResponse struct { Rates []Rate diff --git a/exchanges/okx/okx.go b/exchanges/okx/okx.go index b4a14324420..e0232bf8a6c 100644 --- a/exchanges/okx/okx.go +++ b/exchanges/okx/okx.go @@ -284,6 +284,7 @@ var ( errMissingValidGreeksType = errors.New("missing valid greeks type") errMissingIsolatedMarginTradingSetting = errors.New("missing isolated margin trading setting, isolated margin trading settings automatic:Auto transfers autonomy:Manual transfers") errInvalidOrderSide = errors.New("invalid order side") + errOrderSideRequired = errors.New("order side required") errInvalidCounterParties = errors.New("missing counter parties") errInvalidLegs = errors.New("no legs are provided") errMissingRFQIDANDClientSuppliedRFQID = errors.New("missing rfq id or client supplied rfq id") @@ -338,6 +339,7 @@ var ( errInvalidProtocolType = errors.New("invalid protocol type, only 'staking' and 'defi' allowed") errExceedLimit = errors.New("limit exceeded") errOnlyThreeMonthsSupported = errors.New("only three months of trade data retrieval supported") + errOnlyOneResponseExpected = errors.New("one response item expected") errNoInstrumentFound = errors.New("no instrument found") ) @@ -1859,9 +1861,9 @@ func (ok *Okx) GetConvertHistory(ctx context.Context, before, after time.Time, l /********************************** Account endpoints ***************************************************/ -// GetNonZeroBalances retrieves a list of assets (with non-zero balance), remaining balance, and available amount in the trading account. +// AccountBalance retrieves a list of assets (with non-zero balance), remaining balance, and available amount in the trading account. // Interest-free quota and discount rates are public data and not displayed on the account interface. -func (ok *Okx) GetNonZeroBalances(ctx context.Context, currency string) ([]Account, error) { +func (ok *Okx) AccountBalance(ctx context.Context, currency string) ([]Account, error) { var resp []Account params := url.Values{} if currency != "" { @@ -2010,26 +2012,12 @@ func (ok *Okx) SetPositionMode(ctx context.Context, positionMode string) (string return "", errNoValidResponseFromServer } -// SetLeverage sets a leverage setting for instrument id. -func (ok *Okx) SetLeverage(ctx context.Context, arg SetLeverageInput) (*SetLeverageResponse, error) { +// SetLeverageRate sets a leverage setting for instrument id. +func (ok *Okx) SetLeverageRate(ctx context.Context, arg SetLeverageInput) (*SetLeverageResponse, error) { if arg.InstrumentID == "" && arg.Currency == "" { return nil, errors.New("either instrument id or currency is required") } - if arg.Leverage < 0 { - return nil, errors.New("missing leverage") - } - if arg.InstrumentID == "" && arg.MarginMode == TradeModeIsolated { - return nil, errors.New("only can be cross if ccy is passed") - } - if arg.MarginMode != TradeModeCross && arg.MarginMode != TradeModeIsolated { - return nil, errors.New("only applicable to \"isolated\" margin mode of FUTURES/SWAP allowed") - } arg.PositionSide = strings.ToLower(arg.PositionSide) - if arg.PositionSide != positionSideLong && - arg.PositionSide != positionSideShort && - arg.MarginMode == "isolated" { - return nil, errors.New("\"long\" \"short\" Only applicable to isolated margin mode of FUTURES/SWAP") - } var resp []SetLeverageResponse err := ok.SendHTTPRequest(ctx, exchange.RestSpot, setLeverageEPL, http.MethodPost, accountSetLeverage, &arg, &resp, true) if err != nil { @@ -2107,7 +2095,7 @@ func (ok *Okx) IncreaseDecreaseMargin(ctx context.Context, arg IncreaseDecreaseM return nil, errors.New("missing valid amount") } var resp []IncreaseDecreaseMargin - err := ok.SendHTTPRequest(ctx, exchange.RestSpot, increaseOrDecreaseMarginEPL, http.MethodGet, accountPositionMarginBalance, &arg, &resp, true) + err := ok.SendHTTPRequest(ctx, exchange.RestSpot, increaseOrDecreaseMarginEPL, http.MethodPost, accountPositionMarginBalance, &arg, &resp, true) if err != nil { return nil, err } @@ -2117,8 +2105,8 @@ func (ok *Okx) IncreaseDecreaseMargin(ctx context.Context, arg IncreaseDecreaseM return nil, errNoValidResponseFromServer } -// GetLeverage retrieves leverage data for different instrument id or margin mode. -func (ok *Okx) GetLeverage(ctx context.Context, instrumentID, marginMode string) ([]LeverageResponse, error) { +// GetLeverageRate retrieves leverage data for different instrument id or margin mode. +func (ok *Okx) GetLeverageRate(ctx context.Context, instrumentID, marginMode string) ([]LeverageResponse, error) { params := url.Values{} if instrumentID != "" { params.Set("instId", instrumentID) @@ -3461,10 +3449,8 @@ func (ok *Okx) GetFundingRateHistory(ctx context.Context, instrumentID string, b if !after.IsZero() { params.Set("after", strconv.FormatInt(after.UnixMilli(), 10)) } - if limit > 0 && limit <= 100 { + if limit > 0 { params.Set("limit", strconv.FormatInt(limit, 10)) - } else if limit > 100 { - return nil, errLimitValueExceedsMaxOf100 } var resp []FundingRateResponse return resp, ok.SendHTTPRequest(ctx, exchange.RestSpot, getFundingRateHistoryEPL, http.MethodGet, common.EncodeURLValues(publicFundingRateHistory, params), nil, &resp, false) diff --git a/exchanges/okx/okx_test.go b/exchanges/okx/okx_test.go index 0ba65fe5bd6..4ac1095aae4 100644 --- a/exchanges/okx/okx_test.go +++ b/exchanges/okx/okx_test.go @@ -18,8 +18,10 @@ import ( "github.com/thrasher-corp/gocryptotrader/currency" exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/exchanges/orderbook" "github.com/thrasher-corp/gocryptotrader/exchanges/request" @@ -88,12 +90,12 @@ func contextGenerate() context.Context { func TestStart(t *testing.T) { t.Parallel() - err := ok.Start(context.Background(), nil) + err := ok.Start(contextGenerate(), nil) if !errors.Is(err, common.ErrNilPointer) { t.Fatalf("received: '%v' but expected: '%v'", err, common.ErrNilPointer) } var testWg sync.WaitGroup - err = ok.Start(context.Background(), &testWg) + err = ok.Start(contextGenerate(), &testWg) if err != nil { t.Fatal(err) } @@ -102,7 +104,7 @@ func TestStart(t *testing.T) { func TestGetTickers(t *testing.T) { t.Parallel() - _, err := ok.GetTickers(context.Background(), "OPTION", "", "SOL-USD") + _, err := ok.GetTickers(contextGenerate(), "OPTION", "", "SOL-USD") if err != nil { t.Error("Okx GetTickers() error", err) } @@ -110,7 +112,7 @@ func TestGetTickers(t *testing.T) { func TestGetIndexTicker(t *testing.T) { t.Parallel() - _, err := ok.GetIndexTickers(context.Background(), "USDT", "NEAR-USDT-SWAP") + _, err := ok.GetIndexTickers(contextGenerate(), "USDT", "NEAR-USDT-SWAP") if err != nil { t.Error("OKX GetIndexTicker() error", err) } @@ -118,14 +120,14 @@ func TestGetIndexTicker(t *testing.T) { func TestGetTicker(t *testing.T) { t.Parallel() - if _, err := ok.GetTicker(context.Background(), "NEAR-USDT-SWAP"); err != nil { + if _, err := ok.GetTicker(contextGenerate(), "NEAR-USDT-SWAP"); err != nil { t.Error("Okx GetTicker() error", err) } } func TestGetOrderBookDepth(t *testing.T) { t.Parallel() - _, err := ok.GetOrderBookDepth(context.Background(), "BTC-USDT", 400) + _, err := ok.GetOrderBookDepth(contextGenerate(), "BTC-USDT", 400) if err != nil { t.Error("OKX GetOrderBookDepth() error", err) } @@ -133,7 +135,7 @@ func TestGetOrderBookDepth(t *testing.T) { func TestGetCandlesticks(t *testing.T) { t.Parallel() - _, err := ok.GetCandlesticks(context.Background(), "BTC-USDT", kline.OneHour, time.Now().Add(-time.Hour*24*500), time.Now(), 500) + _, err := ok.GetCandlesticks(contextGenerate(), "BTC-USDT", kline.OneHour, time.Now().Add(-time.Minute*2), time.Now(), 2) if err != nil { t.Error("Okx GetCandlesticks() error", err) } @@ -141,7 +143,7 @@ func TestGetCandlesticks(t *testing.T) { func TestGetCandlesticksHistory(t *testing.T) { t.Parallel() - _, err := ok.GetCandlesticksHistory(context.Background(), "BTC-USDT", kline.OneHour, time.Unix(time.Now().Unix()-int64(time.Minute), 3), time.Now(), 3) + _, err := ok.GetCandlesticksHistory(contextGenerate(), "BTC-USDT", kline.OneHour, time.Unix(time.Now().Unix()-int64(time.Minute), 3), time.Now(), 3) if err != nil { t.Error("Okx GetCandlesticksHistory() error", err) } @@ -149,7 +151,7 @@ func TestGetCandlesticksHistory(t *testing.T) { func TestGetTrades(t *testing.T) { t.Parallel() - _, err := ok.GetTrades(context.Background(), "BTC-USDT", 3) + _, err := ok.GetTrades(contextGenerate(), "BTC-USDT", 3) if err != nil { t.Error("Okx GetTrades() error", err) } @@ -157,14 +159,14 @@ func TestGetTrades(t *testing.T) { func TestGetTradeHistory(t *testing.T) { t.Parallel() - if _, err := ok.GetTradesHistory(context.Background(), "BTC-USDT", "", "", 2); err != nil { + if _, err := ok.GetTradesHistory(contextGenerate(), "BTC-USDT", "", "", 2); err != nil { t.Error("Okx GetTradeHistory() error", err) } } func TestGet24HTotalVolume(t *testing.T) { t.Parallel() - _, err := ok.Get24HTotalVolume(context.Background()) + _, err := ok.Get24HTotalVolume(contextGenerate()) if err != nil { t.Error("Okx Get24HTotalVolume() error", err) } @@ -172,7 +174,7 @@ func TestGet24HTotalVolume(t *testing.T) { func TestGetOracle(t *testing.T) { t.Parallel() - _, err := ok.GetOracle(context.Background()) + _, err := ok.GetOracle(contextGenerate()) if err != nil { t.Error("Okx GetOracle() error", err) } @@ -180,7 +182,7 @@ func TestGetOracle(t *testing.T) { func TestGetExchangeRate(t *testing.T) { t.Parallel() - _, err := ok.GetExchangeRate(context.Background()) + _, err := ok.GetExchangeRate(contextGenerate()) if err != nil { t.Error("Okx GetExchangeRate() error", err) } @@ -188,7 +190,7 @@ func TestGetExchangeRate(t *testing.T) { func TestGetIndexComponents(t *testing.T) { t.Parallel() - _, err := ok.GetIndexComponents(context.Background(), "ETH-USDT") + _, err := ok.GetIndexComponents(contextGenerate(), "ETH-USDT") if err != nil { t.Error("Okx GetIndexComponents() error", err) } @@ -196,35 +198,35 @@ func TestGetIndexComponents(t *testing.T) { func TestGetBlockTickers(t *testing.T) { t.Parallel() - if _, err := ok.GetBlockTickers(context.Background(), "SWAP", ""); err != nil { + if _, err := ok.GetBlockTickers(contextGenerate(), "SWAP", ""); err != nil { t.Error("Okx GetBlockTickers() error", err) } } func TestGetBlockTicker(t *testing.T) { t.Parallel() - if _, err := ok.GetBlockTicker(context.Background(), "BTC-USDT"); err != nil { + if _, err := ok.GetBlockTicker(contextGenerate(), "BTC-USDT"); err != nil { t.Error("Okx GetBlockTicker() error", err) } } func TestGetBlockTrade(t *testing.T) { t.Parallel() - if _, err := ok.GetBlockTrades(context.Background(), "BTC-USDT"); err != nil { + if _, err := ok.GetBlockTrades(contextGenerate(), "BTC-USDT"); err != nil { t.Error("Okx GetBlockTrades() error", err) } } func TestGetInstrument(t *testing.T) { t.Parallel() - _, err := ok.GetInstruments(context.Background(), &InstrumentsFetchParams{ + _, err := ok.GetInstruments(contextGenerate(), &InstrumentsFetchParams{ InstrumentType: "OPTION", Underlying: "SOL-USD", }) if err != nil { t.Error("Okx GetInstruments() error", err) } - _, err = ok.GetInstruments(context.Background(), &InstrumentsFetchParams{ + _, err = ok.GetInstruments(contextGenerate(), &InstrumentsFetchParams{ InstrumentType: "OPTION", Underlying: "SOL-USD", }) @@ -235,7 +237,7 @@ func TestGetInstrument(t *testing.T) { func TestGetDeliveryHistory(t *testing.T) { t.Parallel() - _, err := ok.GetDeliveryHistory(context.Background(), "FUTURES", "BTC-USDT", time.Time{}, time.Time{}, 3) + _, err := ok.GetDeliveryHistory(contextGenerate(), "FUTURES", "BTC-USDT", time.Time{}, time.Time{}, 3) if err != nil { t.Error("okx GetDeliveryHistory() error", err) } @@ -243,7 +245,7 @@ func TestGetDeliveryHistory(t *testing.T) { func TestGetOpenInterest(t *testing.T) { t.Parallel() - if _, err := ok.GetOpenInterest(context.Background(), "FUTURES", "BTC-USDT", ""); err != nil { + if _, err := ok.GetOpenInterest(contextGenerate(), "FUTURES", "BTC-USDT", ""); err != nil { t.Error("Okx GetOpenInterest() error", err) } } @@ -257,39 +259,39 @@ func TestGetSingleFundingRate(t *testing.T) { func TestGetFundingRateHistory(t *testing.T) { t.Parallel() - if _, err := ok.GetFundingRateHistory(context.Background(), "BTC-USD-SWAP", time.Time{}, time.Time{}, 2); err != nil { + if _, err := ok.GetFundingRateHistory(contextGenerate(), "BTC-USD-SWAP", time.Time{}, time.Time{}, 2); err != nil { t.Error("Okx GetFundingRateHistory() error", err) } } func TestGetLimitPrice(t *testing.T) { t.Parallel() - if _, err := ok.GetLimitPrice(context.Background(), "BTC-USD-SWAP"); err != nil { + if _, err := ok.GetLimitPrice(contextGenerate(), "BTC-USD-SWAP"); err != nil { t.Error("okx GetLimitPrice() error", err) } } func TestGetOptionMarketData(t *testing.T) { t.Parallel() - if _, err := ok.GetOptionMarketData(context.Background(), "BTC-USD", time.Time{}); err != nil { + if _, err := ok.GetOptionMarketData(contextGenerate(), "BTC-USD", time.Time{}); err != nil { t.Error("Okx GetOptionMarketData() error", err) } } func TestGetEstimatedDeliveryPrice(t *testing.T) { t.Parallel() - r, err := ok.FetchTradablePairs(context.Background(), asset.Futures) + r, err := ok.FetchTradablePairs(contextGenerate(), asset.Futures) if err != nil { t.Fatal(err) } - if _, err := ok.GetEstimatedDeliveryPrice(context.Background(), r[0].String()); err != nil { + if _, err := ok.GetEstimatedDeliveryPrice(contextGenerate(), r[0].String()); err != nil { t.Error("Okx GetEstimatedDeliveryPrice() error", err) } } func TestGetDiscountRateAndInterestFreeQuota(t *testing.T) { t.Parallel() - _, err := ok.GetDiscountRateAndInterestFreeQuota(context.Background(), "", 0) + _, err := ok.GetDiscountRateAndInterestFreeQuota(contextGenerate(), "", 0) if err != nil { t.Error("Okx GetDiscountRateAndInterestFreeQuota() error", err) } @@ -297,18 +299,18 @@ func TestGetDiscountRateAndInterestFreeQuota(t *testing.T) { func TestGetSystemTime(t *testing.T) { t.Parallel() - if _, err := ok.GetSystemTime(context.Background()); err != nil { + if _, err := ok.GetSystemTime(contextGenerate()); err != nil { t.Error("Okx GetSystemTime() error", err) } } func TestGetLiquidationOrders(t *testing.T) { t.Parallel() - insts, err := ok.FetchTradablePairs(context.Background(), asset.Margin) + insts, err := ok.FetchTradablePairs(contextGenerate(), asset.Margin) if err != nil { t.Skip(err) } - if _, err := ok.GetLiquidationOrders(context.Background(), &LiquidationOrderRequestParams{ + if _, err := ok.GetLiquidationOrders(contextGenerate(), &LiquidationOrderRequestParams{ InstrumentType: okxInstTypeMargin, Underlying: insts[0].String(), Currency: currency.BTC, @@ -320,42 +322,42 @@ func TestGetLiquidationOrders(t *testing.T) { func TestGetMarkPrice(t *testing.T) { t.Parallel() - if _, err := ok.GetMarkPrice(context.Background(), "MARGIN", "", ""); err != nil { + if _, err := ok.GetMarkPrice(contextGenerate(), "MARGIN", "", ""); err != nil { t.Error("Okx GetMarkPrice() error", err) } } func TestGetPositionTiers(t *testing.T) { t.Parallel() - if _, err := ok.GetPositionTiers(context.Background(), "FUTURES", "cross", "BTC-USDT", "", ""); err != nil { + if _, err := ok.GetPositionTiers(contextGenerate(), "FUTURES", "cross", "BTC-USDT", "", ""); err != nil { t.Error("Okx GetPositionTiers() error", err) } } func TestGetInterestRateAndLoanQuota(t *testing.T) { t.Parallel() - if _, err := ok.GetInterestRateAndLoanQuota(context.Background()); err != nil { + if _, err := ok.GetInterestRateAndLoanQuota(contextGenerate()); err != nil { t.Error("Okx GetInterestRateAndLoanQuota() error", err) } } func TestGetInterestRateAndLoanQuotaForVIPLoans(t *testing.T) { t.Parallel() - if _, err := ok.GetInterestRateAndLoanQuotaForVIPLoans(context.Background()); err != nil { + if _, err := ok.GetInterestRateAndLoanQuotaForVIPLoans(contextGenerate()); err != nil { t.Error("Okx GetInterestRateAndLoanQuotaForVIPLoans() error", err) } } func TestGetPublicUnderlyings(t *testing.T) { t.Parallel() - if _, err := ok.GetPublicUnderlyings(context.Background(), "swap"); err != nil { + if _, err := ok.GetPublicUnderlyings(contextGenerate(), "swap"); err != nil { t.Error("Okx GetPublicUnderlyings() error", err) } } func TestGetInsuranceFundInformation(t *testing.T) { t.Parallel() - if _, err := ok.GetInsuranceFundInformation(context.Background(), &InsuranceFundInformationRequestParams{ + if _, err := ok.GetInsuranceFundInformation(contextGenerate(), &InsuranceFundInformationRequestParams{ InstrumentType: "FUTURES", Underlying: "BTC-USDT", Limit: 2, @@ -366,7 +368,7 @@ func TestGetInsuranceFundInformation(t *testing.T) { func TestCurrencyUnitConvert(t *testing.T) { t.Parallel() - if _, err := ok.CurrencyUnitConvert(context.Background(), "BTC-USD-SWAP", 1, 3500, 1, ""); err != nil { + if _, err := ok.CurrencyUnitConvert(contextGenerate(), "BTC-USD-SWAP", 1, 3500, 1, ""); err != nil { t.Error("Okx CurrencyUnitConvert() error", err) } } @@ -374,69 +376,69 @@ func TestCurrencyUnitConvert(t *testing.T) { // Trading related endpoints test functions. func TestGetSupportCoins(t *testing.T) { t.Parallel() - if _, err := ok.GetSupportCoins(context.Background()); err != nil { + if _, err := ok.GetSupportCoins(contextGenerate()); err != nil { t.Error("Okx GetSupportCoins() error", err) } } func TestGetTakerVolume(t *testing.T) { t.Parallel() - if _, err := ok.GetTakerVolume(context.Background(), "BTC", "SPOT", time.Time{}, time.Time{}, kline.OneDay); err != nil { + if _, err := ok.GetTakerVolume(contextGenerate(), "BTC", "SPOT", time.Time{}, time.Time{}, kline.OneDay); err != nil { t.Error("Okx GetTakerVolume() error", err) } } func TestGetMarginLendingRatio(t *testing.T) { t.Parallel() - if _, err := ok.GetMarginLendingRatio(context.Background(), "BTC", time.Time{}, time.Time{}, kline.FiveMin); err != nil { + if _, err := ok.GetMarginLendingRatio(contextGenerate(), "BTC", time.Time{}, time.Time{}, kline.FiveMin); err != nil { t.Error("Okx GetMarginLendingRatio() error", err) } } func TestGetLongShortRatio(t *testing.T) { t.Parallel() - if _, err := ok.GetLongShortRatio(context.Background(), "BTC", time.Time{}, time.Time{}, kline.OneDay); err != nil { + if _, err := ok.GetLongShortRatio(contextGenerate(), "BTC", time.Time{}, time.Time{}, kline.OneDay); err != nil { t.Error("Okx GetLongShortRatio() error", err) } } func TestGetContractsOpenInterestAndVolume(t *testing.T) { t.Parallel() - if _, err := ok.GetContractsOpenInterestAndVolume(context.Background(), "BTC", time.Time{}, time.Time{}, kline.OneDay); err != nil { + if _, err := ok.GetContractsOpenInterestAndVolume(contextGenerate(), "BTC", time.Time{}, time.Time{}, kline.OneDay); err != nil { t.Error("Okx GetContractsOpenInterestAndVolume() error", err) } } func TestGetOptionsOpenInterestAndVolume(t *testing.T) { t.Parallel() - if _, err := ok.GetOptionsOpenInterestAndVolume(context.Background(), "BTC", kline.OneDay); err != nil { + if _, err := ok.GetOptionsOpenInterestAndVolume(contextGenerate(), "BTC", kline.OneDay); err != nil { t.Error("Okx GetOptionsOpenInterestAndVolume() error", err) } } func TestGetPutCallRatio(t *testing.T) { t.Parallel() - if _, err := ok.GetPutCallRatio(context.Background(), "BTC", kline.OneDay); err != nil { + if _, err := ok.GetPutCallRatio(contextGenerate(), "BTC", kline.OneDay); err != nil { t.Error("Okx GetPutCallRatio() error", err) } } func TestGetOpenInterestAndVolumeExpiry(t *testing.T) { t.Parallel() - if _, err := ok.GetOpenInterestAndVolumeExpiry(context.Background(), "BTC", kline.OneDay); err != nil { + if _, err := ok.GetOpenInterestAndVolumeExpiry(contextGenerate(), "BTC", kline.OneDay); err != nil { t.Error("Okx GetOpenInterestAndVolume() error", err) } } func TestGetOpenInterestAndVolumeStrike(t *testing.T) { t.Parallel() - if _, err := ok.GetOpenInterestAndVolumeStrike(context.Background(), "BTC", time.Now(), kline.OneDay); err != nil { + if _, err := ok.GetOpenInterestAndVolumeStrike(contextGenerate(), "BTC", time.Now(), kline.OneDay); err != nil { t.Error("Okx GetOpenInterestAndVolumeStrike() error", err) } } func TestGetTakerFlow(t *testing.T) { t.Parallel() - if _, err := ok.GetTakerFlow(context.Background(), "BTC", kline.OneDay); err != nil { + if _, err := ok.GetTakerFlow(contextGenerate(), "BTC", kline.OneDay); err != nil { t.Error("Okx GetTakerFlow() error", err) } } @@ -445,7 +447,7 @@ func TestPlaceOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.PlaceOrder(context.Background(), &PlaceOrderRequestParam{ + if _, err := ok.PlaceOrder(contextGenerate(), &PlaceOrderRequestParam{ InstrumentID: "BTC-USDC", TradeMode: "cross", Side: "Buy", @@ -470,7 +472,7 @@ func TestPlaceMultipleOrders(t *testing.T) { t.Fatal(err) } - if _, err = ok.PlaceMultipleOrders(context.Background(), + if _, err = ok.PlaceMultipleOrders(contextGenerate(), params); err != nil { t.Error("Okx PlaceMultipleOrders() error", err) } @@ -480,7 +482,7 @@ func TestCancelSingleOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelSingleOrder(context.Background(), + if _, err := ok.CancelSingleOrder(contextGenerate(), CancelOrderRequestParam{ InstrumentID: "BTC-USDT", OrderID: "2510789768709120", @@ -493,7 +495,7 @@ func TestCancelMultipleOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelMultipleOrders(context.Background(), []CancelOrderRequestParam{{ + if _, err := ok.CancelMultipleOrders(contextGenerate(), []CancelOrderRequestParam{{ InstrumentID: "DCR-BTC", OrderID: "2510789768709120", }}); err != nil { @@ -505,7 +507,7 @@ func TestAmendOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.AmendOrder(context.Background(), &AmendOrderRequestParams{ + if _, err := ok.AmendOrder(contextGenerate(), &AmendOrderRequestParams{ InstrumentID: "DCR-BTC", OrderID: "2510789768709120", NewPrice: 1233324.332, @@ -517,7 +519,7 @@ func TestAmendMultipleOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.AmendMultipleOrders(context.Background(), []AmendOrderRequestParams{{ + if _, err := ok.AmendMultipleOrders(contextGenerate(), []AmendOrderRequestParams{{ InstrumentID: "BTC-USDT", OrderID: "2510789768709120", NewPrice: 1233324.332, @@ -530,7 +532,7 @@ func TestClosePositions(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.ClosePositions(context.Background(), &ClosePositionsRequestParams{ + if _, err := ok.ClosePositions(contextGenerate(), &ClosePositionsRequestParams{ InstrumentID: "BTC-USDT", MarginMode: "cross", Currency: "BTC", @@ -543,7 +545,7 @@ func TestGetOrderDetail(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetOrderDetail(context.Background(), &OrderDetailRequestParam{ + if _, err := ok.GetOrderDetail(contextGenerate(), &OrderDetailRequestParam{ InstrumentID: "BTC-USDT", OrderID: "2510789768709120", }); !strings.Contains(err.Error(), "Order does not exist") { @@ -555,7 +557,7 @@ func TestGetOrderList(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetOrderList(context.Background(), &OrderListRequestParams{ + if _, err := ok.GetOrderList(contextGenerate(), &OrderListRequestParams{ Limit: 1, }); err != nil { t.Error("Okx GetOrderList() error", err) @@ -566,12 +568,12 @@ func TestGet7And3MonthDayOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.Get7DayOrderHistory(context.Background(), &OrderHistoryRequestParams{ + if _, err := ok.Get7DayOrderHistory(contextGenerate(), &OrderHistoryRequestParams{ OrderListRequestParams: OrderListRequestParams{InstrumentType: "MARGIN"}, }); err != nil { t.Error("Okx Get7DayOrderHistory() error", err) } - if _, err := ok.Get3MonthOrderHistory(context.Background(), &OrderHistoryRequestParams{ + if _, err := ok.Get3MonthOrderHistory(contextGenerate(), &OrderHistoryRequestParams{ OrderListRequestParams: OrderListRequestParams{InstrumentType: "MARGIN"}, }); err != nil { t.Error("Okx Get3MonthOrderHistory() error", err) @@ -582,13 +584,13 @@ func TestTransactionHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetTransactionDetailsLast3Days(context.Background(), &TransactionDetailRequestParams{ + if _, err := ok.GetTransactionDetailsLast3Days(contextGenerate(), &TransactionDetailRequestParams{ InstrumentType: "MARGIN", Limit: 1, }); err != nil { t.Error("Okx GetTransactionDetailsLast3Days() error", err) } - if _, err := ok.GetTransactionDetailsLast3Months(context.Background(), &TransactionDetailRequestParams{ + if _, err := ok.GetTransactionDetailsLast3Months(contextGenerate(), &TransactionDetailRequestParams{ InstrumentType: "MARGIN", }); err != nil { t.Error("Okx GetTransactionDetailsLast3Days() error", err) @@ -599,7 +601,7 @@ func TestStopOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.PlaceStopOrder(context.Background(), &AlgoOrderParams{ + if _, err := ok.PlaceStopOrder(contextGenerate(), &AlgoOrderParams{ TakeProfitTriggerPriceType: "index", InstrumentID: "BTC-USDT", OrderType: "conditional", @@ -612,7 +614,7 @@ func TestStopOrder(t *testing.T) { }); err != nil { t.Errorf("Okx StopOrderParams() error %v", err) } - if _, err := ok.PlaceTrailingStopOrder(context.Background(), &AlgoOrderParams{ + if _, err := ok.PlaceTrailingStopOrder(contextGenerate(), &AlgoOrderParams{ CallbackRatio: 0.01, InstrumentID: "BTC-USDT", OrderType: "move_order_stop", @@ -623,7 +625,7 @@ func TestStopOrder(t *testing.T) { }); err != nil { t.Error("Okx PlaceTrailingStopOrder error", err) } - if _, err := ok.PlaceIcebergOrder(context.Background(), &AlgoOrderParams{ + if _, err := ok.PlaceIcebergOrder(contextGenerate(), &AlgoOrderParams{ PriceLimit: 100.22, SizeLimit: 9999.9, PriceSpread: "0.04", @@ -637,7 +639,7 @@ func TestStopOrder(t *testing.T) { }); err != nil { t.Error("Okx PlaceIceburgOrder() error", err) } - if _, err := ok.PlaceTWAPOrder(context.Background(), &AlgoOrderParams{ + if _, err := ok.PlaceTWAPOrder(contextGenerate(), &AlgoOrderParams{ InstrumentID: "BTC-USDT", PriceLimit: 100.22, SizeLimit: 9999.9, @@ -650,7 +652,7 @@ func TestStopOrder(t *testing.T) { }); err != nil { t.Error("Okx PlaceTWAPOrder() error", err) } - if _, err := ok.TriggerAlgoOrder(context.Background(), &AlgoOrderParams{ + if _, err := ok.TriggerAlgoOrder(contextGenerate(), &AlgoOrderParams{ TriggerPriceType: "mark", TriggerPrice: 1234, @@ -668,7 +670,7 @@ func TestCancelAlgoOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelAlgoOrder(context.Background(), []AlgoOrderCancelParams{ + if _, err := ok.CancelAlgoOrder(contextGenerate(), []AlgoOrderCancelParams{ { InstrumentID: "BTC-USDT", AlgoOrderID: "90994943", @@ -682,7 +684,7 @@ func TestCancelAdvanceAlgoOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelAdvanceAlgoOrder(context.Background(), []AlgoOrderCancelParams{{ + if _, err := ok.CancelAdvanceAlgoOrder(contextGenerate(), []AlgoOrderCancelParams{{ InstrumentID: "BTC-USDT", AlgoOrderID: "90994943", }}); err != nil { @@ -694,7 +696,7 @@ func TestGetAlgoOrderList(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetAlgoOrderList(context.Background(), "conditional", "", "", "", "", time.Time{}, time.Time{}, 1); err != nil { + if _, err := ok.GetAlgoOrderList(contextGenerate(), "conditional", "", "", "", "", time.Time{}, time.Time{}, 1); err != nil { t.Error("Okx GetAlgoOrderList() error", err) } } @@ -703,7 +705,7 @@ func TestGetAlgoOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetAlgoOrderHistory(context.Background(), "conditional", "effective", "", "", "", time.Time{}, time.Time{}, 1); err != nil { + if _, err := ok.GetAlgoOrderHistory(contextGenerate(), "conditional", "effective", "", "", "", time.Time{}, time.Time{}, 1); err != nil { t.Error("Okx GetAlgoOrderList() error", err) } } @@ -712,7 +714,7 @@ func TestGetEasyConvertCurrencyList(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetEasyConvertCurrencyList(context.Background()); err != nil { + if _, err := ok.GetEasyConvertCurrencyList(contextGenerate()); err != nil { t.Errorf("%s GetEasyConvertCurrencyList() error %v", ok.Name, err) } } @@ -721,7 +723,7 @@ func TestGetOneClickRepayCurrencyList(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetOneClickRepayCurrencyList(context.Background(), "cross"); err != nil && !strings.Contains(err.Error(), "Parameter acctLv error") { + if _, err := ok.GetOneClickRepayCurrencyList(contextGenerate(), "cross"); err != nil && !strings.Contains(err.Error(), "Parameter acctLv error") { t.Error(err) } } @@ -730,7 +732,7 @@ func TestPlaceEasyConvert(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.PlaceEasyConvert(context.Background(), + if _, err := ok.PlaceEasyConvert(contextGenerate(), PlaceEasyConvertParam{ FromCurrency: []string{"BTC"}, ToCurrency: "USDT"}); err != nil { @@ -742,7 +744,7 @@ func TestGetEasyConvertHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetEasyConvertHistory(context.Background(), time.Time{}, time.Time{}, 1); err != nil { + if _, err := ok.GetEasyConvertHistory(contextGenerate(), time.Time{}, time.Time{}, 1); err != nil { t.Errorf("%s GetEasyConvertHistory() error %v", ok.Name, err) } } @@ -751,7 +753,7 @@ func TestGetOneClickRepayHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetOneClickRepayHistory(context.Background(), time.Time{}, time.Time{}, 1); err != nil && !strings.Contains(err.Error(), "Parameter acctLv error") { + if _, err := ok.GetOneClickRepayHistory(contextGenerate(), time.Time{}, time.Time{}, 1); err != nil && !strings.Contains(err.Error(), "Parameter acctLv error") { t.Errorf("%s GetOneClickRepayHistory() error %v", ok.Name, err) } } @@ -760,7 +762,7 @@ func TestTradeOneClickRepay(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.TradeOneClickRepay(context.Background(), TradeOneClickRepayParam{ + if _, err := ok.TradeOneClickRepay(contextGenerate(), TradeOneClickRepayParam{ DebtCurrency: []string{"BTC"}, RepayCurrency: "USDT", }); err != nil { @@ -772,7 +774,7 @@ func TestGetCounterparties(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetCounterparties(context.Background()); err != nil && !strings.Contains(err.Error(), "code: 70006 message: Does not meet the minimum asset requirement.") { + if _, err := ok.GetCounterparties(contextGenerate()); err != nil && !strings.Contains(err.Error(), "code: 70006 message: Does not meet the minimum asset requirement.") { t.Error("Okx GetCounterparties() error", err) } } @@ -787,7 +789,7 @@ func TestCreateRFQ(t *testing.T) { if err := json.Unmarshal([]byte(createRFQInputJSON), &input); err != nil { t.Error("Okx Decerializing to CreateRFQInput", err) } - if _, err := ok.CreateRFQ(context.Background(), input); err != nil { + if _, err := ok.CreateRFQ(contextGenerate(), input); err != nil { t.Error("Okx CreateRFQ() error", err) } } @@ -796,11 +798,11 @@ func TestCancelRFQ(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - _, err := ok.CancelRFQ(context.Background(), CancelRFQRequestParam{}) + _, err := ok.CancelRFQ(contextGenerate(), CancelRFQRequestParam{}) if err != nil && !errors.Is(err, errMissingRFQIDANDClientSuppliedRFQID) { t.Errorf("Okx CancelRFQ() expecting %v, but found %v", errMissingRFQIDANDClientSuppliedRFQID, err) } - _, err = ok.CancelRFQ(context.Background(), CancelRFQRequestParam{ + _, err = ok.CancelRFQ(contextGenerate(), CancelRFQRequestParam{ ClientSuppliedRFQID: "somersdjskfjsdkfjxvxv", }) if err != nil { @@ -812,11 +814,11 @@ func TestMultipleCancelRFQ(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - _, err := ok.CancelMultipleRFQs(context.Background(), CancelRFQRequestsParam{}) + _, err := ok.CancelMultipleRFQs(contextGenerate(), CancelRFQRequestsParam{}) if err != nil && !errors.Is(err, errMissingRFQIDANDClientSuppliedRFQID) { t.Errorf("Okx CancelMultipleRFQs() expecting %v, but found %v", errMissingRFQIDANDClientSuppliedRFQID, err) } - _, err = ok.CancelMultipleRFQs(context.Background(), CancelRFQRequestsParam{ + _, err = ok.CancelMultipleRFQs(contextGenerate(), CancelRFQRequestsParam{ ClientSuppliedRFQID: []string{"somersdjskfjsdkfjxvxv"}, }) if err != nil { @@ -828,7 +830,7 @@ func TestCancelAllRFQs(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelAllRFQs(context.Background()); err != nil { + if _, err := ok.CancelAllRFQs(contextGenerate()); err != nil { t.Errorf("%s CancelAllRFQs() error %v", ok.Name, err) } } @@ -837,11 +839,11 @@ func TestExecuteQuote(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - _, err := ok.ExecuteQuote(context.Background(), ExecuteQuoteParams{}) + _, err := ok.ExecuteQuote(contextGenerate(), ExecuteQuoteParams{}) if err != nil && !errors.Is(err, errMissingRfqIDOrQuoteID) { t.Errorf("Okx ExecuteQuote() expected %v, but found %v", errMissingRfqIDOrQuoteID, err) } - if _, err = ok.ExecuteQuote(context.Background(), ExecuteQuoteParams{ + if _, err = ok.ExecuteQuote(contextGenerate(), ExecuteQuoteParams{ RfqID: "22540", QuoteID: "84073", }); err != nil { @@ -853,7 +855,7 @@ func TestSetQuoteProducts(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.SetQuoteProducts(context.Background(), []SetQuoteProductParam{ + if _, err := ok.SetQuoteProducts(contextGenerate(), []SetQuoteProductParam{ { InstrumentType: "SWAP", Data: []MakerInstrumentSetting{ @@ -875,7 +877,7 @@ func TestResetMMPStatus(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.ResetMMPStatus(context.Background()); err != nil && !strings.Contains(err.Error(), "No permission to use this API") { + if _, err := ok.ResetMMPStatus(contextGenerate()); err != nil && !strings.Contains(err.Error(), "No permission to use this API") { t.Errorf("%s ResetMMPStatus() error %v", ok.Name, err) } } @@ -884,10 +886,10 @@ func TestCreateQuote(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CreateQuote(context.Background(), CreateQuoteParams{}); err != nil && !errors.Is(err, errMissingRfqID) { + if _, err := ok.CreateQuote(contextGenerate(), CreateQuoteParams{}); err != nil && !errors.Is(err, errMissingRfqID) { t.Errorf("Okx CreateQuote() expecting %v, but found %v", errMissingRfqID, err) } - if _, err := ok.CreateQuote(context.Background(), CreateQuoteParams{ + if _, err := ok.CreateQuote(contextGenerate(), CreateQuoteParams{ RfqID: "12345", QuoteSide: order.Buy, Legs: []QuoteLeg{ @@ -913,15 +915,15 @@ func TestCancelQuote(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelQuote(context.Background(), CancelQuoteRequestParams{}); err != nil && !errors.Is(err, errMissingQuoteIDOrClientSuppliedQuoteID) { + if _, err := ok.CancelQuote(contextGenerate(), CancelQuoteRequestParams{}); err != nil && !errors.Is(err, errMissingQuoteIDOrClientSuppliedQuoteID) { t.Error("Okx CancelQuote() error", err) } - if _, err := ok.CancelQuote(context.Background(), CancelQuoteRequestParams{ + if _, err := ok.CancelQuote(contextGenerate(), CancelQuoteRequestParams{ QuoteID: "1234", }); err != nil { t.Error("Okx CancelQuote() error", err) } - if _, err := ok.CancelQuote(context.Background(), CancelQuoteRequestParams{ + if _, err := ok.CancelQuote(contextGenerate(), CancelQuoteRequestParams{ ClientSuppliedQuoteID: "1234", }); err != nil { t.Error("Okx CancelQuote() error", err) @@ -932,10 +934,10 @@ func TestCancelMultipleQuote(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelMultipleQuote(context.Background(), CancelQuotesRequestParams{}); err != nil && !errors.Is(errMissingEitherQuoteIDAOrClientSuppliedQuoteIDs, err) { + if _, err := ok.CancelMultipleQuote(contextGenerate(), CancelQuotesRequestParams{}); err != nil && !errors.Is(errMissingEitherQuoteIDAOrClientSuppliedQuoteIDs, err) { t.Error("Okx CancelQuote() error", err) } - if _, err := ok.CancelMultipleQuote(context.Background(), CancelQuotesRequestParams{ + if _, err := ok.CancelMultipleQuote(contextGenerate(), CancelQuotesRequestParams{ QuoteIDs: []string{"1150", "1151", "1152"}, // Block trades require a minimum of $100,000 in assets in your trading account }); err != nil { @@ -947,7 +949,7 @@ func TestCancelAllQuotes(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - time, err := ok.CancelAllQuotes(context.Background()) + time, err := ok.CancelAllQuotes(contextGenerate()) switch { case err != nil: t.Error("Okx CancelAllQuotes() error", err) @@ -960,7 +962,7 @@ func TestGetRFQs(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetRfqs(context.Background(), &RfqRequestParams{ + if _, err := ok.GetRfqs(contextGenerate(), &RfqRequestParams{ Limit: 1, }); err != nil { t.Error("Okx GetRfqs() error", err) @@ -971,7 +973,7 @@ func TestGetQuotes(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetQuotes(context.Background(), &QuoteRequestParams{ + if _, err := ok.GetQuotes(contextGenerate(), &QuoteRequestParams{ Limit: 3, }); err != nil { t.Error("Okx GetQuotes() error", err) @@ -982,7 +984,7 @@ func TestGetRFQTrades(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetRFQTrades(context.Background(), &RFQTradesRequestParams{ + if _, err := ok.GetRFQTrades(contextGenerate(), &RFQTradesRequestParams{ Limit: 1, }); err != nil { t.Error("Okx GetRFQTrades() error", err) @@ -993,7 +995,7 @@ func TestGetPublicTrades(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetPublicTrades(context.Background(), "", "", 3); err != nil { + if _, err := ok.GetPublicTrades(contextGenerate(), "", "", 3); err != nil { t.Error("Okx GetPublicTrades() error", err) } } @@ -1002,7 +1004,7 @@ func TestGetFundingCurrencies(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetFundingCurrencies(context.Background()); err != nil { + if _, err := ok.GetFundingCurrencies(contextGenerate()); err != nil { t.Error("Okx GetFundingCurrencies() error", err) } } @@ -1011,7 +1013,7 @@ func TestGetBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetBalance(context.Background(), ""); err != nil { + if _, err := ok.GetBalance(contextGenerate(), ""); err != nil { t.Error("Okx GetBalance() error", err) } } @@ -1020,7 +1022,7 @@ func TestGetAccountAssetValuation(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetAccountAssetValuation(context.Background(), ""); err != nil { + if _, err := ok.GetAccountAssetValuation(contextGenerate(), ""); err != nil { t.Error("Okx GetAccountAssetValuation() error", err) } } @@ -1029,7 +1031,7 @@ func TestFundingTransfer(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.FundingTransfer(context.Background(), &FundingTransferRequestInput{ + if _, err := ok.FundingTransfer(contextGenerate(), &FundingTransferRequestInput{ Amount: 12.000, To: "6", From: "18", @@ -1043,7 +1045,7 @@ func TestGetFundsTransferState(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetFundsTransferState(context.Background(), "754147", "1232", 1); err != nil && !strings.Contains(err.Error(), "Parameter transId error") { + if _, err := ok.GetFundsTransferState(contextGenerate(), "754147", "1232", 1); err != nil && !strings.Contains(err.Error(), "Parameter transId error") { t.Error("Okx GetFundsTransferState() error", err) } } @@ -1051,7 +1053,7 @@ func TestGetFundsTransferState(t *testing.T) { func TestGetAssetBillsDetails(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - _, err := ok.GetAssetBillsDetails(context.Background(), "", "", time.Time{}, time.Time{}, 0, 1) + _, err := ok.GetAssetBillsDetails(contextGenerate(), "", "", time.Time{}, time.Time{}, 0, 1) if err != nil { t.Error("Okx GetAssetBillsDetail() error", err) } @@ -1061,7 +1063,7 @@ func TestGetLightningDeposits(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetLightningDeposits(context.Background(), "BTC", 1.00, 0); err != nil && !strings.Contains(err.Error(), "58355") { + if _, err := ok.GetLightningDeposits(contextGenerate(), "BTC", 1.00, 0); err != nil && !strings.Contains(err.Error(), "58355") { t.Error("Okx GetLightningDeposits() error", err) } } @@ -1070,7 +1072,7 @@ func TestGetCurrencyDepositAddress(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetCurrencyDepositAddress(context.Background(), "BTC"); err != nil { + if _, err := ok.GetCurrencyDepositAddress(contextGenerate(), "BTC"); err != nil { t.Error("Okx GetCurrencyDepositAddress() error", err) } } @@ -1079,7 +1081,7 @@ func TestGetCurrencyDepositHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetCurrencyDepositHistory(context.Background(), "BTC", "", "", time.Time{}, time.Time{}, 0, 1); err != nil { + if _, err := ok.GetCurrencyDepositHistory(contextGenerate(), "BTC", "", "", time.Time{}, time.Time{}, 0, 1); err != nil { t.Error("Okx GetCurrencyDepositHistory() error", err) } } @@ -1088,7 +1090,7 @@ func TestWithdrawal(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - _, err := ok.Withdrawal(context.Background(), &WithdrawalInput{Amount: 0.1, TransactionFee: 0.00005, Currency: "BTC", WithdrawalDestination: "4", ToAddress: core.BitcoinDonationAddress}) + _, err := ok.Withdrawal(contextGenerate(), &WithdrawalInput{Amount: 0.1, TransactionFee: 0.00005, Currency: "BTC", WithdrawalDestination: "4", ToAddress: core.BitcoinDonationAddress}) if err != nil { t.Error("Okx Withdrawal error", err) } @@ -1098,7 +1100,7 @@ func TestLightningWithdrawal(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.LightningWithdrawal(context.Background(), LightningWithdrawalRequestInput{ + if _, err := ok.LightningWithdrawal(contextGenerate(), LightningWithdrawalRequestInput{ Currency: currency.BTC.String(), Invoice: "lnbc100u1psnnvhtpp5yq2x3q5hhrzsuxpwx7ptphwzc4k4wk0j3stp0099968m44cyjg9sdqqcqzpgxqzjcsp5hz", }); err != nil { @@ -1110,7 +1112,7 @@ func TestCancelWithdrawal(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelWithdrawal(context.Background(), "fjasdfkjasdk"); err != nil { + if _, err := ok.CancelWithdrawal(contextGenerate(), "fjasdfkjasdk"); err != nil { t.Error("Okx CancelWithdrawal() error", err.Error()) } } @@ -1119,7 +1121,7 @@ func TestGetWithdrawalHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetWithdrawalHistory(context.Background(), "BTC", "", "", "", "", time.Time{}, time.Time{}, 1); err != nil { + if _, err := ok.GetWithdrawalHistory(contextGenerate(), "BTC", "", "", "", "", time.Time{}, time.Time{}, 1); err != nil { t.Error("Okx GetWithdrawalHistory() error", err) } } @@ -1128,7 +1130,7 @@ func TestSmallAssetsConvert(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.SmallAssetsConvert(context.Background(), []string{"BTC", "USDT"}); err != nil { + if _, err := ok.SmallAssetsConvert(contextGenerate(), []string{"BTC", "USDT"}); err != nil { t.Error("Okx SmallAssetsConvert() error", err) } } @@ -1137,7 +1139,7 @@ func TestGetSavingBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetSavingBalance(context.Background(), "BTC"); err != nil { + if _, err := ok.GetSavingBalance(contextGenerate(), "BTC"); err != nil { t.Error("Okx GetSavingBalance() error", err) } } @@ -1146,7 +1148,7 @@ func TestSavingsPurchase(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.SavingsPurchaseOrRedemption(context.Background(), &SavingsPurchaseRedemptionInput{ + if _, err := ok.SavingsPurchaseOrRedemption(contextGenerate(), &SavingsPurchaseRedemptionInput{ Amount: 123.4, Currency: "BTC", Rate: 1, @@ -1154,7 +1156,7 @@ func TestSavingsPurchase(t *testing.T) { }); err != nil { t.Error("Okx SavingsPurchaseOrRedemption() error", err) } - if _, err := ok.SavingsPurchaseOrRedemption(context.Background(), &SavingsPurchaseRedemptionInput{ + if _, err := ok.SavingsPurchaseOrRedemption(contextGenerate(), &SavingsPurchaseRedemptionInput{ Amount: 123.4, Currency: "BTC", Rate: 1, @@ -1168,7 +1170,7 @@ func TestSetLendingRate(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.SetLendingRate(context.Background(), LendingRate{Currency: "BTC", Rate: 2}); err != nil { + if _, err := ok.SetLendingRate(contextGenerate(), LendingRate{Currency: "BTC", Rate: 2}); err != nil { t.Error("Okx SetLendingRate() error", err) } } @@ -1177,14 +1179,14 @@ func TestGetLendingHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetLendingHistory(context.Background(), "USDT", time.Time{}, time.Time{}, 1); err != nil { + if _, err := ok.GetLendingHistory(contextGenerate(), "USDT", time.Time{}, time.Time{}, 1); err != nil { t.Error("Okx GetLendingHostory() error", err) } } func TestGetPublicBorrowInfo(t *testing.T) { t.Parallel() - if _, err := ok.GetPublicBorrowInfo(context.Background(), ""); err != nil { + if _, err := ok.GetPublicBorrowInfo(contextGenerate(), ""); err != nil { t.Error("Okx GetPublicBorrowInfo() error", err) } if _, err := ok.GetPublicBorrowInfo(context.Background(), "USDT"); err != nil { @@ -1203,7 +1205,7 @@ func TestGetConvertCurrencies(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetConvertCurrencies(context.Background()); err != nil { + if _, err := ok.GetConvertCurrencies(contextGenerate()); err != nil { t.Error("Okx GetConvertCurrencies() error", err) } } @@ -1212,7 +1214,7 @@ func TestGetConvertCurrencyPair(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetConvertCurrencyPair(context.Background(), "USDT", "BTC"); err != nil { + if _, err := ok.GetConvertCurrencyPair(contextGenerate(), "USDT", "BTC"); err != nil { t.Error("Okx GetConvertCurrencyPair() error", err) } } @@ -1221,7 +1223,7 @@ func TestEstimateQuote(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.EstimateQuote(context.Background(), &EstimateQuoteRequestInput{ + if _, err := ok.EstimateQuote(contextGenerate(), &EstimateQuoteRequestInput{ BaseCurrency: "BTC", QuoteCurrency: "USDT", Side: "sell", @@ -1236,7 +1238,7 @@ func TestConvertTrade(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.ConvertTrade(context.Background(), &ConvertTradeInput{ + if _, err := ok.ConvertTrade(contextGenerate(), &ConvertTradeInput{ BaseCurrency: "BTC", QuoteCurrency: "USDT", Side: "Buy", @@ -1252,7 +1254,7 @@ func TestGetConvertHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetConvertHistory(context.Background(), time.Time{}, time.Time{}, 1, ""); err != nil { + if _, err := ok.GetConvertHistory(contextGenerate(), time.Time{}, time.Time{}, 1, ""); err != nil { t.Error("Okx GetConvertHistory() error", err) } } @@ -1261,7 +1263,7 @@ func TestGetNonZeroAccountBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetNonZeroBalances(context.Background(), ""); err != nil { + if _, err := ok.AccountBalance(contextGenerate(), ""); err != nil { t.Error("Okx GetBalance() error", err) } } @@ -1270,7 +1272,7 @@ func TestGetPositions(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetPositions(context.Background(), "", "", ""); err != nil { + if _, err := ok.GetPositions(contextGenerate(), "", "", ""); err != nil { t.Error("Okx GetPositions() error", err) } } @@ -1279,7 +1281,7 @@ func TestGetPositionsHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetPositionsHistory(context.Background(), "", "", "", 0, 1, time.Time{}, time.Time{}); err != nil { + if _, err := ok.GetPositionsHistory(contextGenerate(), "", "", "", 0, 1, time.Time{}, time.Time{}); err != nil { t.Error("Okx GetPositionsHistory() error", err) } } @@ -1288,7 +1290,7 @@ func TestGetAccountAndPositionRisk(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetAccountAndPositionRisk(context.Background(), ""); err != nil { + if _, err := ok.GetAccountAndPositionRisk(contextGenerate(), ""); err != nil { t.Error("Okx GetAccountAndPositionRisk() error", err) } } @@ -1297,7 +1299,7 @@ func TestGetBillsDetail(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetBillsDetailLast7Days(context.Background(), &BillsDetailQueryParameter{ + if _, err := ok.GetBillsDetailLast7Days(contextGenerate(), &BillsDetailQueryParameter{ Limit: 3, }); err != nil { t.Error("Okx GetBillsDetailLast7Days() error", err) @@ -1308,7 +1310,7 @@ func TestGetAccountConfiguration(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetAccountConfiguration(context.Background()); err != nil { + if _, err := ok.GetAccountConfiguration(contextGenerate()); err != nil { t.Error("Okx GetAccountConfiguration() error", err) } } @@ -1317,22 +1319,22 @@ func TestSetPositionMode(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.SetPositionMode(context.Background(), "net_mode"); err != nil { + if _, err := ok.SetPositionMode(contextGenerate(), "net_mode"); err != nil { t.Error("Okx SetPositionMode() error", err) } } -func TestSetLeverage(t *testing.T) { +func TestSetLeverageRate(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.SetLeverage(context.Background(), SetLeverageInput{ + if _, err := ok.SetLeverageRate(contextGenerate(), SetLeverageInput{ Currency: "USDT", Leverage: 5, MarginMode: "cross", InstrumentID: "BTC-USDT", }); err != nil && !errors.Is(err, errNoValidResponseFromServer) { - t.Error("Okx SetLeverage() error", err) + t.Error("Okx SetLeverageRate() error", err) } } @@ -1340,7 +1342,7 @@ func TestGetMaximumBuySellAmountOROpenAmount(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetMaximumBuySellAmountOROpenAmount(context.Background(), "BTC-USDT", "cross", "BTC", "", 5); err != nil { + if _, err := ok.GetMaximumBuySellAmountOROpenAmount(contextGenerate(), "BTC-USDT", "cross", "BTC", "", 5); err != nil { t.Error("Okx GetMaximumBuySellAmountOROpenAmount() error", err) } } @@ -1349,7 +1351,7 @@ func TestGetMaximumAvailableTradableAmount(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetMaximumAvailableTradableAmount(context.Background(), "BTC-USDT", "BTC", "cross", true, 123); err != nil && !strings.Contains(err.Error(), "51010") { + if _, err := ok.GetMaximumAvailableTradableAmount(contextGenerate(), "BTC-USDT", "BTC", "cross", true, 123); err != nil && !strings.Contains(err.Error(), "51010") { t.Error("Okx GetMaximumAvailableTradableAmount() error", err) } } @@ -1358,7 +1360,7 @@ func TestIncreaseDecreaseMargin(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.IncreaseDecreaseMargin(context.Background(), IncreaseDecreaseMarginInput{ + if _, err := ok.IncreaseDecreaseMargin(contextGenerate(), IncreaseDecreaseMarginInput{ InstrumentID: "BTC-USDT", PositionSide: "long", Type: "add", @@ -1369,12 +1371,12 @@ func TestIncreaseDecreaseMargin(t *testing.T) { } } -func TestGetLeverage(t *testing.T) { +func TestGetLeverageRate(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetLeverage(context.Background(), "BTC-USDT", "cross"); err != nil { - t.Error("Okx GetLeverage() error", err) + if _, err := ok.GetLeverageRate(contextGenerate(), "BTC-USDT", "cross"); err != nil { + t.Error("Okx GetLeverageRate() error", err) } } @@ -1382,7 +1384,7 @@ func TestGetMaximumLoanOfInstrument(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetMaximumLoanOfInstrument(context.Background(), "ZRX-BTC", "isolated", "ZRX"); err != nil && !strings.Contains(err.Error(), "51010") { + if _, err := ok.GetMaximumLoanOfInstrument(contextGenerate(), "ZRX-BTC", "isolated", "ZRX"); err != nil && !strings.Contains(err.Error(), "51010") { t.Error("Okx GetMaximumLoanOfInstrument() error", err) } } @@ -1391,7 +1393,7 @@ func TestGetTradeFee(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetTradeFee(context.Background(), "SPOT", "", ""); err != nil { + if _, err := ok.GetTradeFee(contextGenerate(), "SPOT", "", ""); err != nil { t.Error("Okx GetTradeFeeRate() error", err) } } @@ -1400,7 +1402,7 @@ func TestGetInterestAccruedData(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetInterestAccruedData(context.Background(), 0, 1, "", "", "", time.Time{}, time.Time{}); err != nil { + if _, err := ok.GetInterestAccruedData(contextGenerate(), 0, 1, "", "", "", time.Time{}, time.Time{}); err != nil { t.Error("Okx GetInterestAccruedData() error", err) } } @@ -1409,7 +1411,7 @@ func TestGetInterestRate(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetInterestRate(context.Background(), ""); err != nil { + if _, err := ok.GetInterestRate(contextGenerate(), ""); err != nil { t.Error("Okx GetInterestRate() error", err) } } @@ -1418,7 +1420,7 @@ func TestSetGreeks(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.SetGreeks(context.Background(), "PA"); err != nil { + if _, err := ok.SetGreeks(contextGenerate(), "PA"); err != nil { t.Error("Okx SetGreeks() error", err) } } @@ -1427,7 +1429,7 @@ func TestIsolatedMarginTradingSettings(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.IsolatedMarginTradingSettings(context.Background(), IsolatedMode{ + if _, err := ok.IsolatedMarginTradingSettings(contextGenerate(), IsolatedMode{ IsoMode: "autonomy", InstrumentType: "MARGIN", }); err != nil { @@ -1439,7 +1441,7 @@ func TestGetMaximumWithdrawals(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetMaximumWithdrawals(context.Background(), "BTC"); err != nil { + if _, err := ok.GetMaximumWithdrawals(contextGenerate(), "BTC"); err != nil { t.Error("Okx GetMaximumWithdrawals() error", err) } } @@ -1448,7 +1450,7 @@ func TestGetAccountRiskState(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetAccountRiskState(context.Background()); err != nil && !strings.Contains(err.Error(), "51010") { + if _, err := ok.GetAccountRiskState(contextGenerate()); err != nil && !strings.Contains(err.Error(), "51010") { t.Error("Okx GetAccountRiskState() error", err) } } @@ -1457,7 +1459,7 @@ func TestVIPLoansBorrowAndRepay(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.VIPLoansBorrowAndRepay(context.Background(), LoanBorrowAndReplayInput{Currency: "BTC", Side: "borrow", Amount: 12}); err != nil && + if _, err := ok.VIPLoansBorrowAndRepay(contextGenerate(), LoanBorrowAndReplayInput{Currency: "BTC", Side: "borrow", Amount: 12}); err != nil && !strings.Contains(err.Error(), "Your account does not support VIP loan") { t.Error("Okx VIPLoansBorrowAndRepay() error", err) } @@ -1467,7 +1469,7 @@ func TestGetBorrowAndRepayHistoryForVIPLoans(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetBorrowAndRepayHistoryForVIPLoans(context.Background(), "", time.Time{}, time.Time{}, 3); err != nil { + if _, err := ok.GetBorrowAndRepayHistoryForVIPLoans(contextGenerate(), "", time.Time{}, time.Time{}, 3); err != nil { t.Error("Okx GetBorrowAndRepayHistoryForVIPLoans() error", err) } } @@ -1476,7 +1478,7 @@ func TestGetBorrowInterestAndLimit(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetBorrowInterestAndLimit(context.Background(), 1, "BTC"); err != nil && !strings.Contains(err.Error(), "59307") { // You are not eligible for VIP loans + if _, err := ok.GetBorrowInterestAndLimit(contextGenerate(), 1, "BTC"); err != nil && !strings.Contains(err.Error(), "59307") { // You are not eligible for VIP loans t.Error("Okx GetBorrowInterestAndLimit() error", err) } } @@ -1485,7 +1487,7 @@ func TestPositionBuilder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.PositionBuilder(context.Background(), PositionBuilderInput{ + if _, err := ok.PositionBuilder(contextGenerate(), PositionBuilderInput{ ImportExistingPosition: true, }); err != nil { t.Error("Okx PositionBuilder() error", err) @@ -1496,7 +1498,7 @@ func TestGetGreeks(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetGreeks(context.Background(), ""); err != nil && !strings.Contains(err.Error(), "Unsupported operation") { + if _, err := ok.GetGreeks(contextGenerate(), ""); err != nil && !strings.Contains(err.Error(), "Unsupported operation") { t.Error("Okx GetGreeks() error", err) } } @@ -1505,7 +1507,7 @@ func TestGetPMLimitation(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetPMLimitation(context.Background(), "SWAP", "BTC-USDT"); err != nil { + if _, err := ok.GetPMLimitation(contextGenerate(), "SWAP", "BTC-USDT"); err != nil { t.Errorf("%s GetPMLimitation() error %v", ok.Name, err) } } @@ -1514,7 +1516,7 @@ func TestViewSubaccountList(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.ViewSubAccountList(context.Background(), false, "", time.Time{}, time.Time{}, 2); err != nil { + if _, err := ok.ViewSubAccountList(contextGenerate(), false, "", time.Time{}, time.Time{}, 2); err != nil { t.Error("Okx ViewSubaccountList() error", err) } } @@ -1523,14 +1525,14 @@ func TestResetSubAccountAPIKey(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.ResetSubAccountAPIKey(context.Background(), &SubAccountAPIKeyParam{ + if _, err := ok.ResetSubAccountAPIKey(contextGenerate(), &SubAccountAPIKeyParam{ SubAccountName: "sam", APIKey: apiKey, APIKeyPermission: "trade", }); err != nil && !strings.Contains(err.Error(), "Parameter subAcct can not be empty.") { t.Errorf("%s ResetSubAccountAPIKey() error %v", ok.Name, err) } - if _, err := ok.ResetSubAccountAPIKey(context.Background(), &SubAccountAPIKeyParam{ + if _, err := ok.ResetSubAccountAPIKey(contextGenerate(), &SubAccountAPIKeyParam{ SubAccountName: "sam", APIKey: apiKey, Permissions: []string{"trade", "read"}, @@ -1543,10 +1545,10 @@ func TestGetSubaccountTradingBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetSubaccountTradingBalance(context.Background(), ""); err != nil && !errors.Is(err, errMissingRequiredParameterSubaccountName) { + if _, err := ok.GetSubaccountTradingBalance(contextGenerate(), ""); err != nil && !errors.Is(err, errMissingRequiredParameterSubaccountName) { t.Errorf("Okx GetSubaccountTradingBalance() expecting \"%v\", but found \"%v\"", errMissingRequiredParameterSubaccountName, err) } - if _, err := ok.GetSubaccountTradingBalance(context.Background(), "test1"); err != nil && !strings.Contains(err.Error(), "sub-account does not exist") { + if _, err := ok.GetSubaccountTradingBalance(contextGenerate(), "test1"); err != nil && !strings.Contains(err.Error(), "sub-account does not exist") { t.Error("Okx GetSubaccountTradingBalance() error", err) } } @@ -1555,7 +1557,7 @@ func TestGetSubaccountFundingBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetSubaccountFundingBalance(context.Background(), "test1", ""); err != nil && !strings.Contains(err.Error(), "Sub-account test1 does not exists") && !strings.Contains(err.Error(), "59510") { + if _, err := ok.GetSubaccountFundingBalance(contextGenerate(), "test1", ""); err != nil && !strings.Contains(err.Error(), "Sub-account test1 does not exists") && !strings.Contains(err.Error(), "59510") { t.Error("Okx GetSubaccountFundingBalance() error", err) } } @@ -1564,7 +1566,7 @@ func TestHistoryOfSubaccountTransfer(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.HistoryOfSubaccountTransfer(context.Background(), "", "0", "", time.Time{}, time.Time{}, 1); err != nil { + if _, err := ok.HistoryOfSubaccountTransfer(contextGenerate(), "", "0", "", time.Time{}, time.Time{}, 1); err != nil { t.Error("Okx HistoryOfSubaccountTransfer() error", err) } } @@ -1573,13 +1575,13 @@ func TestMasterAccountsManageTransfersBetweenSubaccounts(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.MasterAccountsManageTransfersBetweenSubaccounts(context.Background(), SubAccountAssetTransferParams{Currency: "BTC", Amount: 1200, From: 9, To: 9, FromSubAccount: "", ToSubAccount: "", LoanTransfer: true}); err != nil && !errors.Is(err, errInvalidSubaccount) { + if _, err := ok.MasterAccountsManageTransfersBetweenSubaccounts(contextGenerate(), SubAccountAssetTransferParams{Currency: "BTC", Amount: 1200, From: 9, To: 9, FromSubAccount: "", ToSubAccount: "", LoanTransfer: true}); err != nil && !errors.Is(err, errInvalidSubaccount) { t.Error("Okx MasterAccountsManageTransfersBetweenSubaccounts() error", err) } - if _, err := ok.MasterAccountsManageTransfersBetweenSubaccounts(context.Background(), SubAccountAssetTransferParams{Currency: "BTC", Amount: 1200, From: 8, To: 8, FromSubAccount: "", ToSubAccount: "", LoanTransfer: true}); err != nil && !errors.Is(err, errInvalidSubaccount) { + if _, err := ok.MasterAccountsManageTransfersBetweenSubaccounts(contextGenerate(), SubAccountAssetTransferParams{Currency: "BTC", Amount: 1200, From: 8, To: 8, FromSubAccount: "", ToSubAccount: "", LoanTransfer: true}); err != nil && !errors.Is(err, errInvalidSubaccount) { t.Error("Okx MasterAccountsManageTransfersBetweenSubaccounts() error", err) } - if _, err := ok.MasterAccountsManageTransfersBetweenSubaccounts(context.Background(), SubAccountAssetTransferParams{Currency: "BTC", Amount: 1200, From: 6, To: 6, FromSubAccount: "test1", ToSubAccount: "test2", LoanTransfer: true}); err != nil && !strings.Contains(err.Error(), "Sub-account test1 does not exists") { + if _, err := ok.MasterAccountsManageTransfersBetweenSubaccounts(contextGenerate(), SubAccountAssetTransferParams{Currency: "BTC", Amount: 1200, From: 6, To: 6, FromSubAccount: "test1", ToSubAccount: "test2", LoanTransfer: true}); err != nil && !strings.Contains(err.Error(), "Sub-account test1 does not exists") { t.Error("Okx MasterAccountsManageTransfersBetweenSubaccounts() error", err) } } @@ -1588,7 +1590,7 @@ func TestSetPermissionOfTransferOut(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.SetPermissionOfTransferOut(context.Background(), PermissionOfTransfer{SubAcct: "Test1"}); err != nil && !strings.Contains(err.Error(), "Sub-account does not exist") { + if _, err := ok.SetPermissionOfTransferOut(contextGenerate(), PermissionOfTransfer{SubAcct: "Test1"}); err != nil && !strings.Contains(err.Error(), "Sub-account does not exist") { t.Error("Okx SetPermissionOfTransferOut() error", err) } } @@ -1597,7 +1599,7 @@ func TestGetCustodyTradingSubaccountList(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetCustodyTradingSubaccountList(context.Background(), ""); err != nil { + if _, err := ok.GetCustodyTradingSubaccountList(contextGenerate(), ""); err != nil { t.Error("Okx GetCustodyTradingSubaccountList() error", err) } } @@ -1612,7 +1614,7 @@ func TestPlaceGridAlgoOrder(t *testing.T) { if err := json.Unmarshal([]byte(gridTradingPlaceOrder), &input); err != nil { t.Error("Okx Decerializing to GridALgoOrder error", err) } - if _, err := ok.PlaceGridAlgoOrder(context.Background(), &input); err != nil { + if _, err := ok.PlaceGridAlgoOrder(contextGenerate(), &input); err != nil { t.Error("Okx PlaceGridAlgoOrder() error", err) } } @@ -1632,7 +1634,7 @@ func TestAmendGridAlgoOrder(t *testing.T) { if err := json.Unmarshal([]byte(gridOrderAmendAlgo), &input); err != nil { t.Error("Okx Decerializing to GridAlgoOrderAmend error", err) } - if _, err := ok.AmendGridAlgoOrder(context.Background(), input); err != nil { + if _, err := ok.AmendGridAlgoOrder(contextGenerate(), input); err != nil { t.Error("Okx AmendGridAlgoOrder() error", err) } } @@ -1647,7 +1649,7 @@ func TestStopGridAlgoOrder(t *testing.T) { if err := json.Unmarshal([]byte(stopGridAlgoOrderJSON), &resp); err != nil { t.Error("error deserializing to StopGridAlgoOrder error", err) } - if _, err := ok.StopGridAlgoOrder(context.Background(), []StopGridAlgoOrderRequest{ + if _, err := ok.StopGridAlgoOrder(contextGenerate(), []StopGridAlgoOrderRequest{ resp, }); err != nil && !strings.Contains(err.Error(), "The strategy does not exist or has stopped") { t.Error("Okx StopGridAlgoOrder() error", err) @@ -1658,7 +1660,7 @@ func TestGetGridAlgoOrdersList(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetGridAlgoOrdersList(context.Background(), "grid", "", "", "", "", "", 1); err != nil { + if _, err := ok.GetGridAlgoOrdersList(contextGenerate(), "grid", "", "", "", "", "", 1); err != nil { t.Error("Okx GetGridAlgoOrdersList() error", err) } } @@ -1667,7 +1669,7 @@ func TestGetGridAlgoOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetGridAlgoOrderHistory(context.Background(), "contract_grid", "", "", "", "", "", 1); err != nil { + if _, err := ok.GetGridAlgoOrderHistory(contextGenerate(), "contract_grid", "", "", "", "", "", 1); err != nil { t.Error("Okx GetGridAlgoOrderHistory() error", err) } } @@ -1676,10 +1678,10 @@ func TestGetGridAlgoOrderDetails(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetGridAlgoOrderDetails(context.Background(), "grid", ""); err != nil && !errors.Is(err, errMissingAlgoOrderID) { + if _, err := ok.GetGridAlgoOrderDetails(contextGenerate(), "grid", ""); err != nil && !errors.Is(err, errMissingAlgoOrderID) { t.Errorf("Okx GetGridAlgoOrderDetails() expecting %v, but found %v error", errMissingAlgoOrderID, err) } - if _, err := ok.GetGridAlgoOrderDetails(context.Background(), "grid", "7878"); err != nil && !strings.Contains(err.Error(), "Order does not exist") { + if _, err := ok.GetGridAlgoOrderDetails(contextGenerate(), "grid", "7878"); err != nil && !strings.Contains(err.Error(), "Order does not exist") { t.Error("Okx GetGridAlgoOrderDetails() error", err) } } @@ -1688,16 +1690,16 @@ func TestGetGridAlgoSubOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetGridAlgoSubOrders(context.Background(), "", "", "", "", "", "", 2); err != nil && !errors.Is(err, errMissingAlgoOrderType) { + if _, err := ok.GetGridAlgoSubOrders(contextGenerate(), "", "", "", "", "", "", 2); err != nil && !errors.Is(err, errMissingAlgoOrderType) { t.Errorf("Okx GetGridAlgoSubOrders() expecting %v, but found %v", err, errMissingAlgoOrderType) } - if _, err := ok.GetGridAlgoSubOrders(context.Background(), "grid", "", "", "", "", "", 2); err != nil && !errors.Is(err, errMissingAlgoOrderID) { + if _, err := ok.GetGridAlgoSubOrders(contextGenerate(), "grid", "", "", "", "", "", 2); err != nil && !errors.Is(err, errMissingAlgoOrderID) { t.Errorf("Okx GetGridAlgoSubOrders() expecting %v, but found %v", err, errMissingAlgoOrderID) } - if _, err := ok.GetGridAlgoSubOrders(context.Background(), "grid", "1234", "", "", "", "", 2); err != nil && !errors.Is(err, errMissingSubOrderType) { + if _, err := ok.GetGridAlgoSubOrders(contextGenerate(), "grid", "1234", "", "", "", "", 2); err != nil && !errors.Is(err, errMissingSubOrderType) { t.Errorf("Okx GetGridAlgoSubOrders() expecting %v, but found %v", err, errMissingSubOrderType) } - if _, err := ok.GetGridAlgoSubOrders(context.Background(), "grid", "1234", "live", "", "", "", 2); err != nil && !errors.Is(err, errMissingSubOrderType) { + if _, err := ok.GetGridAlgoSubOrders(contextGenerate(), "grid", "1234", "live", "", "", "", 2); err != nil && !errors.Is(err, errMissingSubOrderType) { t.Errorf("Okx GetGridAlgoSubOrders() expecting %v, but found %v", err, errMissingSubOrderType) } } @@ -1712,16 +1714,16 @@ func TestGetGridAlgoOrderPositions(t *testing.T) { if err := json.Unmarshal([]byte(spotGridAlgoOrderPosition), &resp); err != nil { t.Error("Okx Decerializing to AlgoOrderPosition error", err) } - if _, err := ok.GetGridAlgoOrderPositions(context.Background(), "", ""); err != nil && !errors.Is(err, errInvalidAlgoOrderType) { + if _, err := ok.GetGridAlgoOrderPositions(contextGenerate(), "", ""); err != nil && !errors.Is(err, errInvalidAlgoOrderType) { t.Errorf("Okx GetGridAlgoOrderPositions() expecting %v, but found %v", errInvalidAlgoOrderType, err) } - if _, err := ok.GetGridAlgoOrderPositions(context.Background(), "contract_grid", ""); err != nil && !errors.Is(err, errMissingAlgoOrderID) { + if _, err := ok.GetGridAlgoOrderPositions(contextGenerate(), "contract_grid", ""); err != nil && !errors.Is(err, errMissingAlgoOrderID) { t.Errorf("Okx GetGridAlgoOrderPositions() expecting %v, but found %v", errMissingAlgoOrderID, err) } - if _, err := ok.GetGridAlgoOrderPositions(context.Background(), "contract_grid", ""); err != nil && !errors.Is(err, errMissingAlgoOrderID) { + if _, err := ok.GetGridAlgoOrderPositions(contextGenerate(), "contract_grid", ""); err != nil && !errors.Is(err, errMissingAlgoOrderID) { t.Errorf("Okx GetGridAlgoOrderPositions() expecting %v, but found %v", errMissingAlgoOrderID, err) } - if _, err := ok.GetGridAlgoOrderPositions(context.Background(), "contract_grid", "448965992920907776"); err != nil && !strings.Contains(err.Error(), "The strategy does not exist or has stopped") { + if _, err := ok.GetGridAlgoOrderPositions(contextGenerate(), "contract_grid", "448965992920907776"); err != nil && !strings.Contains(err.Error(), "The strategy does not exist or has stopped") { t.Errorf("Okx GetGridAlgoOrderPositions() expecting %v, but found %v", errMissingAlgoOrderID, err) } } @@ -1730,10 +1732,10 @@ func TestSpotGridWithdrawProfit(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.SpotGridWithdrawProfit(context.Background(), ""); err != nil && !errors.Is(err, errMissingAlgoOrderID) { + if _, err := ok.SpotGridWithdrawProfit(contextGenerate(), ""); err != nil && !errors.Is(err, errMissingAlgoOrderID) { t.Errorf("Okx SpotGridWithdrawProfit() expecting %v, but found %v", errMissingAlgoOrderID, err) } - if _, err := ok.SpotGridWithdrawProfit(context.Background(), "1234"); err != nil { + if _, err := ok.SpotGridWithdrawProfit(contextGenerate(), "1234"); err != nil { t.Error("Okx SpotGridWithdrawProfit() error", err) } } @@ -1742,13 +1744,13 @@ func TestComputeMarginBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.ComputeMarginBalance(context.Background(), MarginBalanceParam{ + if _, err := ok.ComputeMarginBalance(contextGenerate(), MarginBalanceParam{ AlgoID: "123456", Type: "other", }); err != nil && !errors.Is(err, errInvalidMarginTypeAdjust) { t.Errorf("%s ComputeMarginBalance() expected %v, but found %v", ok.Name, errInvalidMarginTypeAdjust, err) } - if _, err := ok.ComputeMarginBalance(context.Background(), MarginBalanceParam{ + if _, err := ok.ComputeMarginBalance(contextGenerate(), MarginBalanceParam{ AlgoID: "123456", Type: "add", }); err != nil && !strings.Contains(err.Error(), "The strategy does not exist or has stopped") { @@ -1760,7 +1762,7 @@ func TestAdjustMarginBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.AdjustMarginBalance(context.Background(), MarginBalanceParam{ + if _, err := ok.AdjustMarginBalance(contextGenerate(), MarginBalanceParam{ AlgoID: "1234", Type: "add", Amount: 12345, @@ -1777,7 +1779,7 @@ func TestGetGridAIParameter(t *testing.T) { if err := json.Unmarshal([]byte(gridAIParamJSON), &response); err != nil { t.Errorf("%s error while deserializing to GridAIParameterResponse error %v", ok.Name, err) } - if _, err := ok.GetGridAIParameter(context.Background(), "grid", "BTC-USDT", "", ""); err != nil { + if _, err := ok.GetGridAIParameter(contextGenerate(), "grid", "BTC-USDT", "", ""); err != nil { t.Errorf("%s GetGridAIParameter() error %v", ok.Name, err) } } @@ -1785,7 +1787,7 @@ func TestGetOffers(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetOffers(context.Background(), "", "", ""); err != nil { + if _, err := ok.GetOffers(contextGenerate(), "", "", ""); err != nil { t.Errorf("%s GetOffers() error %v", ok.Name, err) } } @@ -1794,7 +1796,7 @@ func TestPurchase(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.Purchase(context.Background(), PurchaseRequestParam{ + if _, err := ok.Purchase(contextGenerate(), PurchaseRequestParam{ ProductID: "1234", InvestData: []PurchaseInvestDataItem{ { @@ -1816,7 +1818,7 @@ func TestRedeem(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.Redeem(context.Background(), RedeemRequestParam{ + if _, err := ok.Redeem(contextGenerate(), RedeemRequestParam{ OrderID: "754147", ProtocolType: "defi", AllowEarlyRedeem: true, @@ -1829,7 +1831,7 @@ func TestCancelPurchaseOrRedemption(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelPurchaseOrRedemption(context.Background(), CancelFundingParam{ + if _, err := ok.CancelPurchaseOrRedemption(contextGenerate(), CancelFundingParam{ OrderID: "754147", ProtocolType: "defi", }); err != nil && !strings.Contains(err.Error(), "Order not found") { @@ -1841,7 +1843,7 @@ func TestGetEarnActiveOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetEarnActiveOrders(context.Background(), "", "", "", ""); err != nil { + if _, err := ok.GetEarnActiveOrders(contextGenerate(), "", "", "", ""); err != nil { t.Errorf("%s GetEarnActiveOrders() error %v", ok.Name, err) } } @@ -1850,14 +1852,14 @@ func TestGetFundingOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetFundingOrderHistory(context.Background(), "", "", "", time.Time{}, time.Time{}, 1); err != nil { + if _, err := ok.GetFundingOrderHistory(contextGenerate(), "", "", "", time.Time{}, time.Time{}, 1); err != nil { t.Errorf("%s GetFundingOrderHistory() error %v", ok.Name, err) } } func TestSystemStatusResponse(t *testing.T) { t.Parallel() - if _, err := ok.SystemStatusResponse(context.Background(), "completed"); err != nil { + if _, err := ok.SystemStatusResponse(contextGenerate(), "completed"); err != nil { t.Error("Okx SystemStatusResponse() error", err) } } @@ -1866,14 +1868,14 @@ func TestSystemStatusResponse(t *testing.T) { func TestFetchTradablePairs(t *testing.T) { t.Parallel() - if _, err := ok.FetchTradablePairs(context.Background(), asset.Options); err != nil { + if _, err := ok.FetchTradablePairs(contextGenerate(), asset.Options); err != nil { t.Error("Okx FetchTradablePairs() error", err) } } func TestUpdateTradablePairs(t *testing.T) { t.Parallel() - if err := ok.UpdateTradablePairs(context.Background(), true); err != nil { + if err := ok.UpdateTradablePairs(contextGenerate(), true); err != nil { t.Error("Okx UpdateTradablePairs() error", err) } } @@ -1883,18 +1885,16 @@ func TestUpdateOrderExecutionLimits(t *testing.T) { type limitTest struct { pair currency.Pair - step float64 - min float64 } tests := map[asset.Item][]limitTest{ asset.Spot: { - {currency.NewPair(currency.ETH, currency.USDT), 0.01, 0.0001}, - {currency.NewPair(currency.BTC, currency.USDT), 0.1, 0.00001}, + {currency.NewPair(currency.ETH, currency.USDT)}, + {currency.NewPair(currency.BTC, currency.USDT)}, }, asset.Margin: { - {currency.NewPair(currency.ETH, currency.USDT), 0.01, 0.0001}, - {currency.NewPair(currency.ETH, currency.BTC), 0.00001, 0.0001}, + {currency.NewPair(currency.ETH, currency.USDT)}, + {currency.NewPair(currency.ETH, currency.BTC)}, }, } @@ -1903,12 +1903,8 @@ func TestUpdateOrderExecutionLimits(t *testing.T) { if err != nil { t.Errorf("Error fetching dated %s pairs for test: %v", a, err) } - stepIncr := 0.1 - if a == asset.Options { - stepIncr = 0.0005 - } - tests[a] = []limitTest{{pairs[0], stepIncr, 1}} + tests[a] = []limitTest{{pairs[0]}} } for _, a := range ok.GetAssetTypes(false) { @@ -1924,12 +1920,12 @@ func TestUpdateOrderExecutionLimits(t *testing.T) { continue } - if got := limits.PriceStepIncrementSize; got != tt.step { - t.Errorf("Okx UpdateOrderExecutionLimits wrong PriceStepIncrementSize; Asset: %s Pair: %s Expected: %v Got: %v", a, tt.pair, tt.step, got) + if got := limits.PriceStepIncrementSize; got <= 0 { + t.Errorf("Okx UpdateOrderExecutionLimits wrong PriceStepIncrementSize; Asset: %s Pair: %s Got: %v", a, tt.pair, got) } - if got := limits.MinimumBaseAmount; got != tt.min { - t.Errorf("Okx UpdateOrderExecutionLimits wrong MinAmount; Pair: %s Expected: %v Got: %v", tt.pair, tt.min, got) + if got := limits.MinimumBaseAmount; got <= 0 { + t.Errorf("Okx UpdateOrderExecutionLimits wrong MinAmount; Pair: %s Got: %v", tt.pair, got) } } } @@ -1937,39 +1933,39 @@ func TestUpdateOrderExecutionLimits(t *testing.T) { func TestUpdateTicker(t *testing.T) { t.Parallel() - if _, err := ok.UpdateTicker(context.Background(), currency.NewPair(currency.BTC, currency.USDT), asset.Spot); err != nil { + if _, err := ok.UpdateTicker(contextGenerate(), currency.NewPair(currency.BTC, currency.USDT), asset.Spot); err != nil { t.Error("Okx UpdateTicker() error", err) } } func TestUpdateTickers(t *testing.T) { t.Parallel() - if err := ok.UpdateTickers(context.Background(), asset.Spot); err != nil { + if err := ok.UpdateTickers(contextGenerate(), asset.Spot); err != nil { t.Error("Okx UpdateTicker() error", err) } } func TestFetchTicker(t *testing.T) { t.Parallel() - _, err := ok.FetchTicker(context.Background(), currency.NewPair(currency.BTC, currency.NewCode("USDT-SWAP")), asset.PerpetualSwap) + _, err := ok.FetchTicker(contextGenerate(), currency.NewPair(currency.BTC, currency.NewCode("USDT-SWAP")), asset.PerpetualSwap) if err != nil { t.Error("Okx FetchTicker() error", err) } - if _, err = ok.FetchTicker(context.Background(), currency.NewPair(currency.BTC, currency.USDT), asset.Spot); err != nil { + if _, err = ok.FetchTicker(contextGenerate(), currency.NewPair(currency.BTC, currency.USDT), asset.Spot); err != nil { t.Error("Okx FetchTicker() error", err) } } func TestFetchOrderbook(t *testing.T) { t.Parallel() - if _, err := ok.FetchOrderbook(context.Background(), currency.NewPair(currency.BTC, currency.USDT), asset.Spot); err != nil { + if _, err := ok.FetchOrderbook(contextGenerate(), currency.NewPair(currency.BTC, currency.USDT), asset.Spot); err != nil { t.Error("Okx FetchOrderbook() error", err) } } func TestUpdateOrderbook(t *testing.T) { t.Parallel() - if _, err := ok.UpdateOrderbook(context.Background(), currency.NewPair(currency.BTC, currency.NewCode("USDT-SWAP")), asset.Spot); err != nil { + if _, err := ok.UpdateOrderbook(contextGenerate(), currency.NewPair(currency.BTC, currency.NewCode("USDT-SWAP")), asset.Spot); err != nil { t.Error("Okx UpdateOrderbook() error", err) } } @@ -1978,7 +1974,7 @@ func TestUpdateAccountInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.UpdateAccountInfo(context.Background(), asset.Spot); err != nil { + if _, err := ok.UpdateAccountInfo(contextGenerate(), asset.Spot); err != nil { t.Error("Okx UpdateAccountInfo() error", err) } } @@ -1987,7 +1983,7 @@ func TestFetchAccountInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.FetchAccountInfo(context.Background(), asset.Spot); err != nil { + if _, err := ok.FetchAccountInfo(contextGenerate(), asset.Spot); err != nil { t.Error("Okx FetchAccountInfo() error", err) } } @@ -1996,7 +1992,7 @@ func TestGetAccountFundingHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetAccountFundingHistory(context.Background()); err != nil { + if _, err := ok.GetAccountFundingHistory(contextGenerate()); err != nil { t.Error("Okx GetFundingHistory() error", err) } } @@ -2005,14 +2001,14 @@ func TestGetWithdrawalsHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot); err != nil { + if _, err := ok.GetWithdrawalsHistory(contextGenerate(), currency.BTC, asset.Spot); err != nil { t.Error("Okx GetWithdrawalsHistory() error", err) } } func TestGetRecentTrades(t *testing.T) { t.Parallel() - if _, err := ok.GetRecentTrades(context.Background(), currency.NewPair(currency.BTC, currency.USDT), asset.PerpetualSwap); err != nil { + if _, err := ok.GetRecentTrades(contextGenerate(), currency.NewPair(currency.BTC, currency.USDT), asset.PerpetualSwap); err != nil { t.Error("Okx GetRecentTrades() error", err) } } @@ -2042,7 +2038,27 @@ func TestSubmitOrder(t *testing.T) { ClientID: "yeneOrder", AssetType: asset.Spot, } - _, err = ok.SubmitOrder(context.Background(), orderSubmission) + _, err = ok.SubmitOrder(contextGenerate(), orderSubmission) + if err != nil { + t.Error("Okx SubmitOrder() error", err) + } + + cp, err := currency.NewPairFromString("BTC-USDT-230630") + if err != nil { + t.Fatal(err) + } + + orderSubmission = &order.Submit{ + Pair: cp, + Exchange: ok.Name, + Side: order.Buy, + Type: order.Market, + Amount: 1, + ClientID: "hellomoto", + AssetType: asset.Futures, + MarginType: margin.Multi, + } + _, err = ok.SubmitOrder(contextGenerate(), orderSubmission) if err != nil { t.Error("Okx SubmitOrder() error", err) } @@ -2059,7 +2075,7 @@ func TestCancelOrder(t *testing.T) { Pair: currency.NewPair(currency.LTC, currency.BTC), AssetType: asset.Spot, } - if err := ok.CancelOrder(context.Background(), orderCancellation); err != nil { + if err := ok.CancelOrder(contextGenerate(), orderCancellation); err != nil { t.Error(err) } } @@ -2084,7 +2100,7 @@ func TestCancelBatchOrders(t *testing.T) { AssetType: asset.PerpetualSwap, }, } - _, err := ok.CancelBatchOrders(context.Background(), orderCancellationParams) + _, err := ok.CancelBatchOrders(contextGenerate(), orderCancellationParams) if err != nil && !strings.Contains(err.Error(), "order does not exist.") { t.Error("Okx CancelBatchOrders() error", err) } @@ -2094,7 +2110,7 @@ func TestCancelAllOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - if _, err := ok.CancelAllOrders(context.Background(), &order.Cancel{}); err != nil { + if _, err := ok.CancelAllOrders(contextGenerate(), &order.Cancel{}); err != nil { t.Errorf("%s CancelAllOrders() error: %v", ok.Name, err) } } @@ -2103,7 +2119,7 @@ func TestModifyOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) - _, err := ok.ModifyOrder(context.Background(), + _, err := ok.ModifyOrder(contextGenerate(), &order.Modify{ AssetType: asset.Spot, Pair: currency.NewPair(currency.LTC, currency.BTC), @@ -2127,7 +2143,7 @@ func TestGetOrderInfo(t *testing.T) { if len(enabled) == 0 { t.SkipNow() } - _, err = ok.GetOrderInfo(context.Background(), + _, err = ok.GetOrderInfo(contextGenerate(), "123", enabled[0], asset.Futures) if err != nil && !strings.Contains(err.Error(), "Order does not exist") { t.Errorf("Okx GetOrderInfo() expecting %s, but found %v", "Order does not exist", err) @@ -2138,7 +2154,7 @@ func TestGetDepositAddress(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetDepositAddress(context.Background(), currency.BTC, "", ""); err != nil && !errors.Is(err, errDepositAddressNotFound) { + if _, err := ok.GetDepositAddress(contextGenerate(), currency.BTC, "", ""); err != nil && !errors.Is(err, errDepositAddressNotFound) { t.Error("Okx GetDepositAddress() error", err) } } @@ -2155,7 +2171,7 @@ func TestWithdraw(t *testing.T) { Address: core.BitcoinDonationAddress, }, } - if _, err := ok.WithdrawCryptocurrencyFunds(context.Background(), &withdrawCryptoRequest); err != nil { + if _, err := ok.WithdrawCryptocurrencyFunds(contextGenerate(), &withdrawCryptoRequest); err != nil { t.Error("Okx WithdrawCryptoCurrencyFunds() error", err) } } @@ -2192,7 +2208,7 @@ func TestGetActiveOrders(t *testing.T) { AssetType: asset.Spot, Side: order.Buy, } - if _, err := ok.GetActiveOrders(context.Background(), &getOrdersRequest); err != nil { + if _, err := ok.GetActiveOrders(contextGenerate(), &getOrdersRequest); err != nil { t.Error("Okx GetActiveOrders() error", err) } } @@ -2206,7 +2222,7 @@ func TestGetOrderHistory(t *testing.T) { AssetType: asset.Spot, Side: order.Buy, } - _, err := ok.GetOrderHistory(context.Background(), &getOrdersRequest) + _, err := ok.GetOrderHistory(contextGenerate(), &getOrdersRequest) if err == nil { t.Errorf("Okx GetOrderHistory() Expected: %v. received nil", err) } else if err != nil && !errors.Is(err, errMissingAtLeast1CurrencyPair) { @@ -2215,7 +2231,7 @@ func TestGetOrderHistory(t *testing.T) { getOrdersRequest.Pairs = []currency.Pair{ currency.NewPair(currency.LTC, currency.BTC)} - if _, err := ok.GetOrderHistory(context.Background(), &getOrdersRequest); err != nil { + if _, err := ok.GetOrderHistory(contextGenerate(), &getOrdersRequest); err != nil { t.Error("Okx GetOrderHistory() error", err) } } @@ -2223,7 +2239,7 @@ func TestGetFeeByType(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if _, err := ok.GetFeeByType(context.Background(), &exchange.FeeBuilder{ + if _, err := ok.GetFeeByType(contextGenerate(), &exchange.FeeBuilder{ Amount: 1, FeeType: exchange.CryptocurrencyTradeFee, Pair: currency.NewPairWithDelimiter(currency.BTC.String(), @@ -2241,7 +2257,7 @@ func TestValidateAPICredentials(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - if err := ok.ValidateAPICredentials(context.Background(), asset.Spot); err != nil { + if err := ok.ValidateAPICredentials(contextGenerate(), asset.Spot); err != nil { t.Errorf("%s ValidateAPICredentials() error %v", ok.Name, err) } } @@ -2251,12 +2267,12 @@ func TestGetHistoricCandles(t *testing.T) { pair := currency.NewPair(currency.BTC, currency.USDT) startTime := time.Date(2021, 2, 1, 0, 0, 0, 0, time.UTC) endTime := startTime.AddDate(0, 0, 100) - _, err := ok.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneDay, startTime, endTime) + _, err := ok.GetHistoricCandles(contextGenerate(), pair, asset.Spot, kline.OneDay, startTime, endTime) if err != nil { t.Fatal(err) } - _, err = ok.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.Interval(time.Hour*4), startTime, endTime) + _, err = ok.GetHistoricCandles(contextGenerate(), pair, asset.Spot, kline.Interval(time.Hour*4), startTime, endTime) if !errors.Is(err, kline.ErrRequestExceedsExchangeLimits) { t.Errorf("received: '%v' but expected: '%v'", err, kline.ErrRequestExceedsExchangeLimits) } @@ -2265,7 +2281,7 @@ func TestGetHistoricCandles(t *testing.T) { func TestGetHistoricCandlesExtended(t *testing.T) { t.Parallel() currencyPair := currency.NewPair(currency.BTC, currency.USDT) - _, err := ok.GetHistoricCandlesExtended(context.Background(), currencyPair, asset.Spot, kline.OneMin, time.Now().Add(-time.Hour), time.Now()) + _, err := ok.GetHistoricCandlesExtended(contextGenerate(), currencyPair, asset.Spot, kline.OneMin, time.Now().Add(-time.Hour), time.Now()) if err != nil { t.Errorf("%s GetHistoricCandlesExtended() error: %v", ok.Name, err) } @@ -2465,7 +2481,7 @@ func TestAccountPushData(t *testing.T) { } const positionPushDataJSON = `{"arg":{"channel":"positions","instType":"FUTURES"},"data":[{"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-210430","instType":"FUTURES","interest":"0","last":"2566.22","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}]}` -const positionPushDataWithUnderlyingJSON = `{"arg": {"channel": "positions","uid": "77982378738415879","instType": "ANY"},"data": [{"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-210430","instType":"FUTURES","interest":"0","last":"2566.22","usdPx":"","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}, {"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-SWAP","instType":"SWAP","interest":"0","last":"2566.22","usdPx":"","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}]}` +const positionPushDataWithUnderlyingJSON = `{"arg": {"channel": "positions","uid": "77982378738415879","instType": "FUTURES"},"data": [{"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-210430","instType":"FUTURES","interest":"0","last":"2566.22","usdPx":"","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}, {"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-SWAP","instType":"SWAP","interest":"0","last":"2566.22","usdPx":"","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}]}` func TestPositionPushData(t *testing.T) { t.Parallel() @@ -2513,7 +2529,7 @@ func TestAdvancedAlgoOrderPushData(t *testing.T) { } } -const positionRiskPushDataJSON = `{"arg": {"channel": "liquidation-warning","uid": "77982378738415879","instType": "ANY"},"data": [{"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-210430","instType":"FUTURES","interest":"0","last":"2566.22","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}, {"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-SWAP","instType":"SWAP","interest":"0","last":"2566.22","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}]}` +const positionRiskPushDataJSON = `{"arg": {"channel": "liquidation-warning","uid": "77982378738415879","instType": "FUTURES"},"data": [{"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-210430","instType":"FUTURES","interest":"0","last":"2566.22","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}, {"adl":"1","availPos":"1","avgPx":"2566.31","cTime":"1619507758793","ccy":"ETH","deltaBS":"","deltaPA":"","gammaBS":"","gammaPA":"","imr":"","instId":"ETH-USD-SWAP","instType":"SWAP","interest":"0","last":"2566.22","lever":"10","liab":"","liabCcy":"","liqPx":"2352.8496681818233","markPx":"2353.849","margin":"0.0003896645377994","mgnMode":"isolated","mgnRatio":"11.731726509588816","mmr":"0.0000311811092368","notionalUsd":"2276.2546609009605","optVal":"","pTime":"1619507761462","pos":"1","posCcy":"","posId":"307173036051017730","posSide":"long","thetaBS":"","thetaPA":"","tradeId":"109844","uTime":"1619507761462","upl":"-0.0000009932766034","uplRatio":"-0.0025490556801078","vegaBS":"","vegaPA":""}]}` func TestPositionRiskPushDataJSON(t *testing.T) { t.Parallel() @@ -2605,7 +2621,7 @@ func TestGridSubOrdersPushData(t *testing.T) { func TestGetHistoricTrades(t *testing.T) { t.Parallel() - if _, err := ok.GetHistoricTrades(context.Background(), currency.NewPair(currency.BTC, currency.USDT), asset.Spot, time.Now().Add(-time.Minute*4), time.Now().Add(-time.Minute*2)); err != nil { + if _, err := ok.GetHistoricTrades(contextGenerate(), currency.NewPair(currency.BTC, currency.USDT), asset.Spot, time.Now().Add(-time.Minute*4), time.Now().Add(-time.Minute*2)); err != nil { t.Errorf("%s GetHistoricTrades() error %v", ok.Name, err) } } @@ -2670,7 +2686,7 @@ func TestTradesSubscription(t *testing.T) { func TestEstimatedDeliveryExercisePriceSubscription(t *testing.T) { t.Parallel() - futuresPairs, err := ok.FetchTradablePairs(context.Background(), asset.Futures) + futuresPairs, err := ok.FetchTradablePairs(contextGenerate(), asset.Futures) if err != nil { t.Errorf("%s error while fetching tradable pairs for instrument type %v: %v", ok.Name, asset.Futures, err) } @@ -2684,7 +2700,7 @@ func TestEstimatedDeliveryExercisePriceSubscription(t *testing.T) { func TestMarkPriceSubscription(t *testing.T) { t.Parallel() - futuresPairs, err := ok.FetchTradablePairs(context.Background(), asset.Futures) + futuresPairs, err := ok.FetchTradablePairs(contextGenerate(), asset.Futures) if err != nil { t.Errorf("%s error while fetching tradable pairs for instrument type %v: %v", ok.Name, asset.Futures, err) } @@ -2853,7 +2869,7 @@ func TestWsPlaceMultipleOrder(t *testing.T) { if err := json.Unmarshal([]byte(placeOrderArgs), &resp); err != nil { t.Error(err) } - pairs, err := ok.FetchTradablePairs(context.Background(), asset.Spot) + pairs, err := ok.FetchTradablePairs(contextGenerate(), asset.Spot) if err != nil { t.Fatal(err) } else if len(pairs) == 0 { @@ -3085,7 +3101,7 @@ func TestGridSubOrders(t *testing.T) { func TestGetServerTime(t *testing.T) { t.Parallel() - if _, err := ok.GetServerTime(context.Background(), asset.Empty); err != nil { + if _, err := ok.GetServerTime(contextGenerate(), asset.Empty); err != nil { t.Error(err) } } @@ -3093,8 +3109,7 @@ func TestGetServerTime(t *testing.T) { func TestGetAvailableTransferChains(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) - - if _, err := ok.GetAvailableTransferChains(context.Background(), currency.BTC); err != nil { + if _, err := ok.GetAvailableTransferChains(contextGenerate(), currency.BTC); err != nil { t.Error(err) } } @@ -3375,3 +3390,192 @@ func TestGetAssetsFromInstrumentTypeOrID(t *testing.T) { t.Errorf("received %v expected %v", assets, asset.Spot) } } + +func TestSetMarginType(t *testing.T) { + t.Parallel() + err := ok.SetMarginType(contextGenerate(), asset.Spot, currency.NewBTCUSDT(), margin.Isolated) + if !errors.Is(err, common.ErrFunctionNotSupported) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } +} + +func TestChangePositionMargin(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) + cp, err := currency.NewPairFromString("eth/btc") + if err != nil { + t.Error(err) + } + _, err = ok.ChangePositionMargin(contextGenerate(), &margin.PositionChangeRequest{ + Pair: cp, + Asset: asset.Margin, + MarginType: margin.Isolated, + OriginalAllocatedMargin: 4.0695, + NewAllocatedMargin: 5, + }) + if err != nil { + t.Error(err) + } +} + +func TestGetCollateralMode(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) + _, err := ok.GetCollateralMode(contextGenerate(), asset.Spot) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } + _, err = ok.GetCollateralMode(contextGenerate(), asset.Futures) + if !errors.Is(err, nil) { + t.Errorf("received '%v', expected '%v'", err, nil) + } + _, err = ok.GetCollateralMode(contextGenerate(), asset.USDTMarginedFutures) + if !errors.Is(err, asset.ErrNotSupported) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } +} + +func TestSetCollateralMode(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) + err := ok.SetCollateralMode(contextGenerate(), asset.Spot, collateral.SingleMode) + if !errors.Is(err, common.ErrFunctionNotSupported) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } +} + +func TestGetPositionSummary(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) + pp, err := ok.CurrencyPairs.GetPairs(asset.PerpetualSwap, true) + if err != nil { + t.Error(err) + } + _, err = ok.GetFuturesPositionSummary(contextGenerate(), &order.PositionSummaryRequest{ + Asset: asset.PerpetualSwap, + Pair: pp[0], + UnderlyingPair: currency.EMPTYPAIR, + }) + if err != nil { + t.Error(err) + } + + pp, err = ok.CurrencyPairs.GetPairs(asset.Futures, true) + if err != nil { + t.Error(err) + } + _, err = ok.GetFuturesPositionSummary(contextGenerate(), &order.PositionSummaryRequest{ + Asset: asset.Futures, + Pair: pp[0], + UnderlyingPair: currency.EMPTYPAIR, + }) + if err != nil { + t.Error(err) + } + + _, err = ok.GetFuturesPositionSummary(contextGenerate(), &order.PositionSummaryRequest{ + Asset: asset.Spot, + Pair: pp[0], + UnderlyingPair: currency.NewBTCUSDT(), + }) + if !errors.Is(err, order.ErrNotFuturesAsset) { + t.Errorf("received '%v', expected '%v'", err, order.ErrNotFuturesAsset) + } +} + +func TestGetFuturesPositions(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) + pp, err := ok.CurrencyPairs.GetPairs(asset.Futures, true) + if err != nil { + t.Error(err) + } + _, err = ok.GetFuturesPositionOrders(contextGenerate(), &order.PositionsRequest{ + Asset: asset.Futures, + Pairs: []currency.Pair{pp[0]}, + StartDate: time.Now().Add(time.Hour * 24 * -7), + }) + if err != nil { + t.Error(err) + } + + _, err = ok.GetFuturesPositionOrders(contextGenerate(), &order.PositionsRequest{ + Asset: asset.Spot, + Pairs: []currency.Pair{pp[0]}, + StartDate: time.Now().Add(time.Hour * 24 * -7), + }) + if !errors.Is(err, order.ErrNotFuturesAsset) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } +} + +func TestGetLeverage(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, ok) + pp, err := ok.CurrencyPairs.GetPairs(asset.Futures, true) + if err != nil { + t.Error(err) + } + _, err = ok.GetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Multi, order.UnknownSide) + if err != nil { + t.Error(err) + } + + _, err = ok.GetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Isolated, order.UnknownSide) + if !errors.Is(err, errOrderSideRequired) { + t.Errorf("received '%v', expected '%v'", err, errOrderSideRequired) + } + + _, err = ok.GetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Isolated, order.Long) + if err != nil { + t.Error(err) + } + + _, err = ok.GetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Isolated, order.Short) + if err != nil { + t.Error(err) + } + + _, err = ok.GetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Isolated, order.CouldNotBuy) + if !errors.Is(err, errInvalidOrderSide) { + t.Errorf("received '%v', expected '%v'", err, errInvalidOrderSide) + } +} + +func TestSetLeverage(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, ok, canManipulateRealOrders) + pp, err := ok.CurrencyPairs.GetPairs(asset.Futures, true) + if err != nil { + t.Error(err) + } + err = ok.SetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Multi, 5, order.UnknownSide) + if err != nil { + t.Error(err) + } + + err = ok.SetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Isolated, 5, order.UnknownSide) + if !errors.Is(err, errOrderSideRequired) { + t.Errorf("received '%v', expected '%v'", err, errOrderSideRequired) + } + + err = ok.SetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Isolated, 5, order.Long) + if err != nil { + t.Error(err) + } + + err = ok.SetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Isolated, 5, order.Short) + if err != nil { + t.Error(err) + } + + err = ok.SetLeverage(contextGenerate(), asset.Futures, pp[0], margin.Isolated, 5, order.CouldNotBuy) + if !errors.Is(err, errInvalidOrderSide) { + t.Errorf("received '%v', expected '%v'", err, errInvalidOrderSide) + } + + err = ok.SetLeverage(contextGenerate(), asset.Spot, pp[0], margin.Multi, 5, order.UnknownSide) + if !errors.Is(err, asset.ErrNotSupported) { + t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported) + } +} diff --git a/exchanges/okx/okx_types.go b/exchanges/okx/okx_types.go index 263abfa0ee8..039c3d366e9 100644 --- a/exchanges/okx/okx_types.go +++ b/exchanges/okx/okx_types.go @@ -1237,72 +1237,72 @@ type Account struct { // AccountDetail account detail information. type AccountDetail struct { - AvailableBalance okxNumericalValue `json:"availBal"` - AvailableEquity okxNumericalValue `json:"availEq"` - CashBalance okxNumericalValue `json:"cashBal"` // Cash Balance - Currency string `json:"ccy"` - CrossLiab okxNumericalValue `json:"crossLiab"` - DiscountEquity okxNumericalValue `json:"disEq"` - EquityOfCurrency okxNumericalValue `json:"eq"` - EquityUsd okxNumericalValue `json:"eqUsd"` - FrozenBalance okxNumericalValue `json:"frozenBal"` - Interest okxNumericalValue `json:"interest"` - IsoEquity okxNumericalValue `json:"isoEq"` - IsolatedLiabilities okxNumericalValue `json:"isoLiab"` - IsoUpl okxNumericalValue `json:"isoUpl"` // Isolated unrealized profit and loss of the currency applicable to Single-currency margin and Multi-currency margin and Portfolio margin - LiabilitiesOfCurrency okxNumericalValue `json:"liab"` - MaxLoan okxNumericalValue `json:"maxLoan"` - MarginRatio okxNumericalValue `json:"mgnRatio"` // Equity of the currency - NotionalLever okxNumericalValue `json:"notionalLever"` // Leverage of the currency applicable to Single-currency margin - OpenOrdersMarginFrozen okxNumericalValue `json:"ordFrozen"` - Twap okxNumericalValue `json:"twap"` - UpdateTime okxUnixMilliTime `json:"uTime"` - UnrealizedProfit okxNumericalValue `json:"upl"` - UnrealizedCurrencyLiabilities okxNumericalValue `json:"uplLiab"` - StrategyEquity okxNumericalValue `json:"stgyEq"` // strategy equity - TotalEquity okxNumericalValue `json:"totalEq"` // Total equity in USD level + AvailableBalance convert.StringToFloat64 `json:"availBal"` + AvailableEquity convert.StringToFloat64 `json:"availEq"` + CashBalance convert.StringToFloat64 `json:"cashBal"` // Cash Balance + Currency string `json:"ccy"` + CrossLiab convert.StringToFloat64 `json:"crossLiab"` + DiscountEquity convert.StringToFloat64 `json:"disEq"` + EquityOfCurrency convert.StringToFloat64 `json:"eq"` + EquityUsd convert.StringToFloat64 `json:"eqUsd"` + FrozenBalance convert.StringToFloat64 `json:"frozenBal"` + Interest convert.StringToFloat64 `json:"interest"` + IsoEquity convert.StringToFloat64 `json:"isoEq"` + IsolatedLiabilities convert.StringToFloat64 `json:"isoLiab"` + IsoUpl convert.StringToFloat64 `json:"isoUpl"` // Isolated unrealized profit and loss of the currency applicable to Single-currency margin and Multi-currency margin and Portfolio margin + LiabilitiesOfCurrency convert.StringToFloat64 `json:"liab"` + MaxLoan convert.StringToFloat64 `json:"maxLoan"` + MarginRatio convert.StringToFloat64 `json:"mgnRatio"` // Equity of the currency + NotionalLever convert.StringToFloat64 `json:"notionalLever"` // Leverage of the currency applicable to Single-currency margin + OpenOrdersMarginFrozen convert.StringToFloat64 `json:"ordFrozen"` + Twap convert.StringToFloat64 `json:"twap"` + UpdateTime okxUnixMilliTime `json:"uTime"` + UnrealizedProfit convert.StringToFloat64 `json:"upl"` + UnrealizedCurrencyLiabilities convert.StringToFloat64 `json:"uplLiab"` + StrategyEquity convert.StringToFloat64 `json:"stgyEq"` // strategy equity + TotalEquity convert.StringToFloat64 `json:"totalEq"` // Total equity in USD level. Appears unused } // AccountPosition account position. type AccountPosition struct { - AutoDeleveraging string `json:"adl"` // Auto-deleveraging (ADL) indicator Divided into 5 levels, from 1 to 5, the smaller the number, the weaker the adl intensity. - AvailablePosition string `json:"availPos"` // Position that can be closed Only applicable to MARGIN, FUTURES/SWAP in the long-short mode, OPTION in Simple and isolated OPTION in margin Account. - AveragePrice string `json:"avgPx"` - CreationTime okxUnixMilliTime `json:"cTime"` - Currency string `json:"ccy"` - DeltaBS string `json:"deltaBS"` // delta：Black-Scholes Greeks in dollars,only applicable to OPTION - DeltaPA string `json:"deltaPA"` // delta：Greeks in coins,only applicable to OPTION - GammaBS string `json:"gammaBS"` // gamma：Black-Scholes Greeks in dollars,only applicable to OPTION - GammaPA string `json:"gammaPA"` // gamma：Greeks in coins,only applicable to OPTION - InitialMarginRequirement string `json:"imr"` // Initial margin requirement, only applicable to cross. - InstrumentID string `json:"instId"` - InstrumentType string `json:"instType"` - Interest string `json:"interest"` - USDPrice string `json:"usdPx"` - LastTradePrice string `json:"last"` - Leverage string `json:"lever"` // Leverage, not applicable to OPTION seller - Liabilities string `json:"liab"` // Liabilities, only applicable to MARGIN. - LiabilitiesCurrency string `json:"liabCcy"` // Liabilities currency, only applicable to MARGIN. - LiquidationPrice string `json:"liqPx"` // Estimated liquidation price Not applicable to OPTION - MarkPx string `json:"markPx"` - Margin string `json:"margin"` - MgnMode string `json:"mgnMode"` - MgnRatio string `json:"mgnRatio"` - MaintenanceMarginRequirement string `json:"mmr"` // Maintenance margin requirement in USD level Applicable to Multi-currency margin and Portfolio margin - NotionalUsd string `json:"notionalUsd"` // Quality of Positions -- usd - OptionValue string `json:"optVal"` // Option Value, only application to position. - QuantityOfPosition string `json:"pos"` // Quantity of positions,In the mode of autonomous transfer from position to position, after the deposit is transferred, a position with pos of 0 will be generated - PositionCurrency string `json:"posCcy"` - PositionID string `json:"posId"` - PositionSide string `json:"posSide"` - ThetaBS string `json:"thetaBS"` // theta：Black-Scholes Greeks in dollars,only applicable to OPTION - ThetaPA string `json:"thetaPA"` // theta：Greeks in coins,only applicable to OPTION - TradeID string `json:"tradeId"` - UpdatedTime okxUnixMilliTime `json:"uTime"` // Latest time position was adjusted, - Upl float64 `json:"upl,string,omitempty"` // Unrealized profit and loss - UPLRatio float64 `json:"uplRatio,string,omitempty"` // Unrealized profit and loss ratio - VegaBS string `json:"vegaBS"` // vega：Black-Scholes Greeks in dollars,only applicable to OPTION - VegaPA string `json:"vegaPA"` // vega：Greeks in coins,only applicable to OPTION + AutoDeleveraging string `json:"adl"` // Auto-deleveraging (ADL) indicator Divided into 5 levels, from 1 to 5, the smaller the number, the weaker the adl intensity. + AvailablePosition string `json:"availPos"` // Position that can be closed Only applicable to MARGIN, FUTURES/SWAP in the long-short mode, OPTION in Simple and isolated OPTION in margin Account. + AveragePrice convert.StringToFloat64 `json:"avgPx"` + CreationTime okxUnixMilliTime `json:"cTime"` + Currency string `json:"ccy"` + DeltaBS string `json:"deltaBS"` // delta：Black-Scholes Greeks in dollars,only applicable to OPTION + DeltaPA string `json:"deltaPA"` // delta：Greeks in coins,only applicable to OPTION + GammaBS string `json:"gammaBS"` // gamma：Black-Scholes Greeks in dollars,only applicable to OPTION + GammaPA string `json:"gammaPA"` // gamma：Greeks in coins,only applicable to OPTION + InitialMarginRequirement convert.StringToFloat64 `json:"imr"` // Initial margin requirement, only applicable to cross. + InstrumentID string `json:"instId"` + InstrumentType asset.Item `json:"instType"` + Interest convert.StringToFloat64 `json:"interest"` + USDPrice convert.StringToFloat64 `json:"usdPx"` + LastTradePrice convert.StringToFloat64 `json:"last"` + Leverage convert.StringToFloat64 `json:"lever"` // Leverage, not applicable to OPTION seller + Liabilities string `json:"liab"` // Liabilities, only applicable to MARGIN. + LiabilitiesCurrency string `json:"liabCcy"` // Liabilities currency, only applicable to MARGIN. + LiquidationPrice convert.StringToFloat64 `json:"liqPx"` // Estimated liquidation price Not applicable to OPTION + MarkPrice convert.StringToFloat64 `json:"markPx"` + Margin convert.StringToFloat64 `json:"margin"` + MarginMode string `json:"mgnMode"` + MarginRatio convert.StringToFloat64 `json:"mgnRatio"` + MaintenanceMarginRequirement convert.StringToFloat64 `json:"mmr"` // Maintenance margin requirement in USD level Applicable to Multi-currency margin and Portfolio margin + NotionalUsd convert.StringToFloat64 `json:"notionalUsd"` // Quality of Positions -- usd + OptionValue convert.StringToFloat64 `json:"optVal"` // Option Value, only application to position. + QuantityOfPosition convert.StringToFloat64 `json:"pos"` // Quantity of positions,In the mode of autonomous transfer from position to position, after the deposit is transferred, a position with pos of 0 will be generated + PositionCurrency string `json:"posCcy"` + PositionID string `json:"posId"` + PositionSide string `json:"posSide"` + ThetaBS string `json:"thetaBS"` // theta：Black-Scholes Greeks in dollars,only applicable to OPTION + ThetaPA string `json:"thetaPA"` // theta：Greeks in coins,only applicable to OPTION + TradeID string `json:"tradeId"` + UpdatedTime okxUnixMilliTime `json:"uTime"` // Latest time position was adjusted, + UPNL convert.StringToFloat64 `json:"upl"` // Unrealized profit and loss + UPLRatio convert.StringToFloat64 `json:"uplRatio"` // Unrealized profit and loss ratio + VegaBS string `json:"vegaBS"` // vega：Black-Scholes Greeks in dollars,only applicable to OPTION + VegaPA string `json:"vegaPA"` // vega：Greeks in coins,only applicable to OPTION // PushTime added feature in the websocket push data. @@ -1421,19 +1421,19 @@ type PositionMode struct { // SetLeverageInput represents set leverage request input type SetLeverageInput struct { - Leverage int `json:"lever,string"` // set leverage for isolated - MarginMode string `json:"mgnMode"` // Margin Mode "cross" and "isolated" - InstrumentID string `json:"instId,omitempty"` // Optional: - Currency string `json:"ccy,omitempty"` // Optional: - PositionSide string `json:"posSide,omitempty"` + Leverage float64 `json:"lever,string"` // set leverage for isolated + MarginMode string `json:"mgnMode"` // Margin Mode "cross" and "isolated" + InstrumentID string `json:"instId,omitempty"` // Optional: + Currency string `json:"ccy,omitempty"` // Optional: + PositionSide string `json:"posSide,omitempty"` } // SetLeverageResponse represents set leverage response type SetLeverageResponse struct { - Leverage string `json:"lever"` - MarginMode string `json:"mgnMode"` // Margin Mode "cross" and "isolated" - InstrumentID string `json:"instId"` - PositionSide string `json:"posSide"` // "long", "short", and "net" + Leverage okxNumericalValue `json:"lever"` + MarginMode string `json:"mgnMode"` // Margin Mode "cross" and "isolated" + InstrumentID string `json:"instId"` + PositionSide string `json:"posSide"` // "long", "short", and "net" } // MaximumBuyAndSell get maximum buy , sell amount or open amount @@ -1464,20 +1464,20 @@ type IncreaseDecreaseMarginInput struct { // IncreaseDecreaseMargin represents increase or decrease the margin of the isolated position response type IncreaseDecreaseMargin struct { - Amt string `json:"amt"` - Ccy string `json:"ccy"` - InstrumentID string `json:"instId"` - Leverage string `json:"leverage"` - PosSide string `json:"posSide"` - Type string `json:"type"` + Amount okxNumericalValue `json:"amt"` + Ccy string `json:"ccy"` + InstrumentID string `json:"instId"` + Leverage okxNumericalValue `json:"leverage"` + PosSide string `json:"posSide"` + Type string `json:"type"` } // LeverageResponse instrument id leverage response. type LeverageResponse struct { - InstrumentID string `json:"instId"` - MarginMode string `json:"mgnMode"` - PositionSide string `json:"posSide"` - Leverage uint `json:"lever,string"` + InstrumentID string `json:"instId"` + MarginMode string `json:"mgnMode"` + PositionSide string `json:"posSide"` + Leverage okxNumericalValue `json:"lever"` } // MaximumLoanInstrument represents maximum loan of an instrument id. diff --git a/exchanges/okx/okx_wrapper.go b/exchanges/okx/okx_wrapper.go index 4fcece018e3..c0f06545839 100644 --- a/exchanges/okx/okx_wrapper.go +++ b/exchanges/okx/okx_wrapper.go @@ -11,15 +11,18 @@ import ( "sync" "time" + "github.com/shopspring/decimal" "github.com/thrasher-corp/gocryptotrader/common" "github.com/thrasher-corp/gocryptotrader/config" "github.com/thrasher-corp/gocryptotrader/currency" exchange "github.com/thrasher-corp/gocryptotrader/exchanges" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/deposit" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/exchanges/orderbook" "github.com/thrasher-corp/gocryptotrader/exchanges/protocol" @@ -68,11 +71,13 @@ func (ok *Okx) SetDefaults() { ok.API.CredentialsValidator.RequiresKey = true ok.API.CredentialsValidator.RequiresSecret = true ok.API.CredentialsValidator.RequiresClientID = true - pairFormat := ¤cy.PairFormat{ + + cpf := ¤cy.PairFormat{ Delimiter: currency.DashDelimiter, Uppercase: true, } - err := ok.SetGlobalPairsManager(pairFormat, pairFormat, asset.Spot, asset.Futures, asset.PerpetualSwap, asset.Options, asset.Margin) + + err := ok.SetGlobalPairsManager(cpf, cpf, asset.Spot, asset.Futures, asset.PerpetualSwap, asset.Options, asset.Margin) if err != nil { log.Errorln(log.ExchangeSys, err) } @@ -80,8 +85,9 @@ func (ok *Okx) SetDefaults() { // Fill out the capabilities/features that the exchange supports ok.Features = exchange.Features{ Supports: exchange.FeaturesSupported{ - REST: true, - Websocket: true, + REST: true, + Websocket: true, + MaximumOrderHistory: kline.OneDay.Duration() * 90, RESTCapabilities: protocol.Features{ TickerFetching: true, OrderbookFetching: true, @@ -123,6 +129,9 @@ func (ok *Okx) SetDefaults() { }, WithdrawPermissions: exchange.AutoWithdrawCrypto, FuturesCapabilities: exchange.FuturesCapabilities{ + Positions: true, + Leverage: true, + CollateralMode: true, FundingRates: true, MaximumFundingRateHistory: kline.ThreeMonth.Duration(), FundingRateFrequency: kline.EightHour.Duration(), @@ -360,14 +369,14 @@ func (ok *Okx) UpdateOrderExecutionLimits(ctx context.Context, a asset.Item) err // UpdateTicker updates and returns the ticker for a currency pair func (ok *Okx) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) { - format, err := ok.GetPairFormat(a, false) + pairFormat, err := ok.GetPairFormat(a, true) if err != nil { return nil, err } if p.IsEmpty() { return nil, currency.ErrCurrencyPairEmpty } - instrumentID := format.Format(p) + instrumentID := pairFormat.Format(p) if !ok.SupportsAsset(a) { return nil, fmt.Errorf("%w: %v", asset.ErrNotSupported, a) } @@ -502,14 +511,14 @@ func (ok *Okx) UpdateOrderbook(ctx context.Context, pair currency.Pair, assetTyp return nil, err } var instrumentID string - format, err := ok.GetPairFormat(assetType, false) + pairFormat, err := ok.GetPairFormat(assetType, true) if err != nil { return nil, err } if !pair.IsPopulated() { return nil, errIncompleteCurrencyPair } - instrumentID = format.Format(pair) + instrumentID = pairFormat.Format(pair) orderbookNew, err = ok.GetOrderBookDepth(ctx, instrumentID, 400) if err != nil { return book, err @@ -552,7 +561,7 @@ func (ok *Okx) UpdateAccountInfo(ctx context.Context, assetType asset.Item) (acc if !ok.SupportsAsset(assetType) { return info, fmt.Errorf("%w: %v", asset.ErrNotSupported, assetType) } - accountBalances, err := ok.GetNonZeroBalances(ctx, "") + accountBalances, err := ok.AccountBalance(ctx, "") if err != nil { return info, err } @@ -660,15 +669,14 @@ func (ok *Okx) GetWithdrawalsHistory(ctx context.Context, c currency.Code, _ ass // GetRecentTrades returns the most recent trades for a currency and asset func (ok *Okx) GetRecentTrades(ctx context.Context, p currency.Pair, assetType asset.Item) ([]trade.Data, error) { - format, err := ok.GetPairFormat(assetType, false) + pairFormat, err := ok.GetPairFormat(assetType, true) if err != nil { return nil, err } if p.IsEmpty() { return nil, currency.ErrCurrencyPairEmpty } - - instrumentID := format.Format(p) + instrumentID := pairFormat.Format(p) tradeData, err := ok.GetTrades(ctx, instrumentID, 1000) if err != nil { return nil, err @@ -708,7 +716,7 @@ func (ok *Okx) GetHistoricTrades(ctx context.Context, p currency.Pair, assetType return nil, errOnlyThreeMonthsSupported } const limit = 100 - format, err := ok.GetPairFormat(assetType, false) + pairFormat, err := ok.GetPairFormat(assetType, true) if err != nil { return nil, err } @@ -716,7 +724,7 @@ func (ok *Okx) GetHistoricTrades(ctx context.Context, p currency.Pair, assetType return nil, currency.ErrCurrencyPairEmpty } var resp []trade.Data - instrumentID := format.Format(p) + instrumentID := pairFormat.Format(p) tradeIDEnd := "" allTrades: for { @@ -774,17 +782,17 @@ func (ok *Okx) SubmitOrder(ctx context.Context, s *order.Submit) (*order.SubmitR if s.Amount <= 0 { return nil, fmt.Errorf("amount, or size (sz) of quantity to buy or sell hast to be greater than zero ") } - format, err := ok.GetPairFormat(s.AssetType, false) + pairFormat, err := ok.GetPairFormat(s.AssetType, true) if err != nil { return nil, err } if s.Pair.IsEmpty() { return nil, currency.ErrCurrencyPairEmpty } - instrumentID := format.Format(s.Pair) - var tradeMode string - if s.AssetType != asset.Margin { - tradeMode = "cash" + instrumentID := pairFormat.Format(s.Pair) + tradeMode := ok.marginTypeToString(s.MarginType) + if s.Leverage != 0 && s.Leverage != 1 { + return nil, fmt.Errorf("%w received '%v'", order.ErrSubmitLeverageNotSupported, s.Leverage) } var sideType string if s.Side.IsLong() { @@ -846,6 +854,17 @@ func (ok *Okx) SubmitOrder(ctx context.Context, s *order.Submit) (*order.SubmitR return s.DeriveSubmitResponse(placeOrderResponse.OrderID) } +func (ok *Okx) marginTypeToString(m margin.Type) string { + switch m { + case margin.Isolated: + return "isolated" + case margin.Multi: + return "cross" + default: + return "cash" + } +} + // ModifyOrder will allow of changing orderbook placement and limit to market conversion func (ok *Okx) ModifyOrder(ctx context.Context, action *order.Modify) (*order.ModifyResponse, error) { if err := action.Validate(); err != nil { @@ -855,14 +874,14 @@ func (ok *Okx) ModifyOrder(ctx context.Context, action *order.Modify) (*order.Mo if math.Trunc(action.Amount) != action.Amount { return nil, errors.New("okx contract amount can not be decimal") } - format, err := ok.GetPairFormat(action.AssetType, false) + pairFormat, err := ok.GetPairFormat(action.AssetType, true) if err != nil { return nil, err } if action.Pair.IsEmpty() { return nil, currency.ErrCurrencyPairEmpty } - instrumentID := format.Format(action.Pair) + instrumentID := pairFormat.Format(action.Pair) if err != nil { return nil, err } @@ -891,14 +910,14 @@ func (ok *Okx) CancelOrder(ctx context.Context, ord *order.Cancel) error { if !ok.SupportsAsset(ord.AssetType) { return fmt.Errorf("%w: %v", asset.ErrNotSupported, ord.AssetType) } - format, err := ok.GetPairFormat(ord.AssetType, false) + pairFormat, err := ok.GetPairFormat(ord.AssetType, true) if err != nil { return err } if ord.Pair.IsEmpty() { return currency.ErrCurrencyPairEmpty } - instrumentID := format.Format(ord.Pair) + instrumentID := pairFormat.Format(ord.Pair) req := CancelOrderRequestParam{ InstrumentID: instrumentID, OrderID: ord.OrderID, @@ -921,7 +940,6 @@ func (ok *Okx) CancelBatchOrders(ctx context.Context, o []order.Cancel) (*order. } cancelOrderParams := make([]CancelOrderRequestParam, len(o)) var err error - var format currency.PairFormat for x := range o { ord := o[x] err = ord.Validate(ord.StandardCancel()) @@ -931,16 +949,17 @@ func (ok *Okx) CancelBatchOrders(ctx context.Context, o []order.Cancel) (*order. if !ok.SupportsAsset(ord.AssetType) { return nil, fmt.Errorf("%w: %v", asset.ErrNotSupported, ord.AssetType) } - format, err = ok.GetPairFormat(ord.AssetType, true) var instrumentID string + var pairFormat currency.PairFormat + pairFormat, err = ok.GetPairFormat(ord.AssetType, true) if err != nil { return nil, err } if !ord.Pair.IsPopulated() { return nil, errIncompleteCurrencyPair } - instrumentID = format.Format(ord.Pair) + instrumentID = pairFormat.Format(ord.Pair) if err != nil { return nil, err } @@ -1078,12 +1097,17 @@ func (ok *Okx) GetOrderInfo(ctx context.Context, orderID string, pair currency.P return nil, err } - format, err := ok.GetPairFormat(assetType, false) + pairFormat, err := ok.GetPairFormat(assetType, false) if err != nil { return nil, err } - - instrumentID := format.Format(pair) + if !pair.IsPopulated() { + return nil, errIncompleteCurrencyPair + } + instrumentID := pairFormat.Format(pair) + if !ok.SupportsAsset(assetType) { + return nil, fmt.Errorf("%w: %v", asset.ErrNotSupported, assetType) + } orderDetail, err := ok.GetOrderDetail(ctx, &OrderDetailRequestParam{ InstrumentID: instrumentID, OrderID: orderID, @@ -1712,3 +1736,386 @@ func (ok *Okx) GetFundingRates(ctx context.Context, r *fundingrate.RatesRequest) func (ok *Okx) IsPerpetualFutureCurrency(a asset.Item, _ currency.Pair) (bool, error) { return a == asset.PerpetualSwap, nil } + +// SetMarginType sets the default margin type for when opening a new position +// okx allows this to be set with an order, however this sets a default +func (ok *Okx) SetMarginType(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type) error { + return fmt.Errorf("%w margin type is set per order", common.ErrFunctionNotSupported) +} + +// SetCollateralMode sets the collateral type for your account +func (ok *Okx) SetCollateralMode(_ context.Context, _ asset.Item, _ collateral.Mode) error { + return fmt.Errorf("%w must be set via website", common.ErrFunctionNotSupported) +} + +// GetCollateralMode returns the collateral type for your account +func (ok *Okx) GetCollateralMode(ctx context.Context, item asset.Item) (collateral.Mode, error) { + if !ok.SupportsAsset(item) { + return 0, fmt.Errorf("%w: %v", asset.ErrNotSupported, item) + } + cfg, err := ok.GetAccountConfiguration(ctx) + if err != nil { + return 0, err + } + switch cfg[0].AccountLevel { + case 1: + if item != asset.Spot { + return 0, fmt.Errorf("%w %v", asset.ErrNotSupported, item) + } + fallthrough + case 2: + return collateral.SingleMode, nil + case 3: + return collateral.MultiMode, nil + case 4: + return collateral.PortfolioMode, nil + default: + return collateral.UnknownMode, fmt.Errorf("%w %v", order.ErrCollateralInvalid, cfg[0].AccountLevel) + } +} + +// ChangePositionMargin will modify a position/currencies margin parameters +func (ok *Okx) ChangePositionMargin(ctx context.Context, req *margin.PositionChangeRequest) (*margin.PositionChangeResponse, error) { + if req == nil { + return nil, fmt.Errorf("%w PositionChangeRequest", common.ErrNilPointer) + } + if !ok.SupportsAsset(req.Asset) { + return nil, fmt.Errorf("%w: %v", asset.ErrNotSupported, req.Asset) + } + if req.NewAllocatedMargin == 0 { + return nil, fmt.Errorf("%w %v %v", margin.ErrNewAllocatedMarginRequired, req.Asset, req.Pair) + } + if req.OriginalAllocatedMargin == 0 { + return nil, margin.ErrOriginalPositionMarginRequired + } + if req.MarginType != margin.Isolated { + return nil, fmt.Errorf("%w %v", margin.ErrMarginTypeUnsupported, req.MarginType) + } + pairFormat, err := ok.GetPairFormat(req.Asset, true) + if err != nil { + return nil, err + } + fPair := req.Pair.Format(pairFormat) + marginType := "add" + amt := req.NewAllocatedMargin - req.OriginalAllocatedMargin + if req.NewAllocatedMargin < req.OriginalAllocatedMargin { + marginType = "reduce" + amt = req.OriginalAllocatedMargin - req.NewAllocatedMargin + } + if req.MarginSide == "" { + req.MarginSide = "net" + } + r := IncreaseDecreaseMarginInput{ + InstrumentID: fPair.String(), + PositionSide: req.MarginSide, + Type: marginType, + Amount: amt, + } + + if req.Asset == asset.Margin { + r.Currency = req.Pair.Base.Item.Symbol + } + + resp, err := ok.IncreaseDecreaseMargin(ctx, r) + if err != nil { + return nil, err + } + + return &margin.PositionChangeResponse{ + Exchange: ok.Name, + Pair: req.Pair, + Asset: req.Asset, + AllocatedMargin: resp.Amount.Float64(), + MarginType: req.MarginType, + }, nil +} + +// GetFuturesPositionSummary returns position summary details for an active position +func (ok *Okx) GetFuturesPositionSummary(ctx context.Context, req *order.PositionSummaryRequest) (*order.PositionSummary, error) { + if req == nil { + return nil, fmt.Errorf("%w PositionSummaryRequest", common.ErrNilPointer) + } + if req.CalculateOffline { + return nil, common.ErrCannotCalculateOffline + } + if !ok.SupportsAsset(req.Asset) || !req.Asset.IsFutures() { + return nil, fmt.Errorf("%w %v", asset.ErrNotSupported, req.Asset) + } + fPair, err := ok.FormatExchangeCurrency(req.Pair, req.Asset) + if err != nil { + return nil, err + } + instrumentType := ok.GetInstrumentTypeFromAssetItem(req.Asset) + positionSummaries, err := ok.GetPositions(ctx, instrumentType, fPair.String(), "") + if err != nil { + return nil, err + } + var positionSummary *AccountPosition + for i := range positionSummaries { + if positionSummaries[i].QuantityOfPosition.Float64() <= 0 { + continue + } + positionSummary = &positionSummaries[i] + break + } + if positionSummary == nil { + return nil, fmt.Errorf("%w, received '%v', no positions found", errOnlyOneResponseExpected, len(positionSummaries)) + } + marginMode := margin.Isolated + if positionSummary.MarginMode == "cross" { + marginMode = margin.Multi + } + + acc, err := ok.AccountBalance(ctx, "") + if err != nil { + return nil, err + } + if len(acc) != 1 { + return nil, fmt.Errorf("%w, received '%v'", errOnlyOneResponseExpected, len(acc)) + } + var ( + freeCollateral, totalCollateral, equityOfCurrency, frozenBalance, + availableEquity, cashBalance, discountEquity, + equityUSD, totalEquity, isolatedEquity, isolatedLiabilities, + isolatedUnrealisedProfit, notionalLeverage, + strategyEquity decimal.Decimal + ) + + for i := range acc[0].Details { + if acc[0].Details[i].Currency != positionSummary.Currency { + continue + } + freeCollateral = acc[0].Details[i].AvailableBalance.Decimal() + frozenBalance = acc[0].Details[i].FrozenBalance.Decimal() + totalCollateral = freeCollateral.Add(frozenBalance) + equityOfCurrency = acc[0].Details[i].EquityOfCurrency.Decimal() + availableEquity = acc[0].Details[i].AvailableEquity.Decimal() + cashBalance = acc[0].Details[i].CashBalance.Decimal() + discountEquity = acc[0].Details[i].DiscountEquity.Decimal() + equityUSD = acc[0].Details[i].EquityUsd.Decimal() + totalEquity = acc[0].Details[i].TotalEquity.Decimal() + isolatedEquity = acc[0].Details[i].IsoEquity.Decimal() + isolatedLiabilities = acc[0].Details[i].IsolatedLiabilities.Decimal() + isolatedUnrealisedProfit = acc[0].Details[i].IsoUpl.Decimal() + notionalLeverage = acc[0].Details[i].NotionalLever.Decimal() + strategyEquity = acc[0].Details[i].StrategyEquity.Decimal() + + break + } + collateralMode, err := ok.GetCollateralMode(ctx, req.Asset) + if err != nil { + return nil, err + } + return &order.PositionSummary{ + Pair: req.Pair, + Asset: req.Asset, + MarginType: marginMode, + CollateralMode: collateralMode, + Currency: currency.NewCode(positionSummary.Currency), + AvailableEquity: availableEquity, + CashBalance: cashBalance, + DiscountEquity: discountEquity, + EquityUSD: equityUSD, + IsolatedEquity: isolatedEquity, + IsolatedLiabilities: isolatedLiabilities, + IsolatedUPL: isolatedUnrealisedProfit, + NotionalLeverage: notionalLeverage, + TotalEquity: totalEquity, + StrategyEquity: strategyEquity, + IsolatedMargin: positionSummary.Margin.Decimal(), + NotionalSize: positionSummary.NotionalUsd.Decimal(), + Leverage: positionSummary.Leverage.Decimal(), + MaintenanceMarginRequirement: positionSummary.MaintenanceMarginRequirement.Decimal(), + InitialMarginRequirement: positionSummary.InitialMarginRequirement.Decimal(), + EstimatedLiquidationPrice: positionSummary.LiquidationPrice.Decimal(), + CollateralUsed: positionSummary.Margin.Decimal(), + MarkPrice: positionSummary.MarkPrice.Decimal(), + CurrentSize: positionSummary.QuantityOfPosition.Decimal(), // TODO: add field(s) for contract amount vs quote amount + AverageOpenPrice: positionSummary.AveragePrice.Decimal(), + PositionPNL: positionSummary.UPNL.Decimal(), + MaintenanceMarginFraction: positionSummary.MarginRatio.Decimal(), + FreeCollateral: freeCollateral, + TotalCollateral: totalCollateral, + FrozenBalance: frozenBalance, + EquityOfCurrency: equityOfCurrency, + }, nil +} + +// GetFuturesPositionOrders returns the orders for futures positions +func (ok *Okx) GetFuturesPositionOrders(ctx context.Context, req *order.PositionsRequest) ([]order.PositionResponse, error) { + if req == nil { + return nil, fmt.Errorf("%w PositionSummaryRequest", common.ErrNilPointer) + } + if !ok.SupportsAsset(req.Asset) || !req.Asset.IsFutures() { + return nil, fmt.Errorf("%w %v", asset.ErrNotSupported, req.Asset) + } + if time.Since(req.StartDate) > ok.Features.Supports.MaximumOrderHistory { + if req.RespectOrderHistoryLimits { + req.StartDate = time.Now().Add(-ok.Features.Supports.MaximumOrderHistory) + } else { + return nil, fmt.Errorf("%w max lookup %v", order.ErrOrderHistoryTooLarge, time.Now().Add(-ok.Features.Supports.MaximumOrderHistory)) + } + } + if err := common.StartEndTimeCheck(req.StartDate, req.EndDate); err != nil { + return nil, err + } + resp := make([]order.PositionResponse, len(req.Pairs)) + for i := range req.Pairs { + fPair, err := ok.FormatExchangeCurrency(req.Pairs[i], req.Asset) + if err != nil { + return nil, err + } + instrumentType := ok.GetInstrumentTypeFromAssetItem(req.Asset) + resp[i] = order.PositionResponse{ + Pair: req.Pairs[i], + Asset: req.Asset, + } + + var positions []OrderDetail + historyRequest := &OrderHistoryRequestParams{ + OrderListRequestParams: OrderListRequestParams{ + InstrumentType: instrumentType, + InstrumentID: fPair.String(), + Start: req.StartDate, + End: req.EndDate, + }, + } + if time.Since(req.StartDate) <= time.Hour*24*7 { + positions, err = ok.Get7DayOrderHistory(ctx, historyRequest) + } else { + positions, err = ok.Get3MonthOrderHistory(ctx, historyRequest) + } + if err != nil { + return nil, err + } + for j := range positions { + if req.Pairs[i].String() != positions[j].InstrumentID { + continue + } + var orderStatus order.Status + orderStatus, err = order.StringToOrderStatus(strings.ToUpper(positions[j].State)) + if err != nil { + log.Errorf(log.ExchangeSys, "%s %v", ok.Name, err) + } + orderSide := positions[j].Side + var oType order.Type + oType, err = ok.OrderTypeFromString(positions[j].OrderType) + if err != nil { + return nil, err + } + orderAmount := positions[j].Size + if positions[j].QuantityType == "quote_ccy" { + // Size is quote amount. + orderAmount /= positions[j].AveragePrice + } + + remainingAmount := float64(0) + if orderStatus != order.Filled { + remainingAmount = orderAmount.Float64() - positions[j].AccumulatedFillSize.Float64() + } + resp[i].Orders = append(resp[i].Orders, order.Detail{ + Price: positions[j].Price.Float64(), + AverageExecutedPrice: positions[j].AveragePrice.Float64(), + Amount: orderAmount.Float64(), // TODO: add field(s) for contract amount vs quote amount + ExecutedAmount: positions[j].AccumulatedFillSize.Float64(), + RemainingAmount: remainingAmount, + Fee: positions[j].TransactionFee.Float64(), + FeeAsset: currency.NewCode(positions[j].FeeCurrency), + Exchange: ok.Name, + OrderID: positions[j].OrderID, + ClientOrderID: positions[j].ClientSupplierOrderID, + Type: oType, + Side: orderSide, + Status: orderStatus, + AssetType: req.Asset, + Date: positions[j].CreationTime, + LastUpdated: positions[j].UpdateTime, + Pair: req.Pairs[i], + Cost: positions[j].AveragePrice.Float64() * positions[j].AccumulatedFillSize.Float64(), + CostAsset: currency.NewCode(positions[j].RebateCurrency), + }) + } + } + return resp, nil +} + +// SetLeverage sets the account's initial leverage for the asset type and pair +func (ok *Okx) SetLeverage(ctx context.Context, item asset.Item, pair currency.Pair, marginType margin.Type, amount float64, orderSide order.Side) error { + posSide := "net" + switch item { + case asset.Futures, asset.PerpetualSwap: + if marginType == margin.Isolated { + switch { + case orderSide == order.UnknownSide: + return errOrderSideRequired + case orderSide.IsLong(): + posSide = "long" + case orderSide.IsShort(): + posSide = "short" + default: + return fmt.Errorf("%w %v requires long/short", errInvalidOrderSide, orderSide) + } + } + fallthrough + case asset.Margin, asset.Options: + instrumentID, err := ok.FormatSymbol(pair, item) + if err != nil { + return err + } + + marginMode := ok.marginTypeToString(marginType) + _, err = ok.SetLeverageRate(ctx, SetLeverageInput{ + Leverage: amount, + MarginMode: marginMode, + InstrumentID: instrumentID, + PositionSide: posSide, + }) + return err + default: + return fmt.Errorf("%w %v", asset.ErrNotSupported, item) + } +} + +// GetLeverage gets the account's initial leverage for the asset type and pair +func (ok *Okx) GetLeverage(ctx context.Context, item asset.Item, pair currency.Pair, marginType margin.Type, orderSide order.Side) (float64, error) { + var inspectLeverage bool + switch item { + case asset.Futures, asset.PerpetualSwap: + if marginType == margin.Isolated { + switch { + case orderSide == order.UnknownSide: + return 0, errOrderSideRequired + case orderSide.IsLong(), orderSide.IsShort(): + inspectLeverage = true + default: + return 0, fmt.Errorf("%w %v requires long/short", errInvalidOrderSide, orderSide) + } + } + fallthrough + case asset.Margin, asset.Options: + instrumentID, err := ok.FormatSymbol(pair, item) + if err != nil { + return -1, err + } + marginMode := ok.marginTypeToString(marginType) + lev, err := ok.GetLeverageRate(ctx, instrumentID, marginMode) + if err != nil { + return -1, err + } + if len(lev) == 0 { + return -1, fmt.Errorf("%w %v %v %s", order.ErrPositionNotFound, item, pair, marginType) + } + if inspectLeverage { + for i := range lev { + if lev[i].PositionSide == orderSide.Lower() { + return lev[i].Leverage.Float64(), nil + } + } + } + + // leverage is the same across positions + return lev[0].Leverage.Float64(), nil + default: + return -1, fmt.Errorf("%w %v", asset.ErrNotSupported, item) + } +} diff --git a/exchanges/order/futures_types.go b/exchanges/order/futures_types.go index 6a08ee60783..a0b1f8288e4 100644 --- a/exchanges/order/futures_types.go +++ b/exchanges/order/futures_types.go @@ -9,7 +9,9 @@ import ( "github.com/shopspring/decimal" "github.com/thrasher-corp/gocryptotrader/currency" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/collateral" "github.com/thrasher-corp/gocryptotrader/exchanges/fundingrate" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" ) var ( @@ -35,6 +37,8 @@ var ( ErrNoPositionsFound = errors.New("no positions found") // ErrGetFundingDataRequired is returned when requesting funding rate data without the prerequisite ErrGetFundingDataRequired = errors.New("getfundingdata is a prerequisite") + // ErrOrderHistoryTooLarge is returned when you lookup order history, but with too early a start date + ErrOrderHistoryTooLarge = errors.New("order history start date too long ago") errExchangeNameEmpty = errors.New("exchange name empty") errExchangeNameMismatch = errors.New("exchange name mismatch") @@ -65,57 +69,12 @@ type TotalCollateralResponse struct { TotalValueOfPositiveSpotBalances decimal.Decimal CollateralContributedByPositiveSpotBalances decimal.Decimal UsedCollateral decimal.Decimal - UsedBreakdown *UsedCollateralBreakdown + UsedBreakdown *collateral.UsedBreakdown AvailableCollateral decimal.Decimal AvailableMaintenanceCollateral decimal.Decimal UnrealisedPNL decimal.Decimal - BreakdownByCurrency []CollateralByCurrency - BreakdownOfPositions []CollateralByPosition -} - -// CollateralByPosition shows how much collateral is used -// from positions -type CollateralByPosition struct { - PositionCurrency currency.Pair - Size decimal.Decimal - OpenOrderSize decimal.Decimal - PositionSize decimal.Decimal - MarkPrice decimal.Decimal - RequiredMargin decimal.Decimal - CollateralUsed decimal.Decimal -} - -// CollateralByCurrency individual collateral contribution -// along with what the potentially scaled collateral -// currency it is represented as -// eg in Bybit ScaledCurrency is USDC -type CollateralByCurrency struct { - Currency currency.Code - SkipContribution bool - TotalFunds decimal.Decimal - AvailableForUseAsCollateral decimal.Decimal - CollateralContribution decimal.Decimal - AdditionalCollateralUsed decimal.Decimal - FairMarketValue decimal.Decimal - Weighting decimal.Decimal - ScaledCurrency currency.Code - UnrealisedPNL decimal.Decimal - ScaledUsed decimal.Decimal - ScaledUsedBreakdown *UsedCollateralBreakdown - Error error -} - -// UsedCollateralBreakdown provides a detailed -// breakdown of where collateral is currently being allocated -type UsedCollateralBreakdown struct { - LockedInStakes decimal.Decimal - LockedInNFTBids decimal.Decimal - LockedInFeeVoucher decimal.Decimal - LockedInSpotMarginFundingOffers decimal.Decimal - LockedInSpotOrders decimal.Decimal - LockedAsCollateral decimal.Decimal - UsedInPositions decimal.Decimal - UsedInSpotMarginBorrows decimal.Decimal + BreakdownByCurrency []collateral.ByCurrency + BreakdownOfPositions []collateral.ByPosition } // PositionController manages all futures orders @@ -310,38 +269,27 @@ type Position struct { type PositionSummaryRequest struct { Asset asset.Item Pair currency.Pair + // UnderlyingPair is optional if the exchange requires it for a contract like BTCUSDT-13333337 + UnderlyingPair currency.Pair // offline calculation requirements below CalculateOffline bool - Direction Side FreeCollateral decimal.Decimal TotalCollateral decimal.Decimal - OpeningPrice decimal.Decimal CurrentPrice decimal.Decimal - OpeningSize decimal.Decimal CurrentSize decimal.Decimal CollateralUsed decimal.Decimal NotionalPrice decimal.Decimal - Leverage decimal.Decimal MaxLeverageForAccount decimal.Decimal - TotalAccountValue decimal.Decimal TotalOpenPositionNotional decimal.Decimal -} - -// PositionSummary returns basic details on an open position -type PositionSummary struct { - MaintenanceMarginRequirement decimal.Decimal - InitialMarginRequirement decimal.Decimal - EstimatedLiquidationPrice decimal.Decimal - CollateralUsed decimal.Decimal - MarkPrice decimal.Decimal - CurrentSize decimal.Decimal - BreakEvenPrice decimal.Decimal - AverageOpenPrice decimal.Decimal - RecentPNL decimal.Decimal - MarginFraction decimal.Decimal - FreeCollateral decimal.Decimal - TotalCollateral decimal.Decimal + // EstimatePosition if enabled, can be used to calculate a new position + EstimatePosition bool + // These fields are also used for offline calculation + OpeningPrice decimal.Decimal + OpeningSize decimal.Decimal + Leverage decimal.Decimal + Direction Side + TotalAccountValue decimal.Decimal } // PositionDetails are used to track open positions @@ -359,4 +307,56 @@ type PositionsRequest struct { Asset asset.Item Pairs currency.Pairs StartDate time.Time + EndDate time.Time + // RespectOrderHistoryLimits is designed for the order manager + // it allows for orders to be tracked if the start date in the config is + // beyond the allowable limits by the API, rather than returning an error + RespectOrderHistoryLimits bool +} + +// PositionResponse are used to track open positions +// in the order manager +type PositionResponse struct { + Pair currency.Pair + Asset asset.Item + Orders []Detail +} + +// PositionSummary returns basic details on an open position +type PositionSummary struct { + Pair currency.Pair + Asset asset.Item + MarginType margin.Type + CollateralMode collateral.Mode + // The currency in which the values are quoted against. Isn't always pair.Quote + // eg BTC-USDC-230929's quote in GCT is 230929, but the currency should be USDC + Currency currency.Code + + AvailableEquity decimal.Decimal + CashBalance decimal.Decimal + DiscountEquity decimal.Decimal + EquityUSD decimal.Decimal + IsolatedEquity decimal.Decimal + IsolatedLiabilities decimal.Decimal + IsolatedUPL decimal.Decimal + NotionalLeverage decimal.Decimal + TotalEquity decimal.Decimal + StrategyEquity decimal.Decimal + + IsolatedMargin decimal.Decimal + NotionalSize decimal.Decimal + Leverage decimal.Decimal + MaintenanceMarginRequirement decimal.Decimal + InitialMarginRequirement decimal.Decimal + EstimatedLiquidationPrice decimal.Decimal + CollateralUsed decimal.Decimal + MarkPrice decimal.Decimal + CurrentSize decimal.Decimal + AverageOpenPrice decimal.Decimal + PositionPNL decimal.Decimal + MaintenanceMarginFraction decimal.Decimal + FreeCollateral decimal.Decimal + TotalCollateral decimal.Decimal + FrozenBalance decimal.Decimal + EquityOfCurrency decimal.Decimal } diff --git a/exchanges/order/order_test.go b/exchanges/order/order_test.go index a93475d2004..8c5f1dff421 100644 --- a/exchanges/order/order_test.go +++ b/exchanges/order/order_test.go @@ -820,7 +820,7 @@ func TestStringToOrderSide(t *testing.T) { {"any", AnySide, nil}, {"ANY", AnySide, nil}, {"aNy", AnySide, nil}, - {"woahMan", UnknownSide, errUnrecognisedOrderSide}, + {"woahMan", UnknownSide, ErrSideIsInvalid}, } for i := range cases { testData := &cases[i] @@ -1340,8 +1340,8 @@ func TestValidationOnOrderTypes(t *testing.T) { getOrders.AssetType = asset.Spot err = getOrders.Validate() - if !errors.Is(err, errUnrecognisedOrderSide) { - t.Fatalf("received: '%v' but expected: '%v'", err, errUnrecognisedOrderSide) + if !errors.Is(err, ErrSideIsInvalid) { + t.Fatalf("received: '%v' but expected: '%v'", err, ErrSideIsInvalid) } getOrders.Side = AnySide diff --git a/exchanges/order/order_types.go b/exchanges/order/order_types.go index e718ff5ea2c..253d7410cef 100644 --- a/exchanges/order/order_types.go +++ b/exchanges/order/order_types.go @@ -7,6 +7,7 @@ import ( "github.com/gofrs/uuid" "github.com/thrasher-corp/gocryptotrader/currency" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/exchanges/margin" ) // var error definitions @@ -19,10 +20,12 @@ var ( ErrPairIsEmpty = errors.New("order pair is empty") ErrAssetNotSet = errors.New("order asset type is not set") ErrSideIsInvalid = errors.New("order side is invalid") + ErrCollateralInvalid = errors.New("collateral type is invalid") ErrTypeIsInvalid = errors.New("order type is invalid") ErrAmountIsInvalid = errors.New("order amount is equal or less than zero") ErrPriceMustBeSetIfLimitOrder = errors.New("order price must be set if limit order type is desired") ErrOrderIDNotSet = errors.New("order id or client order id is not set") + ErrSubmitLeverageNotSupported = errors.New("leverage is not supported via order submission") ErrClientOrderIDNotSupported = errors.New("client order id not supported") ErrUnsupportedOrderType = errors.New("unsupported order type") // ErrNoRates is returned when no margin rates are returned when they are expected @@ -64,6 +67,9 @@ type Submit struct { TriggerPrice float64 ClientID string // TODO: Shift to credentials ClientOrderID string + // MarginType such as isolated or cross margin for when an exchange + // supports margin type definition when submitting an order eg okx + MarginType margin.Type // RetrieveFees use if an API submit order response does not return fees // enabling this will perform additional request(s) to retrieve them // and set it in the SubmitResponse @@ -103,6 +109,7 @@ type SubmitResponse struct { Fee float64 FeeAsset currency.Code Cost float64 + MarginType margin.Type } // Modify contains all properties of an order @@ -191,6 +198,7 @@ type Detail struct { CloseTime time.Time LastUpdated time.Time Pair currency.Pair + MarginType margin.Type Trades []TradeHistory } @@ -226,6 +234,7 @@ type Cancel struct { Side Side AssetType asset.Item Pair currency.Pair + MarginType margin.Type } // CancelAllResponse returns the status from attempting to diff --git a/exchanges/order/orders.go b/exchanges/order/orders.go index 8b7dc0d002a..077ec7eff20 100644 --- a/exchanges/order/orders.go +++ b/exchanges/order/orders.go @@ -35,7 +35,6 @@ var ( ErrOrderNotFound = errors.New("order not found") errTimeInForceConflict = errors.New("multiple time in force options applied") - errUnrecognisedOrderSide = errors.New("unrecognised order side") errUnrecognisedOrderType = errors.New("unrecognised order type") errUnrecognisedOrderStatus = errors.New("unrecognised order status") errExchangeNameUnset = errors.New("exchange name unset") @@ -476,6 +475,7 @@ func (s *Submit) DeriveSubmitResponse(orderID string) (*SubmitResponse, error) { TriggerPrice: s.TriggerPrice, ClientID: s.ClientID, ClientOrderID: s.ClientOrderID, + MarginType: s.MarginType, LastUpdated: time.Now(), Date: time.Now(), @@ -1056,7 +1056,7 @@ func StringToOrderSide(side string) (Side, error) { case AnySide.String(): return AnySide, nil default: - return UnknownSide, fmt.Errorf("'%s' %w", side, errUnrecognisedOrderSide) + return UnknownSide, fmt.Errorf("'%s' %w", side, ErrSideIsInvalid) } } @@ -1210,7 +1210,7 @@ func (g *MultiOrderRequest) Validate(opt ...validate.Checker) error { } if g.Side == UnknownSide { - return errUnrecognisedOrderSide + return ErrSideIsInvalid } if g.Type == UnknownType { diff --git a/gctrpc/buf.lock b/gctrpc/buf.lock index ce22a7bcc9c..619f052b03f 100644 --- a/gctrpc/buf.lock +++ b/gctrpc/buf.lock @@ -4,8 +4,10 @@ deps: - remote: buf.build owner: googleapis repository: googleapis - commit: 62f35d8aed1149c291d606d958a7ce32 + commit: cc916c31859748a68fd229a3c8d7a2e8 + digest: shake256:469b049d0eb04203d5272062636c078decefc96fec69739159c25d85349c50c34c7706918a8b216c5c27f76939df48452148cff8c5c3ae77fa6ba5c25c1b8bf8 - remote: buf.build owner: grpc-ecosystem repository: grpc-gateway - commit: bc28b723cd774c32b6fbc77621518765 + commit: a1ecdc58eccd49aa8bea2a7a9022dc27 + digest: shake256:efdd86fbdc42e8b7259fe461a49656827a03fb7cba0b3b9eb622ca10654ec6beccb9a051229c1553ccd89ed3e95d69ad4d7c799f1da3f3f1bd447b7947a4893e diff --git a/gctrpc/rpc.pb.go b/gctrpc/rpc.pb.go index 426d681ace7..f60db7d801f 100644 --- a/gctrpc/rpc.pb.go +++ b/gctrpc/rpc.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.30.0 +// protoc-gen-go v1.31.0 // protoc (unknown) // source: rpc.proto @@ -3674,14 +3674,15 @@ type SubmitOrderRequest struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` - Side string `protobuf:"bytes,3,opt,name=side,proto3" json:"side,omitempty"` - OrderType string `protobuf:"bytes,4,opt,name=order_type,json=orderType,proto3" json:"order_type,omitempty"` - Amount float64 `protobuf:"fixed64,5,opt,name=amount,proto3" json:"amount,omitempty"` - Price float64 `protobuf:"fixed64,6,opt,name=price,proto3" json:"price,omitempty"` - ClientId string `protobuf:"bytes,7,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` - AssetType string `protobuf:"bytes,8,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` + Side string `protobuf:"bytes,3,opt,name=side,proto3" json:"side,omitempty"` + OrderType string `protobuf:"bytes,4,opt,name=order_type,json=orderType,proto3" json:"order_type,omitempty"` + Amount float64 `protobuf:"fixed64,5,opt,name=amount,proto3" json:"amount,omitempty"` + Price float64 `protobuf:"fixed64,6,opt,name=price,proto3" json:"price,omitempty"` + ClientId string `protobuf:"bytes,7,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + AssetType string `protobuf:"bytes,8,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + MarginType string `protobuf:"bytes,9,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` } func (x *SubmitOrderRequest) Reset() { @@ -3772,6 +3773,13 @@ func (x *SubmitOrderRequest) GetAssetType() string { return "" } +func (x *SubmitOrderRequest) GetMarginType() string { + if x != nil { + return x.MarginType + } + return "" +} + type Trades struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -3911,10 +3919,11 @@ type SimulateOrderRequest struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` - Amount float64 `protobuf:"fixed64,3,opt,name=amount,proto3" json:"amount,omitempty"` - Side string `protobuf:"bytes,4,opt,name=side,proto3" json:"side,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` + Amount float64 `protobuf:"fixed64,3,opt,name=amount,proto3" json:"amount,omitempty"` + Side string `protobuf:"bytes,4,opt,name=side,proto3" json:"side,omitempty"` + MarginType string `protobuf:"bytes,5,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` } func (x *SimulateOrderRequest) Reset() { @@ -3977,6 +3986,13 @@ func (x *SimulateOrderRequest) GetSide() string { return "" } +func (x *SimulateOrderRequest) GetMarginType() string { + if x != nil { + return x.MarginType + } + return "" +} + type SimulateOrderResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -11091,6 +11107,18 @@ type FuturesPositionStats struct { MarginFraction string `protobuf:"bytes,10,opt,name=margin_fraction,json=marginFraction,proto3" json:"margin_fraction,omitempty"` FreeCollateral string `protobuf:"bytes,11,opt,name=free_collateral,json=freeCollateral,proto3" json:"free_collateral,omitempty"` TotalCollateral string `protobuf:"bytes,12,opt,name=total_collateral,json=totalCollateral,proto3" json:"total_collateral,omitempty"` + FrozenBalance string `protobuf:"bytes,13,opt,name=frozen_balance,json=frozenBalance,proto3" json:"frozen_balance,omitempty"` + EquityOfCurrency string `protobuf:"bytes,14,opt,name=equity_of_currency,json=equityOfCurrency,proto3" json:"equity_of_currency,omitempty"` + AvailableEquity string `protobuf:"bytes,15,opt,name=available_equity,json=availableEquity,proto3" json:"available_equity,omitempty"` + CashBalance string `protobuf:"bytes,16,opt,name=cash_balance,json=cashBalance,proto3" json:"cash_balance,omitempty"` + DiscountEquity string `protobuf:"bytes,17,opt,name=discount_equity,json=discountEquity,proto3" json:"discount_equity,omitempty"` + EquityUsd string `protobuf:"bytes,18,opt,name=equity_usd,json=equityUsd,proto3" json:"equity_usd,omitempty"` + IsolatedEquity string `protobuf:"bytes,19,opt,name=isolated_equity,json=isolatedEquity,proto3" json:"isolated_equity,omitempty"` + IsolatedLiabilities string `protobuf:"bytes,20,opt,name=isolated_liabilities,json=isolatedLiabilities,proto3" json:"isolated_liabilities,omitempty"` + IsolatedUpl string `protobuf:"bytes,21,opt,name=isolated_upl,json=isolatedUpl,proto3" json:"isolated_upl,omitempty"` + NotionalLeverage string `protobuf:"bytes,22,opt,name=notional_leverage,json=notionalLeverage,proto3" json:"notional_leverage,omitempty"` + TotalEquity string `protobuf:"bytes,23,opt,name=total_equity,json=totalEquity,proto3" json:"total_equity,omitempty"` + StrategyEquity string `protobuf:"bytes,24,opt,name=strategy_equity,json=strategyEquity,proto3" json:"strategy_equity,omitempty"` } func (x *FuturesPositionStats) Reset() { @@ -11209,6 +11237,90 @@ func (x *FuturesPositionStats) GetTotalCollateral() string { return "" } +func (x *FuturesPositionStats) GetFrozenBalance() string { + if x != nil { + return x.FrozenBalance + } + return "" +} + +func (x *FuturesPositionStats) GetEquityOfCurrency() string { + if x != nil { + return x.EquityOfCurrency + } + return "" +} + +func (x *FuturesPositionStats) GetAvailableEquity() string { + if x != nil { + return x.AvailableEquity + } + return "" +} + +func (x *FuturesPositionStats) GetCashBalance() string { + if x != nil { + return x.CashBalance + } + return "" +} + +func (x *FuturesPositionStats) GetDiscountEquity() string { + if x != nil { + return x.DiscountEquity + } + return "" +} + +func (x *FuturesPositionStats) GetEquityUsd() string { + if x != nil { + return x.EquityUsd + } + return "" +} + +func (x *FuturesPositionStats) GetIsolatedEquity() string { + if x != nil { + return x.IsolatedEquity + } + return "" +} + +func (x *FuturesPositionStats) GetIsolatedLiabilities() string { + if x != nil { + return x.IsolatedLiabilities + } + return "" +} + +func (x *FuturesPositionStats) GetIsolatedUpl() string { + if x != nil { + return x.IsolatedUpl + } + return "" +} + +func (x *FuturesPositionStats) GetNotionalLeverage() string { + if x != nil { + return x.NotionalLeverage + } + return "" +} + +func (x *FuturesPositionStats) GetTotalEquity() string { + if x != nil { + return x.TotalEquity + } + return "" +} + +func (x *FuturesPositionStats) GetStrategyEquity() string { + if x != nil { + return x.StrategyEquity + } + return "" +} + type FuturePosition struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -11605,28 +11717,19 @@ func (x *GetManagedPositionsResponse) GetPositions() []*FuturePosition { return nil } -type GetFuturesPositionsRequest struct { +type GetFuturesPositionsSummaryRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` - StartDate string `protobuf:"bytes,4,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` - EndDate string `protobuf:"bytes,5,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` - Status string `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"` - PositionLimit int64 `protobuf:"varint,7,opt,name=position_limit,json=positionLimit,proto3" json:"position_limit,omitempty"` - Overwrite bool `protobuf:"varint,8,opt,name=overwrite,proto3" json:"overwrite,omitempty"` - GetPositionStats bool `protobuf:"varint,9,opt,name=get_position_stats,json=getPositionStats,proto3" json:"get_position_stats,omitempty"` - IncludeFullOrderData bool `protobuf:"varint,10,opt,name=include_full_order_data,json=includeFullOrderData,proto3" json:"include_full_order_data,omitempty"` - GetFundingPayments bool `protobuf:"varint,11,opt,name=get_funding_payments,json=getFundingPayments,proto3" json:"get_funding_payments,omitempty"` - IncludeFullFundingRates bool `protobuf:"varint,12,opt,name=include_full_funding_rates,json=includeFullFundingRates,proto3" json:"include_full_funding_rates,omitempty"` - IncludePredictedRate bool `protobuf:"varint,13,opt,name=include_predicted_rate,json=includePredictedRate,proto3" json:"include_predicted_rate,omitempty"` -} - -func (x *GetFuturesPositionsRequest) Reset() { - *x = GetFuturesPositionsRequest{} + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + UnderlyingPair *CurrencyPair `protobuf:"bytes,4,opt,name=underlying_pair,json=underlyingPair,proto3" json:"underlying_pair,omitempty"` +} + +func (x *GetFuturesPositionsSummaryRequest) Reset() { + *x = GetFuturesPositionsSummaryRequest{} if protoimpl.UnsafeEnabled { mi := &file_rpc_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11634,13 +11737,13 @@ func (x *GetFuturesPositionsRequest) Reset() { } } -func (x *GetFuturesPositionsRequest) String() string { +func (x *GetFuturesPositionsSummaryRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetFuturesPositionsRequest) ProtoMessage() {} +func (*GetFuturesPositionsSummaryRequest) ProtoMessage() {} -func (x *GetFuturesPositionsRequest) ProtoReflect() protoreflect.Message { +func (x *GetFuturesPositionsSummaryRequest) ProtoReflect() protoreflect.Message { mi := &file_rpc_proto_msgTypes[177] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11652,132 +11755,142 @@ func (x *GetFuturesPositionsRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetFuturesPositionsRequest.ProtoReflect.Descriptor instead. -func (*GetFuturesPositionsRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use GetFuturesPositionsSummaryRequest.ProtoReflect.Descriptor instead. +func (*GetFuturesPositionsSummaryRequest) Descriptor() ([]byte, []int) { return file_rpc_proto_rawDescGZIP(), []int{177} } -func (x *GetFuturesPositionsRequest) GetExchange() string { +func (x *GetFuturesPositionsSummaryRequest) GetExchange() string { if x != nil { return x.Exchange } return "" } -func (x *GetFuturesPositionsRequest) GetAsset() string { +func (x *GetFuturesPositionsSummaryRequest) GetAsset() string { if x != nil { return x.Asset } return "" } -func (x *GetFuturesPositionsRequest) GetPair() *CurrencyPair { +func (x *GetFuturesPositionsSummaryRequest) GetPair() *CurrencyPair { if x != nil { return x.Pair } return nil } -func (x *GetFuturesPositionsRequest) GetStartDate() string { +func (x *GetFuturesPositionsSummaryRequest) GetUnderlyingPair() *CurrencyPair { if x != nil { - return x.StartDate + return x.UnderlyingPair } - return "" + return nil } -func (x *GetFuturesPositionsRequest) GetEndDate() string { - if x != nil { - return x.EndDate - } - return "" +type GetFuturesPositionsSummaryResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + PositionStats *FuturesPositionStats `protobuf:"bytes,4,opt,name=position_stats,json=positionStats,proto3" json:"position_stats,omitempty"` } -func (x *GetFuturesPositionsRequest) GetStatus() string { - if x != nil { - return x.Status +func (x *GetFuturesPositionsSummaryResponse) Reset() { + *x = GetFuturesPositionsSummaryResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[178] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return "" } -func (x *GetFuturesPositionsRequest) GetPositionLimit() int64 { - if x != nil { - return x.PositionLimit - } - return 0 +func (x *GetFuturesPositionsSummaryResponse) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *GetFuturesPositionsRequest) GetOverwrite() bool { - if x != nil { - return x.Overwrite +func (*GetFuturesPositionsSummaryResponse) ProtoMessage() {} + +func (x *GetFuturesPositionsSummaryResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[178] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return false + return mi.MessageOf(x) } -func (x *GetFuturesPositionsRequest) GetGetPositionStats() bool { - if x != nil { - return x.GetPositionStats - } - return false +// Deprecated: Use GetFuturesPositionsSummaryResponse.ProtoReflect.Descriptor instead. +func (*GetFuturesPositionsSummaryResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{178} } -func (x *GetFuturesPositionsRequest) GetIncludeFullOrderData() bool { +func (x *GetFuturesPositionsSummaryResponse) GetExchange() string { if x != nil { - return x.IncludeFullOrderData + return x.Exchange } - return false + return "" } -func (x *GetFuturesPositionsRequest) GetGetFundingPayments() bool { +func (x *GetFuturesPositionsSummaryResponse) GetAsset() string { if x != nil { - return x.GetFundingPayments + return x.Asset } - return false + return "" } -func (x *GetFuturesPositionsRequest) GetIncludeFullFundingRates() bool { +func (x *GetFuturesPositionsSummaryResponse) GetPair() *CurrencyPair { if x != nil { - return x.IncludeFullFundingRates + return x.Pair } - return false + return nil } -func (x *GetFuturesPositionsRequest) GetIncludePredictedRate() bool { +func (x *GetFuturesPositionsSummaryResponse) GetPositionStats() *FuturesPositionStats { if x != nil { - return x.IncludePredictedRate + return x.PositionStats } - return false + return nil } -type GetFuturesPositionsResponse struct { +type GetFuturesPositionsOrdersRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - TotalOrders int64 `protobuf:"varint,1,opt,name=total_orders,json=totalOrders,proto3" json:"total_orders,omitempty"` - SubAccount string `protobuf:"bytes,2,opt,name=sub_account,json=subAccount,proto3" json:"sub_account,omitempty"` - TotalRealisedPnl string `protobuf:"bytes,3,opt,name=total_realised_pnl,json=totalRealisedPnl,proto3" json:"total_realised_pnl,omitempty"` - TotalUnrealisedPnl string `protobuf:"bytes,4,opt,name=total_unrealised_pnl,json=totalUnrealisedPnl,proto3" json:"total_unrealised_pnl,omitempty"` - TotalPnl string `protobuf:"bytes,5,opt,name=total_pnl,json=totalPnl,proto3" json:"total_pnl,omitempty"` - Positions []*FuturePosition `protobuf:"bytes,6,rep,name=positions,proto3" json:"positions,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + UnderlyingPair *CurrencyPair `protobuf:"bytes,4,opt,name=underlying_pair,json=underlyingPair,proto3" json:"underlying_pair,omitempty"` + StartDate string `protobuf:"bytes,5,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` + EndDate string `protobuf:"bytes,6,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` + RespectOrderHistoryLimits bool `protobuf:"varint,7,opt,name=respect_order_history_limits,json=respectOrderHistoryLimits,proto3" json:"respect_order_history_limits,omitempty"` + SyncWithOrderManager bool `protobuf:"varint,8,opt,name=sync_with_order_manager,json=syncWithOrderManager,proto3" json:"sync_with_order_manager,omitempty"` } -func (x *GetFuturesPositionsResponse) Reset() { - *x = GetFuturesPositionsResponse{} +func (x *GetFuturesPositionsOrdersRequest) Reset() { + *x = GetFuturesPositionsOrdersRequest{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[178] + mi := &file_rpc_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetFuturesPositionsResponse) String() string { +func (x *GetFuturesPositionsOrdersRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetFuturesPositionsResponse) ProtoMessage() {} +func (*GetFuturesPositionsOrdersRequest) ProtoMessage() {} -func (x *GetFuturesPositionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[178] +func (x *GetFuturesPositionsOrdersRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[179] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11788,82 +11901,92 @@ func (x *GetFuturesPositionsResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetFuturesPositionsResponse.ProtoReflect.Descriptor instead. -func (*GetFuturesPositionsResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{178} +// Deprecated: Use GetFuturesPositionsOrdersRequest.ProtoReflect.Descriptor instead. +func (*GetFuturesPositionsOrdersRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{179} } -func (x *GetFuturesPositionsResponse) GetTotalOrders() int64 { +func (x *GetFuturesPositionsOrdersRequest) GetExchange() string { if x != nil { - return x.TotalOrders + return x.Exchange } - return 0 + return "" } -func (x *GetFuturesPositionsResponse) GetSubAccount() string { +func (x *GetFuturesPositionsOrdersRequest) GetAsset() string { if x != nil { - return x.SubAccount + return x.Asset } return "" } -func (x *GetFuturesPositionsResponse) GetTotalRealisedPnl() string { +func (x *GetFuturesPositionsOrdersRequest) GetPair() *CurrencyPair { if x != nil { - return x.TotalRealisedPnl + return x.Pair } - return "" + return nil +} + +func (x *GetFuturesPositionsOrdersRequest) GetUnderlyingPair() *CurrencyPair { + if x != nil { + return x.UnderlyingPair + } + return nil } -func (x *GetFuturesPositionsResponse) GetTotalUnrealisedPnl() string { +func (x *GetFuturesPositionsOrdersRequest) GetStartDate() string { if x != nil { - return x.TotalUnrealisedPnl + return x.StartDate } return "" } -func (x *GetFuturesPositionsResponse) GetTotalPnl() string { +func (x *GetFuturesPositionsOrdersRequest) GetEndDate() string { if x != nil { - return x.TotalPnl + return x.EndDate } return "" } -func (x *GetFuturesPositionsResponse) GetPositions() []*FuturePosition { +func (x *GetFuturesPositionsOrdersRequest) GetRespectOrderHistoryLimits() bool { if x != nil { - return x.Positions + return x.RespectOrderHistoryLimits } - return nil + return false } -type GetCollateralRequest struct { +func (x *GetFuturesPositionsOrdersRequest) GetSyncWithOrderManager() bool { + if x != nil { + return x.SyncWithOrderManager + } + return false +} + +type GetFuturesPositionsOrdersResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - IncludeBreakdown bool `protobuf:"varint,3,opt,name=include_breakdown,json=includeBreakdown,proto3" json:"include_breakdown,omitempty"` - CalculateOffline bool `protobuf:"varint,4,opt,name=calculate_offline,json=calculateOffline,proto3" json:"calculate_offline,omitempty"` - IncludeZeroValues bool `protobuf:"varint,5,opt,name=include_zero_values,json=includeZeroValues,proto3" json:"include_zero_values,omitempty"` + Positions []*FuturePosition `protobuf:"bytes,6,rep,name=positions,proto3" json:"positions,omitempty"` } -func (x *GetCollateralRequest) Reset() { - *x = GetCollateralRequest{} +func (x *GetFuturesPositionsOrdersResponse) Reset() { + *x = GetFuturesPositionsOrdersResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[179] + mi := &file_rpc_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetCollateralRequest) String() string { +func (x *GetFuturesPositionsOrdersResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetCollateralRequest) ProtoMessage() {} +func (*GetFuturesPositionsOrdersResponse) ProtoMessage() {} -func (x *GetCollateralRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[179] +func (x *GetFuturesPositionsOrdersResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[180] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11874,81 +11997,100 @@ func (x *GetCollateralRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetCollateralRequest.ProtoReflect.Descriptor instead. -func (*GetCollateralRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{179} +// Deprecated: Use GetFuturesPositionsOrdersResponse.ProtoReflect.Descriptor instead. +func (*GetFuturesPositionsOrdersResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{180} } -func (x *GetCollateralRequest) GetExchange() string { +func (x *GetFuturesPositionsOrdersResponse) GetPositions() []*FuturePosition { if x != nil { - return x.Exchange + return x.Positions } - return "" + return nil } -func (x *GetCollateralRequest) GetAsset() string { - if x != nil { - return x.Asset +type GetCollateralModeRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` +} + +func (x *GetCollateralModeRequest) Reset() { + *x = GetCollateralModeRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[181] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return "" } -func (x *GetCollateralRequest) GetIncludeBreakdown() bool { - if x != nil { - return x.IncludeBreakdown +func (x *GetCollateralModeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCollateralModeRequest) ProtoMessage() {} + +func (x *GetCollateralModeRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[181] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return false + return mi.MessageOf(x) } -func (x *GetCollateralRequest) GetCalculateOffline() bool { +// Deprecated: Use GetCollateralModeRequest.ProtoReflect.Descriptor instead. +func (*GetCollateralModeRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{181} +} + +func (x *GetCollateralModeRequest) GetExchange() string { if x != nil { - return x.CalculateOffline + return x.Exchange } - return false + return "" } -func (x *GetCollateralRequest) GetIncludeZeroValues() bool { +func (x *GetCollateralModeRequest) GetAsset() string { if x != nil { - return x.IncludeZeroValues + return x.Asset } - return false + return "" } -type GetCollateralResponse struct { +type GetCollateralModeResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - SubAccount string `protobuf:"bytes,1,opt,name=sub_account,json=subAccount,proto3" json:"sub_account,omitempty"` - CollateralCurrency string `protobuf:"bytes,2,opt,name=collateral_currency,json=collateralCurrency,proto3" json:"collateral_currency,omitempty"` - TotalValueOfPositiveSpotBalances string `protobuf:"bytes,3,opt,name=total_value_of_positive_spot_balances,json=totalValueOfPositiveSpotBalances,proto3" json:"total_value_of_positive_spot_balances,omitempty"` - CollateralContributedByPositiveSpotBalances string `protobuf:"bytes,4,opt,name=collateral_contributed_by_positive_spot_balances,json=collateralContributedByPositiveSpotBalances,proto3" json:"collateral_contributed_by_positive_spot_balances,omitempty"` - UsedCollateral string `protobuf:"bytes,5,opt,name=used_collateral,json=usedCollateral,proto3" json:"used_collateral,omitempty"` - UsedBreakdown *CollateralUsedBreakdown `protobuf:"bytes,6,opt,name=used_breakdown,json=usedBreakdown,proto3" json:"used_breakdown,omitempty"` - AvailableCollateral string `protobuf:"bytes,7,opt,name=available_collateral,json=availableCollateral,proto3" json:"available_collateral,omitempty"` - MaintenanceCollateral string `protobuf:"bytes,8,opt,name=maintenance_collateral,json=maintenanceCollateral,proto3" json:"maintenance_collateral,omitempty"` - UnrealisedPnl string `protobuf:"bytes,9,opt,name=unrealised_pnl,json=unrealisedPnl,proto3" json:"unrealised_pnl,omitempty"` - CurrencyBreakdown []*CollateralForCurrency `protobuf:"bytes,10,rep,name=currency_breakdown,json=currencyBreakdown,proto3" json:"currency_breakdown,omitempty"` - PositionBreakdown []*CollateralByPosition `protobuf:"bytes,11,rep,name=position_breakdown,json=positionBreakdown,proto3" json:"position_breakdown,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + CollateralMode string `protobuf:"bytes,3,opt,name=collateral_mode,json=collateralMode,proto3" json:"collateral_mode,omitempty"` } -func (x *GetCollateralResponse) Reset() { - *x = GetCollateralResponse{} +func (x *GetCollateralModeResponse) Reset() { + *x = GetCollateralModeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[180] + mi := &file_rpc_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetCollateralResponse) String() string { +func (x *GetCollateralModeResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetCollateralResponse) ProtoMessage() {} +func (*GetCollateralModeResponse) ProtoMessage() {} -func (x *GetCollateralResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[180] +func (x *GetCollateralModeResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[182] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11959,125 +12101,122 @@ func (x *GetCollateralResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetCollateralResponse.ProtoReflect.Descriptor instead. -func (*GetCollateralResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{180} +// Deprecated: Use GetCollateralModeResponse.ProtoReflect.Descriptor instead. +func (*GetCollateralModeResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{182} } -func (x *GetCollateralResponse) GetSubAccount() string { +func (x *GetCollateralModeResponse) GetExchange() string { if x != nil { - return x.SubAccount + return x.Exchange } return "" } -func (x *GetCollateralResponse) GetCollateralCurrency() string { +func (x *GetCollateralModeResponse) GetAsset() string { if x != nil { - return x.CollateralCurrency + return x.Asset } return "" } -func (x *GetCollateralResponse) GetTotalValueOfPositiveSpotBalances() string { +func (x *GetCollateralModeResponse) GetCollateralMode() string { if x != nil { - return x.TotalValueOfPositiveSpotBalances + return x.CollateralMode } return "" } -func (x *GetCollateralResponse) GetCollateralContributedByPositiveSpotBalances() string { - if x != nil { - return x.CollateralContributedByPositiveSpotBalances - } - return "" +type SetCollateralModeRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + CollateralMode string `protobuf:"bytes,3,opt,name=collateral_mode,json=collateralMode,proto3" json:"collateral_mode,omitempty"` } -func (x *GetCollateralResponse) GetUsedCollateral() string { - if x != nil { - return x.UsedCollateral +func (x *SetCollateralModeRequest) Reset() { + *x = SetCollateralModeRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[183] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return "" } -func (x *GetCollateralResponse) GetUsedBreakdown() *CollateralUsedBreakdown { - if x != nil { - return x.UsedBreakdown - } - return nil +func (x *SetCollateralModeRequest) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *GetCollateralResponse) GetAvailableCollateral() string { - if x != nil { - return x.AvailableCollateral +func (*SetCollateralModeRequest) ProtoMessage() {} + +func (x *SetCollateralModeRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[183] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return "" + return mi.MessageOf(x) } -func (x *GetCollateralResponse) GetMaintenanceCollateral() string { - if x != nil { - return x.MaintenanceCollateral - } - return "" +// Deprecated: Use SetCollateralModeRequest.ProtoReflect.Descriptor instead. +func (*SetCollateralModeRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{183} } -func (x *GetCollateralResponse) GetUnrealisedPnl() string { +func (x *SetCollateralModeRequest) GetExchange() string { if x != nil { - return x.UnrealisedPnl + return x.Exchange } return "" } -func (x *GetCollateralResponse) GetCurrencyBreakdown() []*CollateralForCurrency { +func (x *SetCollateralModeRequest) GetAsset() string { if x != nil { - return x.CurrencyBreakdown + return x.Asset } - return nil + return "" } -func (x *GetCollateralResponse) GetPositionBreakdown() []*CollateralByPosition { +func (x *SetCollateralModeRequest) GetCollateralMode() string { if x != nil { - return x.PositionBreakdown + return x.CollateralMode } - return nil + return "" } -type CollateralForCurrency struct { +type SetCollateralModeResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Currency string `protobuf:"bytes,1,opt,name=currency,proto3" json:"currency,omitempty"` - ExcludedFromCollateral bool `protobuf:"varint,2,opt,name=excluded_from_collateral,json=excludedFromCollateral,proto3" json:"excluded_from_collateral,omitempty"` - TotalFunds string `protobuf:"bytes,3,opt,name=total_funds,json=totalFunds,proto3" json:"total_funds,omitempty"` - AvailableForUseAsCollateral string `protobuf:"bytes,4,opt,name=available_for_use_as_collateral,json=availableForUseAsCollateral,proto3" json:"available_for_use_as_collateral,omitempty"` - ApproxFairMarketValue string `protobuf:"bytes,5,opt,name=approx_fair_market_value,json=approxFairMarketValue,proto3" json:"approx_fair_market_value,omitempty"` - Weighting string `protobuf:"bytes,6,opt,name=weighting,proto3" json:"weighting,omitempty"` - CollateralContribution string `protobuf:"bytes,7,opt,name=collateral_contribution,json=collateralContribution,proto3" json:"collateral_contribution,omitempty"` - ScaledToCurrency string `protobuf:"bytes,8,opt,name=scaled_to_currency,json=scaledToCurrency,proto3" json:"scaled_to_currency,omitempty"` - UnrealisedPnl string `protobuf:"bytes,9,opt,name=unrealised_pnl,json=unrealisedPnl,proto3" json:"unrealised_pnl,omitempty"` - FundsInUse string `protobuf:"bytes,10,opt,name=funds_in_use,json=fundsInUse,proto3" json:"funds_in_use,omitempty"` - AdditionalCollateralUsed string `protobuf:"bytes,11,opt,name=additional_collateral_used,json=additionalCollateralUsed,proto3" json:"additional_collateral_used,omitempty"` - UsedBreakdown *CollateralUsedBreakdown `protobuf:"bytes,12,opt,name=used_breakdown,json=usedBreakdown,proto3" json:"used_breakdown,omitempty"` - Error string `protobuf:"bytes,13,opt,name=error,proto3" json:"error,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Success bool `protobuf:"varint,3,opt,name=success,proto3" json:"success,omitempty"` } -func (x *CollateralForCurrency) Reset() { - *x = CollateralForCurrency{} +func (x *SetCollateralModeResponse) Reset() { + *x = SetCollateralModeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[181] + mi := &file_rpc_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CollateralForCurrency) String() string { +func (x *SetCollateralModeResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CollateralForCurrency) ProtoMessage() {} +func (*SetCollateralModeResponse) ProtoMessage() {} -func (x *CollateralForCurrency) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[181] +func (x *SetCollateralModeResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[184] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12088,133 +12227,197 @@ func (x *CollateralForCurrency) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CollateralForCurrency.ProtoReflect.Descriptor instead. -func (*CollateralForCurrency) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{181} +// Deprecated: Use SetCollateralModeResponse.ProtoReflect.Descriptor instead. +func (*SetCollateralModeResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{184} } -func (x *CollateralForCurrency) GetCurrency() string { +func (x *SetCollateralModeResponse) GetExchange() string { if x != nil { - return x.Currency + return x.Exchange } return "" } -func (x *CollateralForCurrency) GetExcludedFromCollateral() bool { +func (x *SetCollateralModeResponse) GetAsset() string { if x != nil { - return x.ExcludedFromCollateral + return x.Asset } - return false + return "" } -func (x *CollateralForCurrency) GetTotalFunds() string { +func (x *SetCollateralModeResponse) GetSuccess() bool { if x != nil { - return x.TotalFunds + return x.Success } - return "" + return false } -func (x *CollateralForCurrency) GetAvailableForUseAsCollateral() string { - if x != nil { - return x.AvailableForUseAsCollateral +type GetMarginTypeRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` +} + +func (x *GetMarginTypeRequest) Reset() { + *x = GetMarginTypeRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[185] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return "" } -func (x *CollateralForCurrency) GetApproxFairMarketValue() string { - if x != nil { - return x.ApproxFairMarketValue +func (x *GetMarginTypeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMarginTypeRequest) ProtoMessage() {} + +func (x *GetMarginTypeRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[185] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return "" + return mi.MessageOf(x) } -func (x *CollateralForCurrency) GetWeighting() string { +// Deprecated: Use GetMarginTypeRequest.ProtoReflect.Descriptor instead. +func (*GetMarginTypeRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{185} +} + +func (x *GetMarginTypeRequest) GetExchange() string { if x != nil { - return x.Weighting + return x.Exchange } return "" } -func (x *CollateralForCurrency) GetCollateralContribution() string { +func (x *GetMarginTypeRequest) GetAsset() string { if x != nil { - return x.CollateralContribution + return x.Asset } return "" } -func (x *CollateralForCurrency) GetScaledToCurrency() string { +func (x *GetMarginTypeRequest) GetPair() *CurrencyPair { if x != nil { - return x.ScaledToCurrency + return x.Pair } - return "" + return nil } -func (x *CollateralForCurrency) GetUnrealisedPnl() string { - if x != nil { - return x.UnrealisedPnl +type GetMarginTypeResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + MarginType string `protobuf:"bytes,4,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` +} + +func (x *GetMarginTypeResponse) Reset() { + *x = GetMarginTypeResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[186] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return "" } -func (x *CollateralForCurrency) GetFundsInUse() string { +func (x *GetMarginTypeResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMarginTypeResponse) ProtoMessage() {} + +func (x *GetMarginTypeResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[186] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetMarginTypeResponse.ProtoReflect.Descriptor instead. +func (*GetMarginTypeResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{186} +} + +func (x *GetMarginTypeResponse) GetExchange() string { if x != nil { - return x.FundsInUse + return x.Exchange } return "" } -func (x *CollateralForCurrency) GetAdditionalCollateralUsed() string { +func (x *GetMarginTypeResponse) GetAsset() string { if x != nil { - return x.AdditionalCollateralUsed + return x.Asset } return "" } -func (x *CollateralForCurrency) GetUsedBreakdown() *CollateralUsedBreakdown { +func (x *GetMarginTypeResponse) GetPair() *CurrencyPair { if x != nil { - return x.UsedBreakdown + return x.Pair } return nil } -func (x *CollateralForCurrency) GetError() string { +func (x *GetMarginTypeResponse) GetMarginType() string { if x != nil { - return x.Error + return x.MarginType } return "" } -type CollateralByPosition struct { +type ChangePositionMarginRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Currency string `protobuf:"bytes,1,opt,name=currency,proto3" json:"currency,omitempty"` - Size string `protobuf:"bytes,2,opt,name=size,proto3" json:"size,omitempty"` - OpenOrderSize string `protobuf:"bytes,3,opt,name=open_order_size,json=openOrderSize,proto3" json:"open_order_size,omitempty"` - PositionSize string `protobuf:"bytes,4,opt,name=position_size,json=positionSize,proto3" json:"position_size,omitempty"` - MarkPrice string `protobuf:"bytes,5,opt,name=mark_price,json=markPrice,proto3" json:"mark_price,omitempty"` - RequiredMargin string `protobuf:"bytes,6,opt,name=required_margin,json=requiredMargin,proto3" json:"required_margin,omitempty"` - TotalCollateralUsed string `protobuf:"bytes,7,opt,name=total_collateral_used,json=totalCollateralUsed,proto3" json:"total_collateral_used,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + MarginType string `protobuf:"bytes,4,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` + OriginalAllocatedMargin float64 `protobuf:"fixed64,5,opt,name=original_allocated_margin,json=originalAllocatedMargin,proto3" json:"original_allocated_margin,omitempty"` + NewAllocatedMargin float64 `protobuf:"fixed64,6,opt,name=new_allocated_margin,json=newAllocatedMargin,proto3" json:"new_allocated_margin,omitempty"` + MarginSide string `protobuf:"bytes,7,opt,name=margin_side,json=marginSide,proto3" json:"margin_side,omitempty"` } -func (x *CollateralByPosition) Reset() { - *x = CollateralByPosition{} +func (x *ChangePositionMarginRequest) Reset() { + *x = ChangePositionMarginRequest{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[182] + mi := &file_rpc_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CollateralByPosition) String() string { +func (x *ChangePositionMarginRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CollateralByPosition) ProtoMessage() {} +func (*ChangePositionMarginRequest) ProtoMessage() {} -func (x *CollateralByPosition) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[182] +func (x *ChangePositionMarginRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[187] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12225,92 +12428,90 @@ func (x *CollateralByPosition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CollateralByPosition.ProtoReflect.Descriptor instead. -func (*CollateralByPosition) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{182} +// Deprecated: Use ChangePositionMarginRequest.ProtoReflect.Descriptor instead. +func (*ChangePositionMarginRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{187} } -func (x *CollateralByPosition) GetCurrency() string { +func (x *ChangePositionMarginRequest) GetExchange() string { if x != nil { - return x.Currency + return x.Exchange } return "" } -func (x *CollateralByPosition) GetSize() string { +func (x *ChangePositionMarginRequest) GetAsset() string { if x != nil { - return x.Size + return x.Asset } return "" } -func (x *CollateralByPosition) GetOpenOrderSize() string { +func (x *ChangePositionMarginRequest) GetPair() *CurrencyPair { if x != nil { - return x.OpenOrderSize + return x.Pair } - return "" + return nil } -func (x *CollateralByPosition) GetPositionSize() string { +func (x *ChangePositionMarginRequest) GetMarginType() string { if x != nil { - return x.PositionSize + return x.MarginType } return "" } -func (x *CollateralByPosition) GetMarkPrice() string { +func (x *ChangePositionMarginRequest) GetOriginalAllocatedMargin() float64 { if x != nil { - return x.MarkPrice + return x.OriginalAllocatedMargin } - return "" + return 0 } -func (x *CollateralByPosition) GetRequiredMargin() string { +func (x *ChangePositionMarginRequest) GetNewAllocatedMargin() float64 { if x != nil { - return x.RequiredMargin + return x.NewAllocatedMargin } - return "" + return 0 } -func (x *CollateralByPosition) GetTotalCollateralUsed() string { +func (x *ChangePositionMarginRequest) GetMarginSide() string { if x != nil { - return x.TotalCollateralUsed + return x.MarginSide } return "" } -type CollateralUsedBreakdown struct { +type ChangePositionMarginResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - LockedInStakes string `protobuf:"bytes,1,opt,name=locked_in_stakes,json=lockedInStakes,proto3" json:"locked_in_stakes,omitempty"` - LockedInNftBids string `protobuf:"bytes,2,opt,name=locked_in_nft_bids,json=lockedInNftBids,proto3" json:"locked_in_nft_bids,omitempty"` - LockedInFeeVoucher string `protobuf:"bytes,3,opt,name=locked_in_fee_voucher,json=lockedInFeeVoucher,proto3" json:"locked_in_fee_voucher,omitempty"` - LockedInSpotMarginFundingOffers string `protobuf:"bytes,4,opt,name=locked_in_spot_margin_funding_offers,json=lockedInSpotMarginFundingOffers,proto3" json:"locked_in_spot_margin_funding_offers,omitempty"` - LockedInSpotOrders string `protobuf:"bytes,5,opt,name=locked_in_spot_orders,json=lockedInSpotOrders,proto3" json:"locked_in_spot_orders,omitempty"` - LockedAsCollateral string `protobuf:"bytes,6,opt,name=locked_as_collateral,json=lockedAsCollateral,proto3" json:"locked_as_collateral,omitempty"` - UsedInFutures string `protobuf:"bytes,7,opt,name=used_in_futures,json=usedInFutures,proto3" json:"used_in_futures,omitempty"` - UsedInSpotMargin string `protobuf:"bytes,8,opt,name=used_in_spot_margin,json=usedInSpotMargin,proto3" json:"used_in_spot_margin,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + MarginType string `protobuf:"bytes,4,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` + NewAllocatedMargin float64 `protobuf:"fixed64,5,opt,name=new_allocated_margin,json=newAllocatedMargin,proto3" json:"new_allocated_margin,omitempty"` + MarginSide string `protobuf:"bytes,6,opt,name=margin_side,json=marginSide,proto3" json:"margin_side,omitempty"` } -func (x *CollateralUsedBreakdown) Reset() { - *x = CollateralUsedBreakdown{} +func (x *ChangePositionMarginResponse) Reset() { + *x = ChangePositionMarginResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[183] + mi := &file_rpc_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CollateralUsedBreakdown) String() string { +func (x *ChangePositionMarginResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CollateralUsedBreakdown) ProtoMessage() {} +func (*ChangePositionMarginResponse) ProtoMessage() {} -func (x *CollateralUsedBreakdown) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[183] +func (x *ChangePositionMarginResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[188] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12321,100 +12522,81 @@ func (x *CollateralUsedBreakdown) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CollateralUsedBreakdown.ProtoReflect.Descriptor instead. -func (*CollateralUsedBreakdown) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{183} -} - -func (x *CollateralUsedBreakdown) GetLockedInStakes() string { - if x != nil { - return x.LockedInStakes - } - return "" -} - -func (x *CollateralUsedBreakdown) GetLockedInNftBids() string { - if x != nil { - return x.LockedInNftBids - } - return "" +// Deprecated: Use ChangePositionMarginResponse.ProtoReflect.Descriptor instead. +func (*ChangePositionMarginResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{188} } -func (x *CollateralUsedBreakdown) GetLockedInFeeVoucher() string { +func (x *ChangePositionMarginResponse) GetExchange() string { if x != nil { - return x.LockedInFeeVoucher + return x.Exchange } return "" } -func (x *CollateralUsedBreakdown) GetLockedInSpotMarginFundingOffers() string { +func (x *ChangePositionMarginResponse) GetAsset() string { if x != nil { - return x.LockedInSpotMarginFundingOffers + return x.Asset } return "" } -func (x *CollateralUsedBreakdown) GetLockedInSpotOrders() string { +func (x *ChangePositionMarginResponse) GetPair() *CurrencyPair { if x != nil { - return x.LockedInSpotOrders + return x.Pair } - return "" + return nil } -func (x *CollateralUsedBreakdown) GetLockedAsCollateral() string { +func (x *ChangePositionMarginResponse) GetMarginType() string { if x != nil { - return x.LockedAsCollateral + return x.MarginType } return "" } -func (x *CollateralUsedBreakdown) GetUsedInFutures() string { +func (x *ChangePositionMarginResponse) GetNewAllocatedMargin() float64 { if x != nil { - return x.UsedInFutures + return x.NewAllocatedMargin } - return "" + return 0 } -func (x *CollateralUsedBreakdown) GetUsedInSpotMargin() string { +func (x *ChangePositionMarginResponse) GetMarginSide() string { if x != nil { - return x.UsedInSpotMargin + return x.MarginSide } return "" } -type GetFundingRatesRequest struct { +type SetMarginTypeRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` - StartDate string `protobuf:"bytes,4,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` - EndDate string `protobuf:"bytes,5,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` - PaymentCurrency string `protobuf:"bytes,6,opt,name=payment_currency,json=paymentCurrency,proto3" json:"payment_currency,omitempty"` - IncludePredicted bool `protobuf:"varint,7,opt,name=include_predicted,json=includePredicted,proto3" json:"include_predicted,omitempty"` - IncludePayments bool `protobuf:"varint,8,opt,name=include_payments,json=includePayments,proto3" json:"include_payments,omitempty"` - RespectHistoryLimits bool `protobuf:"varint,9,opt,name=respect_history_limits,json=respectHistoryLimits,proto3" json:"respect_history_limits,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + MarginType string `protobuf:"bytes,4,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` } -func (x *GetFundingRatesRequest) Reset() { - *x = GetFundingRatesRequest{} +func (x *SetMarginTypeRequest) Reset() { + *x = SetMarginTypeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[184] + mi := &file_rpc_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetFundingRatesRequest) String() string { +func (x *SetMarginTypeRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetFundingRatesRequest) ProtoMessage() {} +func (*SetMarginTypeRequest) ProtoMessage() {} -func (x *GetFundingRatesRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[184] +func (x *SetMarginTypeRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[189] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12425,99 +12607,67 @@ func (x *GetFundingRatesRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetFundingRatesRequest.ProtoReflect.Descriptor instead. -func (*GetFundingRatesRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{184} +// Deprecated: Use SetMarginTypeRequest.ProtoReflect.Descriptor instead. +func (*SetMarginTypeRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{189} } -func (x *GetFundingRatesRequest) GetExchange() string { +func (x *SetMarginTypeRequest) GetExchange() string { if x != nil { return x.Exchange } return "" } -func (x *GetFundingRatesRequest) GetAsset() string { +func (x *SetMarginTypeRequest) GetAsset() string { if x != nil { return x.Asset } return "" } -func (x *GetFundingRatesRequest) GetPair() *CurrencyPair { +func (x *SetMarginTypeRequest) GetPair() *CurrencyPair { if x != nil { return x.Pair } return nil } -func (x *GetFundingRatesRequest) GetStartDate() string { - if x != nil { - return x.StartDate - } - return "" -} - -func (x *GetFundingRatesRequest) GetEndDate() string { - if x != nil { - return x.EndDate - } - return "" -} - -func (x *GetFundingRatesRequest) GetPaymentCurrency() string { +func (x *SetMarginTypeRequest) GetMarginType() string { if x != nil { - return x.PaymentCurrency + return x.MarginType } return "" } -func (x *GetFundingRatesRequest) GetIncludePredicted() bool { - if x != nil { - return x.IncludePredicted - } - return false -} - -func (x *GetFundingRatesRequest) GetIncludePayments() bool { - if x != nil { - return x.IncludePayments - } - return false -} - -func (x *GetFundingRatesRequest) GetRespectHistoryLimits() bool { - if x != nil { - return x.RespectHistoryLimits - } - return false -} - -type GetFundingRatesResponse struct { +type SetMarginTypeResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Rates *FundingData `protobuf:"bytes,1,opt,name=rates,proto3" json:"rates,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + Success bool `protobuf:"varint,4,opt,name=success,proto3" json:"success,omitempty"` } -func (x *GetFundingRatesResponse) Reset() { - *x = GetFundingRatesResponse{} +func (x *SetMarginTypeResponse) Reset() { + *x = SetMarginTypeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[185] + mi := &file_rpc_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetFundingRatesResponse) String() string { +func (x *SetMarginTypeResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetFundingRatesResponse) ProtoMessage() {} +func (*SetMarginTypeResponse) ProtoMessage() {} -func (x *GetFundingRatesResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[185] +func (x *SetMarginTypeResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[190] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12528,46 +12678,69 @@ func (x *GetFundingRatesResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetFundingRatesResponse.ProtoReflect.Descriptor instead. -func (*GetFundingRatesResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{185} +// Deprecated: Use SetMarginTypeResponse.ProtoReflect.Descriptor instead. +func (*SetMarginTypeResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{190} } -func (x *GetFundingRatesResponse) GetRates() *FundingData { +func (x *SetMarginTypeResponse) GetExchange() string { if x != nil { - return x.Rates + return x.Exchange + } + return "" +} + +func (x *SetMarginTypeResponse) GetAsset() string { + if x != nil { + return x.Asset + } + return "" +} + +func (x *SetMarginTypeResponse) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -type GetLatestFundingRateRequest struct { +func (x *SetMarginTypeResponse) GetSuccess() bool { + if x != nil { + return x.Success + } + return false +} + +type GetLeverageRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` - IncludePredicted bool `protobuf:"varint,4,opt,name=include_predicted,json=includePredicted,proto3" json:"include_predicted,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + UnderlyingPair *CurrencyPair `protobuf:"bytes,4,opt,name=underlying_pair,json=underlyingPair,proto3" json:"underlying_pair,omitempty"` + MarginType string `protobuf:"bytes,5,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` + OrderSide string `protobuf:"bytes,6,opt,name=order_side,json=orderSide,proto3" json:"order_side,omitempty"` } -func (x *GetLatestFundingRateRequest) Reset() { - *x = GetLatestFundingRateRequest{} +func (x *GetLeverageRequest) Reset() { + *x = GetLeverageRequest{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[186] + mi := &file_rpc_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetLatestFundingRateRequest) String() string { +func (x *GetLeverageRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetLatestFundingRateRequest) ProtoMessage() {} +func (*GetLeverageRequest) ProtoMessage() {} -func (x *GetLatestFundingRateRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[186] +func (x *GetLeverageRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[191] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12578,64 +12751,84 @@ func (x *GetLatestFundingRateRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetLatestFundingRateRequest.ProtoReflect.Descriptor instead. -func (*GetLatestFundingRateRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{186} +// Deprecated: Use GetLeverageRequest.ProtoReflect.Descriptor instead. +func (*GetLeverageRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{191} } -func (x *GetLatestFundingRateRequest) GetExchange() string { +func (x *GetLeverageRequest) GetExchange() string { if x != nil { return x.Exchange } return "" } -func (x *GetLatestFundingRateRequest) GetAsset() string { +func (x *GetLeverageRequest) GetAsset() string { if x != nil { return x.Asset } return "" } -func (x *GetLatestFundingRateRequest) GetPair() *CurrencyPair { +func (x *GetLeverageRequest) GetPair() *CurrencyPair { if x != nil { return x.Pair } return nil } -func (x *GetLatestFundingRateRequest) GetIncludePredicted() bool { +func (x *GetLeverageRequest) GetUnderlyingPair() *CurrencyPair { if x != nil { - return x.IncludePredicted + return x.UnderlyingPair } - return false + return nil } -type GetLatestFundingRateResponse struct { +func (x *GetLeverageRequest) GetMarginType() string { + if x != nil { + return x.MarginType + } + return "" +} + +func (x *GetLeverageRequest) GetOrderSide() string { + if x != nil { + return x.OrderSide + } + return "" +} + +type GetLeverageResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Rate *FundingData `protobuf:"bytes,1,opt,name=rate,proto3" json:"rate,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + UnderlyingPair *CurrencyPair `protobuf:"bytes,4,opt,name=underlying_pair,json=underlyingPair,proto3" json:"underlying_pair,omitempty"` + MarginType string `protobuf:"bytes,5,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` + Leverage float64 `protobuf:"fixed64,6,opt,name=leverage,proto3" json:"leverage,omitempty"` + OrderSide string `protobuf:"bytes,7,opt,name=order_side,json=orderSide,proto3" json:"order_side,omitempty"` } -func (x *GetLatestFundingRateResponse) Reset() { - *x = GetLatestFundingRateResponse{} +func (x *GetLeverageResponse) Reset() { + *x = GetLeverageResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[187] + mi := &file_rpc_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetLatestFundingRateResponse) String() string { +func (x *GetLeverageResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetLatestFundingRateResponse) ProtoMessage() {} +func (*GetLeverageResponse) ProtoMessage() {} -func (x *GetLatestFundingRateResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[187] +func (x *GetLeverageResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[192] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12646,41 +12839,91 @@ func (x *GetLatestFundingRateResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetLatestFundingRateResponse.ProtoReflect.Descriptor instead. -func (*GetLatestFundingRateResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{187} +// Deprecated: Use GetLeverageResponse.ProtoReflect.Descriptor instead. +func (*GetLeverageResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{192} } -func (x *GetLatestFundingRateResponse) GetRate() *FundingData { +func (x *GetLeverageResponse) GetExchange() string { if x != nil { - return x.Rate + return x.Exchange + } + return "" +} + +func (x *GetLeverageResponse) GetAsset() string { + if x != nil { + return x.Asset + } + return "" +} + +func (x *GetLeverageResponse) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -type ShutdownRequest struct { +func (x *GetLeverageResponse) GetUnderlyingPair() *CurrencyPair { + if x != nil { + return x.UnderlyingPair + } + return nil +} + +func (x *GetLeverageResponse) GetMarginType() string { + if x != nil { + return x.MarginType + } + return "" +} + +func (x *GetLeverageResponse) GetLeverage() float64 { + if x != nil { + return x.Leverage + } + return 0 +} + +func (x *GetLeverageResponse) GetOrderSide() string { + if x != nil { + return x.OrderSide + } + return "" +} + +type SetLeverageRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + UnderlyingPair *CurrencyPair `protobuf:"bytes,4,opt,name=underlying_pair,json=underlyingPair,proto3" json:"underlying_pair,omitempty"` + MarginType string `protobuf:"bytes,5,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` + Leverage float64 `protobuf:"fixed64,6,opt,name=leverage,proto3" json:"leverage,omitempty"` + OrderSide string `protobuf:"bytes,7,opt,name=order_side,json=orderSide,proto3" json:"order_side,omitempty"` } -func (x *ShutdownRequest) Reset() { - *x = ShutdownRequest{} +func (x *SetLeverageRequest) Reset() { + *x = SetLeverageRequest{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[188] + mi := &file_rpc_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *ShutdownRequest) String() string { +func (x *SetLeverageRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ShutdownRequest) ProtoMessage() {} +func (*SetLeverageRequest) ProtoMessage() {} -func (x *ShutdownRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[188] +func (x *SetLeverageRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[193] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12691,89 +12934,91 @@ func (x *ShutdownRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ShutdownRequest.ProtoReflect.Descriptor instead. -func (*ShutdownRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{188} +// Deprecated: Use SetLeverageRequest.ProtoReflect.Descriptor instead. +func (*SetLeverageRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{193} } -type ShutdownResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields +func (x *SetLeverageRequest) GetExchange() string { + if x != nil { + return x.Exchange + } + return "" } -func (x *ShutdownResponse) Reset() { - *x = ShutdownResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[189] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *SetLeverageRequest) GetAsset() string { + if x != nil { + return x.Asset } + return "" } -func (x *ShutdownResponse) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *SetLeverageRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair + } + return nil } -func (*ShutdownResponse) ProtoMessage() {} +func (x *SetLeverageRequest) GetUnderlyingPair() *CurrencyPair { + if x != nil { + return x.UnderlyingPair + } + return nil +} -func (x *ShutdownResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[189] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms +func (x *SetLeverageRequest) GetMarginType() string { + if x != nil { + return x.MarginType } - return mi.MessageOf(x) + return "" } -// Deprecated: Use ShutdownResponse.ProtoReflect.Descriptor instead. -func (*ShutdownResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{189} +func (x *SetLeverageRequest) GetLeverage() float64 { + if x != nil { + return x.Leverage + } + return 0 } -type GetTechnicalAnalysisRequest struct { +func (x *SetLeverageRequest) GetOrderSide() string { + if x != nil { + return x.OrderSide + } + return "" +} + +type SetLeverageResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` - AssetType string `protobuf:"bytes,3,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` - AlgorithmType string `protobuf:"bytes,4,opt,name=algorithm_type,json=algorithmType,proto3" json:"algorithm_type,omitempty"` - Interval int64 `protobuf:"varint,5,opt,name=interval,proto3" json:"interval,omitempty"` - Start *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=start,proto3" json:"start,omitempty"` - End *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=end,proto3" json:"end,omitempty"` - Period int64 `protobuf:"varint,8,opt,name=period,proto3" json:"period,omitempty"` - FastPeriod int64 `protobuf:"varint,9,opt,name=fast_period,json=fastPeriod,proto3" json:"fast_period,omitempty"` - SlowPeriod int64 `protobuf:"varint,10,opt,name=slow_period,json=slowPeriod,proto3" json:"slow_period,omitempty"` - StandardDeviationUp float64 `protobuf:"fixed64,11,opt,name=standard_deviation_up,json=standardDeviationUp,proto3" json:"standard_deviation_up,omitempty"` - StandardDeviationDown float64 `protobuf:"fixed64,12,opt,name=standard_deviation_down,json=standardDeviationDown,proto3" json:"standard_deviation_down,omitempty"` - MovingAverageType int64 `protobuf:"varint,13,opt,name=moving_average_type,json=movingAverageType,proto3" json:"moving_average_type,omitempty"` - OtherExchange string `protobuf:"bytes,14,opt,name=other_exchange,json=otherExchange,proto3" json:"other_exchange,omitempty"` - OtherPair *CurrencyPair `protobuf:"bytes,15,opt,name=other_pair,json=otherPair,proto3" json:"other_pair,omitempty"` - OtherAssetType string `protobuf:"bytes,16,opt,name=other_asset_type,json=otherAssetType,proto3" json:"other_asset_type,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + UnderlyingPair *CurrencyPair `protobuf:"bytes,4,opt,name=underlying_pair,json=underlyingPair,proto3" json:"underlying_pair,omitempty"` + MarginType string `protobuf:"bytes,5,opt,name=margin_type,json=marginType,proto3" json:"margin_type,omitempty"` + OrderSide string `protobuf:"bytes,6,opt,name=order_side,json=orderSide,proto3" json:"order_side,omitempty"` + Success bool `protobuf:"varint,7,opt,name=success,proto3" json:"success,omitempty"` } -func (x *GetTechnicalAnalysisRequest) Reset() { - *x = GetTechnicalAnalysisRequest{} +func (x *SetLeverageResponse) Reset() { + *x = SetLeverageResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[190] + mi := &file_rpc_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetTechnicalAnalysisRequest) String() string { +func (x *SetLeverageResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetTechnicalAnalysisRequest) ProtoMessage() {} +func (*SetLeverageResponse) ProtoMessage() {} -func (x *GetTechnicalAnalysisRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[190] +func (x *SetLeverageResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[194] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12784,148 +13029,174 @@ func (x *GetTechnicalAnalysisRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetTechnicalAnalysisRequest.ProtoReflect.Descriptor instead. -func (*GetTechnicalAnalysisRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{190} +// Deprecated: Use SetLeverageResponse.ProtoReflect.Descriptor instead. +func (*SetLeverageResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{194} } -func (x *GetTechnicalAnalysisRequest) GetExchange() string { +func (x *SetLeverageResponse) GetExchange() string { if x != nil { return x.Exchange } return "" } -func (x *GetTechnicalAnalysisRequest) GetPair() *CurrencyPair { +func (x *SetLeverageResponse) GetAsset() string { + if x != nil { + return x.Asset + } + return "" +} + +func (x *SetLeverageResponse) GetPair() *CurrencyPair { if x != nil { return x.Pair } return nil } -func (x *GetTechnicalAnalysisRequest) GetAssetType() string { +func (x *SetLeverageResponse) GetUnderlyingPair() *CurrencyPair { if x != nil { - return x.AssetType + return x.UnderlyingPair } - return "" + return nil } -func (x *GetTechnicalAnalysisRequest) GetAlgorithmType() string { +func (x *SetLeverageResponse) GetMarginType() string { if x != nil { - return x.AlgorithmType + return x.MarginType } return "" } -func (x *GetTechnicalAnalysisRequest) GetInterval() int64 { +func (x *SetLeverageResponse) GetOrderSide() string { if x != nil { - return x.Interval + return x.OrderSide } - return 0 + return "" } -func (x *GetTechnicalAnalysisRequest) GetStart() *timestamppb.Timestamp { +func (x *SetLeverageResponse) GetSuccess() bool { if x != nil { - return x.Start + return x.Success } - return nil + return false } -func (x *GetTechnicalAnalysisRequest) GetEnd() *timestamppb.Timestamp { - if x != nil { - return x.End - } - return nil +type GetCollateralRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + IncludeBreakdown bool `protobuf:"varint,3,opt,name=include_breakdown,json=includeBreakdown,proto3" json:"include_breakdown,omitempty"` + CalculateOffline bool `protobuf:"varint,4,opt,name=calculate_offline,json=calculateOffline,proto3" json:"calculate_offline,omitempty"` + IncludeZeroValues bool `protobuf:"varint,5,opt,name=include_zero_values,json=includeZeroValues,proto3" json:"include_zero_values,omitempty"` } -func (x *GetTechnicalAnalysisRequest) GetPeriod() int64 { - if x != nil { - return x.Period +func (x *GetCollateralRequest) Reset() { + *x = GetCollateralRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[195] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return 0 } -func (x *GetTechnicalAnalysisRequest) GetFastPeriod() int64 { - if x != nil { - return x.FastPeriod - } - return 0 +func (x *GetCollateralRequest) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *GetTechnicalAnalysisRequest) GetSlowPeriod() int64 { - if x != nil { - return x.SlowPeriod +func (*GetCollateralRequest) ProtoMessage() {} + +func (x *GetCollateralRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[195] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return 0 + return mi.MessageOf(x) } -func (x *GetTechnicalAnalysisRequest) GetStandardDeviationUp() float64 { - if x != nil { - return x.StandardDeviationUp - } - return 0 +// Deprecated: Use GetCollateralRequest.ProtoReflect.Descriptor instead. +func (*GetCollateralRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{195} } -func (x *GetTechnicalAnalysisRequest) GetStandardDeviationDown() float64 { +func (x *GetCollateralRequest) GetExchange() string { if x != nil { - return x.StandardDeviationDown + return x.Exchange } - return 0 + return "" } -func (x *GetTechnicalAnalysisRequest) GetMovingAverageType() int64 { +func (x *GetCollateralRequest) GetAsset() string { if x != nil { - return x.MovingAverageType + return x.Asset } - return 0 + return "" } -func (x *GetTechnicalAnalysisRequest) GetOtherExchange() string { +func (x *GetCollateralRequest) GetIncludeBreakdown() bool { if x != nil { - return x.OtherExchange + return x.IncludeBreakdown } - return "" + return false } -func (x *GetTechnicalAnalysisRequest) GetOtherPair() *CurrencyPair { +func (x *GetCollateralRequest) GetCalculateOffline() bool { if x != nil { - return x.OtherPair + return x.CalculateOffline } - return nil + return false } -func (x *GetTechnicalAnalysisRequest) GetOtherAssetType() string { +func (x *GetCollateralRequest) GetIncludeZeroValues() bool { if x != nil { - return x.OtherAssetType + return x.IncludeZeroValues } - return "" + return false } -type ListOfSignals struct { +type GetCollateralResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Signals []float64 `protobuf:"fixed64,1,rep,packed,name=signals,proto3" json:"signals,omitempty"` + SubAccount string `protobuf:"bytes,1,opt,name=sub_account,json=subAccount,proto3" json:"sub_account,omitempty"` + CollateralCurrency string `protobuf:"bytes,2,opt,name=collateral_currency,json=collateralCurrency,proto3" json:"collateral_currency,omitempty"` + TotalValueOfPositiveSpotBalances string `protobuf:"bytes,3,opt,name=total_value_of_positive_spot_balances,json=totalValueOfPositiveSpotBalances,proto3" json:"total_value_of_positive_spot_balances,omitempty"` + CollateralContributedByPositiveSpotBalances string `protobuf:"bytes,4,opt,name=collateral_contributed_by_positive_spot_balances,json=collateralContributedByPositiveSpotBalances,proto3" json:"collateral_contributed_by_positive_spot_balances,omitempty"` + UsedCollateral string `protobuf:"bytes,5,opt,name=used_collateral,json=usedCollateral,proto3" json:"used_collateral,omitempty"` + UsedBreakdown *CollateralUsedBreakdown `protobuf:"bytes,6,opt,name=used_breakdown,json=usedBreakdown,proto3" json:"used_breakdown,omitempty"` + AvailableCollateral string `protobuf:"bytes,7,opt,name=available_collateral,json=availableCollateral,proto3" json:"available_collateral,omitempty"` + MaintenanceCollateral string `protobuf:"bytes,8,opt,name=maintenance_collateral,json=maintenanceCollateral,proto3" json:"maintenance_collateral,omitempty"` + UnrealisedPnl string `protobuf:"bytes,9,opt,name=unrealised_pnl,json=unrealisedPnl,proto3" json:"unrealised_pnl,omitempty"` + CurrencyBreakdown []*CollateralForCurrency `protobuf:"bytes,10,rep,name=currency_breakdown,json=currencyBreakdown,proto3" json:"currency_breakdown,omitempty"` + PositionBreakdown []*CollateralByPosition `protobuf:"bytes,11,rep,name=position_breakdown,json=positionBreakdown,proto3" json:"position_breakdown,omitempty"` } -func (x *ListOfSignals) Reset() { - *x = ListOfSignals{} +func (x *GetCollateralResponse) Reset() { + *x = GetCollateralResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[191] + mi := &file_rpc_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *ListOfSignals) String() string { +func (x *GetCollateralResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListOfSignals) ProtoMessage() {} +func (*GetCollateralResponse) ProtoMessage() {} -func (x *ListOfSignals) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[191] +func (x *GetCollateralResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[196] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12936,102 +13207,125 @@ func (x *ListOfSignals) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListOfSignals.ProtoReflect.Descriptor instead. -func (*ListOfSignals) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{191} +// Deprecated: Use GetCollateralResponse.ProtoReflect.Descriptor instead. +func (*GetCollateralResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{196} } -func (x *ListOfSignals) GetSignals() []float64 { +func (x *GetCollateralResponse) GetSubAccount() string { if x != nil { - return x.Signals + return x.SubAccount } - return nil + return "" } -type GetTechnicalAnalysisResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields +func (x *GetCollateralResponse) GetCollateralCurrency() string { + if x != nil { + return x.CollateralCurrency + } + return "" +} - Signals map[string]*ListOfSignals `protobuf:"bytes,1,rep,name=signals,proto3" json:"signals,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +func (x *GetCollateralResponse) GetTotalValueOfPositiveSpotBalances() string { + if x != nil { + return x.TotalValueOfPositiveSpotBalances + } + return "" } -func (x *GetTechnicalAnalysisResponse) Reset() { - *x = GetTechnicalAnalysisResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[192] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *GetCollateralResponse) GetCollateralContributedByPositiveSpotBalances() string { + if x != nil { + return x.CollateralContributedByPositiveSpotBalances } + return "" } -func (x *GetTechnicalAnalysisResponse) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *GetCollateralResponse) GetUsedCollateral() string { + if x != nil { + return x.UsedCollateral + } + return "" } -func (*GetTechnicalAnalysisResponse) ProtoMessage() {} +func (x *GetCollateralResponse) GetUsedBreakdown() *CollateralUsedBreakdown { + if x != nil { + return x.UsedBreakdown + } + return nil +} -func (x *GetTechnicalAnalysisResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[192] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms +func (x *GetCollateralResponse) GetAvailableCollateral() string { + if x != nil { + return x.AvailableCollateral } - return mi.MessageOf(x) + return "" } -// Deprecated: Use GetTechnicalAnalysisResponse.ProtoReflect.Descriptor instead. -func (*GetTechnicalAnalysisResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{192} +func (x *GetCollateralResponse) GetMaintenanceCollateral() string { + if x != nil { + return x.MaintenanceCollateral + } + return "" } -func (x *GetTechnicalAnalysisResponse) GetSignals() map[string]*ListOfSignals { +func (x *GetCollateralResponse) GetUnrealisedPnl() string { if x != nil { - return x.Signals + return x.UnrealisedPnl + } + return "" +} + +func (x *GetCollateralResponse) GetCurrencyBreakdown() []*CollateralForCurrency { + if x != nil { + return x.CurrencyBreakdown } return nil } -type GetMarginRatesHistoryRequest struct { +func (x *GetCollateralResponse) GetPositionBreakdown() []*CollateralByPosition { + if x != nil { + return x.PositionBreakdown + } + return nil +} + +type CollateralForCurrency struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - Currency string `protobuf:"bytes,3,opt,name=currency,proto3" json:"currency,omitempty"` - StartDate string `protobuf:"bytes,4,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` - EndDate string `protobuf:"bytes,5,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` - GetPredictedRate bool `protobuf:"varint,6,opt,name=get_predicted_rate,json=getPredictedRate,proto3" json:"get_predicted_rate,omitempty"` - GetLendingPayments bool `protobuf:"varint,7,opt,name=get_lending_payments,json=getLendingPayments,proto3" json:"get_lending_payments,omitempty"` - GetBorrowRates bool `protobuf:"varint,8,opt,name=get_borrow_rates,json=getBorrowRates,proto3" json:"get_borrow_rates,omitempty"` - GetBorrowCosts bool `protobuf:"varint,9,opt,name=get_borrow_costs,json=getBorrowCosts,proto3" json:"get_borrow_costs,omitempty"` - IncludeAllRates bool `protobuf:"varint,10,opt,name=include_all_rates,json=includeAllRates,proto3" json:"include_all_rates,omitempty"` - CalculateOffline bool `protobuf:"varint,11,opt,name=calculate_offline,json=calculateOffline,proto3" json:"calculate_offline,omitempty"` - TakerFeeRate string `protobuf:"bytes,12,opt,name=taker_fee_rate,json=takerFeeRate,proto3" json:"taker_fee_rate,omitempty"` - Rates []*MarginRate `protobuf:"bytes,13,rep,name=rates,proto3" json:"rates,omitempty"` + Currency string `protobuf:"bytes,1,opt,name=currency,proto3" json:"currency,omitempty"` + ExcludedFromCollateral bool `protobuf:"varint,2,opt,name=excluded_from_collateral,json=excludedFromCollateral,proto3" json:"excluded_from_collateral,omitempty"` + TotalFunds string `protobuf:"bytes,3,opt,name=total_funds,json=totalFunds,proto3" json:"total_funds,omitempty"` + AvailableForUseAsCollateral string `protobuf:"bytes,4,opt,name=available_for_use_as_collateral,json=availableForUseAsCollateral,proto3" json:"available_for_use_as_collateral,omitempty"` + ApproxFairMarketValue string `protobuf:"bytes,5,opt,name=approx_fair_market_value,json=approxFairMarketValue,proto3" json:"approx_fair_market_value,omitempty"` + Weighting string `protobuf:"bytes,6,opt,name=weighting,proto3" json:"weighting,omitempty"` + CollateralContribution string `protobuf:"bytes,7,opt,name=collateral_contribution,json=collateralContribution,proto3" json:"collateral_contribution,omitempty"` + ScaledToCurrency string `protobuf:"bytes,8,opt,name=scaled_to_currency,json=scaledToCurrency,proto3" json:"scaled_to_currency,omitempty"` + UnrealisedPnl string `protobuf:"bytes,9,opt,name=unrealised_pnl,json=unrealisedPnl,proto3" json:"unrealised_pnl,omitempty"` + FundsInUse string `protobuf:"bytes,10,opt,name=funds_in_use,json=fundsInUse,proto3" json:"funds_in_use,omitempty"` + AdditionalCollateralUsed string `protobuf:"bytes,11,opt,name=additional_collateral_used,json=additionalCollateralUsed,proto3" json:"additional_collateral_used,omitempty"` + UsedBreakdown *CollateralUsedBreakdown `protobuf:"bytes,12,opt,name=used_breakdown,json=usedBreakdown,proto3" json:"used_breakdown,omitempty"` + Error string `protobuf:"bytes,13,opt,name=error,proto3" json:"error,omitempty"` } -func (x *GetMarginRatesHistoryRequest) Reset() { - *x = GetMarginRatesHistoryRequest{} +func (x *CollateralForCurrency) Reset() { + *x = CollateralForCurrency{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[193] + mi := &file_rpc_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetMarginRatesHistoryRequest) String() string { +func (x *CollateralForCurrency) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetMarginRatesHistoryRequest) ProtoMessage() {} +func (*CollateralForCurrency) ProtoMessage() {} -func (x *GetMarginRatesHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[193] +func (x *CollateralForCurrency) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[197] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13042,128 +13336,133 @@ func (x *GetMarginRatesHistoryRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetMarginRatesHistoryRequest.ProtoReflect.Descriptor instead. -func (*GetMarginRatesHistoryRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{193} +// Deprecated: Use CollateralForCurrency.ProtoReflect.Descriptor instead. +func (*CollateralForCurrency) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{197} } -func (x *GetMarginRatesHistoryRequest) GetExchange() string { +func (x *CollateralForCurrency) GetCurrency() string { if x != nil { - return x.Exchange + return x.Currency } return "" } -func (x *GetMarginRatesHistoryRequest) GetAsset() string { +func (x *CollateralForCurrency) GetExcludedFromCollateral() bool { if x != nil { - return x.Asset + return x.ExcludedFromCollateral } - return "" + return false } -func (x *GetMarginRatesHistoryRequest) GetCurrency() string { +func (x *CollateralForCurrency) GetTotalFunds() string { if x != nil { - return x.Currency + return x.TotalFunds } return "" } -func (x *GetMarginRatesHistoryRequest) GetStartDate() string { +func (x *CollateralForCurrency) GetAvailableForUseAsCollateral() string { if x != nil { - return x.StartDate + return x.AvailableForUseAsCollateral } return "" } -func (x *GetMarginRatesHistoryRequest) GetEndDate() string { +func (x *CollateralForCurrency) GetApproxFairMarketValue() string { if x != nil { - return x.EndDate + return x.ApproxFairMarketValue } return "" } -func (x *GetMarginRatesHistoryRequest) GetGetPredictedRate() bool { +func (x *CollateralForCurrency) GetWeighting() string { if x != nil { - return x.GetPredictedRate + return x.Weighting } - return false + return "" } -func (x *GetMarginRatesHistoryRequest) GetGetLendingPayments() bool { +func (x *CollateralForCurrency) GetCollateralContribution() string { if x != nil { - return x.GetLendingPayments + return x.CollateralContribution } - return false + return "" } -func (x *GetMarginRatesHistoryRequest) GetGetBorrowRates() bool { +func (x *CollateralForCurrency) GetScaledToCurrency() string { if x != nil { - return x.GetBorrowRates + return x.ScaledToCurrency } - return false + return "" } -func (x *GetMarginRatesHistoryRequest) GetGetBorrowCosts() bool { +func (x *CollateralForCurrency) GetUnrealisedPnl() string { if x != nil { - return x.GetBorrowCosts + return x.UnrealisedPnl } - return false + return "" } -func (x *GetMarginRatesHistoryRequest) GetIncludeAllRates() bool { +func (x *CollateralForCurrency) GetFundsInUse() string { if x != nil { - return x.IncludeAllRates + return x.FundsInUse } - return false + return "" } -func (x *GetMarginRatesHistoryRequest) GetCalculateOffline() bool { +func (x *CollateralForCurrency) GetAdditionalCollateralUsed() string { if x != nil { - return x.CalculateOffline + return x.AdditionalCollateralUsed } - return false + return "" } -func (x *GetMarginRatesHistoryRequest) GetTakerFeeRate() string { +func (x *CollateralForCurrency) GetUsedBreakdown() *CollateralUsedBreakdown { if x != nil { - return x.TakerFeeRate + return x.UsedBreakdown } - return "" + return nil } -func (x *GetMarginRatesHistoryRequest) GetRates() []*MarginRate { +func (x *CollateralForCurrency) GetError() string { if x != nil { - return x.Rates + return x.Error } - return nil + return "" } -type LendingPayment struct { +type CollateralByPosition struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Payment string `protobuf:"bytes,1,opt,name=payment,proto3" json:"payment,omitempty"` - Size string `protobuf:"bytes,2,opt,name=size,proto3" json:"size,omitempty"` + Currency string `protobuf:"bytes,1,opt,name=currency,proto3" json:"currency,omitempty"` + Size string `protobuf:"bytes,2,opt,name=size,proto3" json:"size,omitempty"` + OpenOrderSize string `protobuf:"bytes,3,opt,name=open_order_size,json=openOrderSize,proto3" json:"open_order_size,omitempty"` + PositionSize string `protobuf:"bytes,4,opt,name=position_size,json=positionSize,proto3" json:"position_size,omitempty"` + MarkPrice string `protobuf:"bytes,5,opt,name=mark_price,json=markPrice,proto3" json:"mark_price,omitempty"` + RequiredMargin string `protobuf:"bytes,6,opt,name=required_margin,json=requiredMargin,proto3" json:"required_margin,omitempty"` + TotalCollateralUsed string `protobuf:"bytes,7,opt,name=total_collateral_used,json=totalCollateralUsed,proto3" json:"total_collateral_used,omitempty"` } -func (x *LendingPayment) Reset() { - *x = LendingPayment{} +func (x *CollateralByPosition) Reset() { + *x = CollateralByPosition{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[194] + mi := &file_rpc_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *LendingPayment) String() string { +func (x *CollateralByPosition) String() string { return protoimpl.X.MessageStringOf(x) } -func (*LendingPayment) ProtoMessage() {} +func (*CollateralByPosition) ProtoMessage() {} -func (x *LendingPayment) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[194] +func (x *CollateralByPosition) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[198] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13174,112 +13473,92 @@ func (x *LendingPayment) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use LendingPayment.ProtoReflect.Descriptor instead. -func (*LendingPayment) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{194} +// Deprecated: Use CollateralByPosition.ProtoReflect.Descriptor instead. +func (*CollateralByPosition) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{198} } -func (x *LendingPayment) GetPayment() string { +func (x *CollateralByPosition) GetCurrency() string { if x != nil { - return x.Payment + return x.Currency } return "" } -func (x *LendingPayment) GetSize() string { +func (x *CollateralByPosition) GetSize() string { if x != nil { return x.Size } return "" } -type BorrowCost struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Cost string `protobuf:"bytes,1,opt,name=cost,proto3" json:"cost,omitempty"` - Size string `protobuf:"bytes,2,opt,name=size,proto3" json:"size,omitempty"` -} - -func (x *BorrowCost) Reset() { - *x = BorrowCost{} - if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[195] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *CollateralByPosition) GetOpenOrderSize() string { + if x != nil { + return x.OpenOrderSize } + return "" } -func (x *BorrowCost) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*BorrowCost) ProtoMessage() {} - -func (x *BorrowCost) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[195] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms +func (x *CollateralByPosition) GetPositionSize() string { + if x != nil { + return x.PositionSize } - return mi.MessageOf(x) + return "" } -// Deprecated: Use BorrowCost.ProtoReflect.Descriptor instead. -func (*BorrowCost) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{195} +func (x *CollateralByPosition) GetMarkPrice() string { + if x != nil { + return x.MarkPrice + } + return "" } -func (x *BorrowCost) GetCost() string { +func (x *CollateralByPosition) GetRequiredMargin() string { if x != nil { - return x.Cost + return x.RequiredMargin } return "" } -func (x *BorrowCost) GetSize() string { +func (x *CollateralByPosition) GetTotalCollateralUsed() string { if x != nil { - return x.Size + return x.TotalCollateralUsed } return "" } -type MarginRate struct { +type CollateralUsedBreakdown struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Time string `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"` - MarketBorrowSize string `protobuf:"bytes,2,opt,name=market_borrow_size,json=marketBorrowSize,proto3" json:"market_borrow_size,omitempty"` - HourlyRate string `protobuf:"bytes,3,opt,name=hourly_rate,json=hourlyRate,proto3" json:"hourly_rate,omitempty"` - YearlyRate string `protobuf:"bytes,4,opt,name=yearly_rate,json=yearlyRate,proto3" json:"yearly_rate,omitempty"` - HourlyBorrowRate string `protobuf:"bytes,5,opt,name=hourly_borrow_rate,json=hourlyBorrowRate,proto3" json:"hourly_borrow_rate,omitempty"` - YearlyBorrowRate string `protobuf:"bytes,6,opt,name=yearly_borrow_rate,json=yearlyBorrowRate,proto3" json:"yearly_borrow_rate,omitempty"` - LendingPayment *LendingPayment `protobuf:"bytes,7,opt,name=lending_payment,json=lendingPayment,proto3" json:"lending_payment,omitempty"` - BorrowCost *BorrowCost `protobuf:"bytes,8,opt,name=borrow_cost,json=borrowCost,proto3" json:"borrow_cost,omitempty"` + LockedInStakes string `protobuf:"bytes,1,opt,name=locked_in_stakes,json=lockedInStakes,proto3" json:"locked_in_stakes,omitempty"` + LockedInNftBids string `protobuf:"bytes,2,opt,name=locked_in_nft_bids,json=lockedInNftBids,proto3" json:"locked_in_nft_bids,omitempty"` + LockedInFeeVoucher string `protobuf:"bytes,3,opt,name=locked_in_fee_voucher,json=lockedInFeeVoucher,proto3" json:"locked_in_fee_voucher,omitempty"` + LockedInSpotMarginFundingOffers string `protobuf:"bytes,4,opt,name=locked_in_spot_margin_funding_offers,json=lockedInSpotMarginFundingOffers,proto3" json:"locked_in_spot_margin_funding_offers,omitempty"` + LockedInSpotOrders string `protobuf:"bytes,5,opt,name=locked_in_spot_orders,json=lockedInSpotOrders,proto3" json:"locked_in_spot_orders,omitempty"` + LockedAsCollateral string `protobuf:"bytes,6,opt,name=locked_as_collateral,json=lockedAsCollateral,proto3" json:"locked_as_collateral,omitempty"` + UsedInFutures string `protobuf:"bytes,7,opt,name=used_in_futures,json=usedInFutures,proto3" json:"used_in_futures,omitempty"` + UsedInSpotMargin string `protobuf:"bytes,8,opt,name=used_in_spot_margin,json=usedInSpotMargin,proto3" json:"used_in_spot_margin,omitempty"` } -func (x *MarginRate) Reset() { - *x = MarginRate{} +func (x *CollateralUsedBreakdown) Reset() { + *x = CollateralUsedBreakdown{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[196] + mi := &file_rpc_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *MarginRate) String() string { +func (x *CollateralUsedBreakdown) String() string { return protoimpl.X.MessageStringOf(x) } -func (*MarginRate) ProtoMessage() {} +func (*CollateralUsedBreakdown) ProtoMessage() {} -func (x *MarginRate) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[196] +func (x *CollateralUsedBreakdown) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[199] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13290,100 +13569,100 @@ func (x *MarginRate) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use MarginRate.ProtoReflect.Descriptor instead. -func (*MarginRate) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{196} +// Deprecated: Use CollateralUsedBreakdown.ProtoReflect.Descriptor instead. +func (*CollateralUsedBreakdown) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{199} } -func (x *MarginRate) GetTime() string { +func (x *CollateralUsedBreakdown) GetLockedInStakes() string { if x != nil { - return x.Time + return x.LockedInStakes } return "" } -func (x *MarginRate) GetMarketBorrowSize() string { +func (x *CollateralUsedBreakdown) GetLockedInNftBids() string { if x != nil { - return x.MarketBorrowSize + return x.LockedInNftBids } return "" } -func (x *MarginRate) GetHourlyRate() string { +func (x *CollateralUsedBreakdown) GetLockedInFeeVoucher() string { if x != nil { - return x.HourlyRate + return x.LockedInFeeVoucher } return "" } -func (x *MarginRate) GetYearlyRate() string { +func (x *CollateralUsedBreakdown) GetLockedInSpotMarginFundingOffers() string { if x != nil { - return x.YearlyRate + return x.LockedInSpotMarginFundingOffers } return "" } -func (x *MarginRate) GetHourlyBorrowRate() string { +func (x *CollateralUsedBreakdown) GetLockedInSpotOrders() string { if x != nil { - return x.HourlyBorrowRate + return x.LockedInSpotOrders } return "" } -func (x *MarginRate) GetYearlyBorrowRate() string { +func (x *CollateralUsedBreakdown) GetLockedAsCollateral() string { if x != nil { - return x.YearlyBorrowRate + return x.LockedAsCollateral } return "" } -func (x *MarginRate) GetLendingPayment() *LendingPayment { +func (x *CollateralUsedBreakdown) GetUsedInFutures() string { if x != nil { - return x.LendingPayment + return x.UsedInFutures } - return nil + return "" } -func (x *MarginRate) GetBorrowCost() *BorrowCost { +func (x *CollateralUsedBreakdown) GetUsedInSpotMargin() string { if x != nil { - return x.BorrowCost + return x.UsedInSpotMargin } - return nil + return "" } -type GetMarginRatesHistoryResponse struct { +type GetFundingRatesRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Rates []*MarginRate `protobuf:"bytes,1,rep,name=rates,proto3" json:"rates,omitempty"` - TotalRates int64 `protobuf:"varint,2,opt,name=total_rates,json=totalRates,proto3" json:"total_rates,omitempty"` - SumBorrowCosts string `protobuf:"bytes,3,opt,name=sum_borrow_costs,json=sumBorrowCosts,proto3" json:"sum_borrow_costs,omitempty"` - AvgBorrowSize string `protobuf:"bytes,4,opt,name=avg_borrow_size,json=avgBorrowSize,proto3" json:"avg_borrow_size,omitempty"` - SumLendingPayments string `protobuf:"bytes,5,opt,name=sum_lending_payments,json=sumLendingPayments,proto3" json:"sum_lending_payments,omitempty"` - AvgLendingSize string `protobuf:"bytes,6,opt,name=avg_lending_size,json=avgLendingSize,proto3" json:"avg_lending_size,omitempty"` - LatestRate *MarginRate `protobuf:"bytes,7,opt,name=latest_rate,json=latestRate,proto3" json:"latest_rate,omitempty"` - PredictedRate *MarginRate `protobuf:"bytes,8,opt,name=predicted_rate,json=predictedRate,proto3" json:"predicted_rate,omitempty"` - TakerFeeRate string `protobuf:"bytes,9,opt,name=taker_fee_rate,json=takerFeeRate,proto3" json:"taker_fee_rate,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + StartDate string `protobuf:"bytes,4,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` + EndDate string `protobuf:"bytes,5,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` + PaymentCurrency string `protobuf:"bytes,6,opt,name=payment_currency,json=paymentCurrency,proto3" json:"payment_currency,omitempty"` + IncludePredicted bool `protobuf:"varint,7,opt,name=include_predicted,json=includePredicted,proto3" json:"include_predicted,omitempty"` + IncludePayments bool `protobuf:"varint,8,opt,name=include_payments,json=includePayments,proto3" json:"include_payments,omitempty"` + RespectHistoryLimits bool `protobuf:"varint,9,opt,name=respect_history_limits,json=respectHistoryLimits,proto3" json:"respect_history_limits,omitempty"` } -func (x *GetMarginRatesHistoryResponse) Reset() { - *x = GetMarginRatesHistoryResponse{} +func (x *GetFundingRatesRequest) Reset() { + *x = GetFundingRatesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[197] + mi := &file_rpc_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetMarginRatesHistoryResponse) String() string { +func (x *GetFundingRatesRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetMarginRatesHistoryResponse) ProtoMessage() {} +func (*GetFundingRatesRequest) ProtoMessage() {} -func (x *GetMarginRatesHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[197] +func (x *GetFundingRatesRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[200] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13394,105 +13673,99 @@ func (x *GetMarginRatesHistoryResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetMarginRatesHistoryResponse.ProtoReflect.Descriptor instead. -func (*GetMarginRatesHistoryResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{197} +// Deprecated: Use GetFundingRatesRequest.ProtoReflect.Descriptor instead. +func (*GetFundingRatesRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{200} } -func (x *GetMarginRatesHistoryResponse) GetRates() []*MarginRate { +func (x *GetFundingRatesRequest) GetExchange() string { if x != nil { - return x.Rates + return x.Exchange } - return nil + return "" } -func (x *GetMarginRatesHistoryResponse) GetTotalRates() int64 { +func (x *GetFundingRatesRequest) GetAsset() string { if x != nil { - return x.TotalRates + return x.Asset } - return 0 + return "" } -func (x *GetMarginRatesHistoryResponse) GetSumBorrowCosts() string { +func (x *GetFundingRatesRequest) GetPair() *CurrencyPair { if x != nil { - return x.SumBorrowCosts + return x.Pair } - return "" + return nil } -func (x *GetMarginRatesHistoryResponse) GetAvgBorrowSize() string { +func (x *GetFundingRatesRequest) GetStartDate() string { if x != nil { - return x.AvgBorrowSize + return x.StartDate } return "" } -func (x *GetMarginRatesHistoryResponse) GetSumLendingPayments() string { +func (x *GetFundingRatesRequest) GetEndDate() string { if x != nil { - return x.SumLendingPayments + return x.EndDate } return "" } -func (x *GetMarginRatesHistoryResponse) GetAvgLendingSize() string { +func (x *GetFundingRatesRequest) GetPaymentCurrency() string { if x != nil { - return x.AvgLendingSize + return x.PaymentCurrency } return "" } -func (x *GetMarginRatesHistoryResponse) GetLatestRate() *MarginRate { +func (x *GetFundingRatesRequest) GetIncludePredicted() bool { if x != nil { - return x.LatestRate + return x.IncludePredicted } - return nil + return false } -func (x *GetMarginRatesHistoryResponse) GetPredictedRate() *MarginRate { +func (x *GetFundingRatesRequest) GetIncludePayments() bool { if x != nil { - return x.PredictedRate + return x.IncludePayments } - return nil + return false } -func (x *GetMarginRatesHistoryResponse) GetTakerFeeRate() string { +func (x *GetFundingRatesRequest) GetRespectHistoryLimits() bool { if x != nil { - return x.TakerFeeRate + return x.RespectHistoryLimits } - return "" + return false } -type GetOrderbookMovementRequest struct { +type GetFundingRatesResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` - Amount float64 `protobuf:"fixed64,6,opt,name=amount,proto3" json:"amount,omitempty"` - Sell bool `protobuf:"varint,7,opt,name=sell,proto3" json:"sell,omitempty"` - RequiresRestOrderbook bool `protobuf:"varint,8,opt,name=requires_rest_orderbook,json=requiresRestOrderbook,proto3" json:"requires_rest_orderbook,omitempty"` - Purchase bool `protobuf:"varint,9,opt,name=purchase,proto3" json:"purchase,omitempty"` + Rates *FundingData `protobuf:"bytes,1,opt,name=rates,proto3" json:"rates,omitempty"` } -func (x *GetOrderbookMovementRequest) Reset() { - *x = GetOrderbookMovementRequest{} +func (x *GetFundingRatesResponse) Reset() { + *x = GetFundingRatesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[198] + mi := &file_rpc_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetOrderbookMovementRequest) String() string { +func (x *GetFundingRatesResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetOrderbookMovementRequest) ProtoMessage() {} +func (*GetFundingRatesResponse) ProtoMessage() {} -func (x *GetOrderbookMovementRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[198] +func (x *GetFundingRatesResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[201] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13503,98 +13776,114 @@ func (x *GetOrderbookMovementRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetOrderbookMovementRequest.ProtoReflect.Descriptor instead. -func (*GetOrderbookMovementRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{198} +// Deprecated: Use GetFundingRatesResponse.ProtoReflect.Descriptor instead. +func (*GetFundingRatesResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{201} } -func (x *GetOrderbookMovementRequest) GetExchange() string { +func (x *GetFundingRatesResponse) GetRates() *FundingData { + if x != nil { + return x.Rates + } + return nil +} + +type GetLatestFundingRateRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + IncludePredicted bool `protobuf:"varint,4,opt,name=include_predicted,json=includePredicted,proto3" json:"include_predicted,omitempty"` +} + +func (x *GetLatestFundingRateRequest) Reset() { + *x = GetLatestFundingRateRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[202] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetLatestFundingRateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLatestFundingRateRequest) ProtoMessage() {} + +func (x *GetLatestFundingRateRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[202] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetLatestFundingRateRequest.ProtoReflect.Descriptor instead. +func (*GetLatestFundingRateRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{202} +} + +func (x *GetLatestFundingRateRequest) GetExchange() string { if x != nil { return x.Exchange } return "" } -func (x *GetOrderbookMovementRequest) GetAsset() string { +func (x *GetLatestFundingRateRequest) GetAsset() string { if x != nil { return x.Asset } return "" } -func (x *GetOrderbookMovementRequest) GetPair() *CurrencyPair { +func (x *GetLatestFundingRateRequest) GetPair() *CurrencyPair { if x != nil { return x.Pair } return nil } -func (x *GetOrderbookMovementRequest) GetAmount() float64 { +func (x *GetLatestFundingRateRequest) GetIncludePredicted() bool { if x != nil { - return x.Amount + return x.IncludePredicted } - return 0 + return false } -func (x *GetOrderbookMovementRequest) GetSell() bool { - if x != nil { - return x.Sell - } - return false -} - -func (x *GetOrderbookMovementRequest) GetRequiresRestOrderbook() bool { - if x != nil { - return x.RequiresRestOrderbook - } - return false -} - -func (x *GetOrderbookMovementRequest) GetPurchase() bool { - if x != nil { - return x.Purchase - } - return false -} - -type GetOrderbookMovementResponse struct { +type GetLatestFundingRateResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - NominalPercentage float64 `protobuf:"fixed64,1,opt,name=nominal_percentage,json=nominalPercentage,proto3" json:"nominal_percentage,omitempty"` - ImpactPercentage float64 `protobuf:"fixed64,2,opt,name=impact_percentage,json=impactPercentage,proto3" json:"impact_percentage,omitempty"` - SlippageCost float64 `protobuf:"fixed64,3,opt,name=slippage_cost,json=slippageCost,proto3" json:"slippage_cost,omitempty"` - CurrencyBought string `protobuf:"bytes,4,opt,name=currency_bought,json=currencyBought,proto3" json:"currency_bought,omitempty"` - Bought float64 `protobuf:"fixed64,5,opt,name=bought,proto3" json:"bought,omitempty"` - CurrencySold string `protobuf:"bytes,6,opt,name=currency_sold,json=currencySold,proto3" json:"currency_sold,omitempty"` - Sold float64 `protobuf:"fixed64,7,opt,name=sold,proto3" json:"sold,omitempty"` - SideAffected string `protobuf:"bytes,8,opt,name=side_affected,json=sideAffected,proto3" json:"side_affected,omitempty"` - UpdateProtocol string `protobuf:"bytes,9,opt,name=update_protocol,json=updateProtocol,proto3" json:"update_protocol,omitempty"` - FullOrderbookSideConsumed bool `protobuf:"varint,10,opt,name=full_orderbook_side_consumed,json=fullOrderbookSideConsumed,proto3" json:"full_orderbook_side_consumed,omitempty"` - StartPrice float64 `protobuf:"fixed64,11,opt,name=start_price,json=startPrice,proto3" json:"start_price,omitempty"` - EndPrice float64 `protobuf:"fixed64,12,opt,name=end_price,json=endPrice,proto3" json:"end_price,omitempty"` - NoSlippageOccurred bool `protobuf:"varint,13,opt,name=no_slippage_occurred,json=noSlippageOccurred,proto3" json:"no_slippage_occurred,omitempty"` - AverageOrderCost float64 `protobuf:"fixed64,14,opt,name=average_order_cost,json=averageOrderCost,proto3" json:"average_order_cost,omitempty"` + Rate *FundingData `protobuf:"bytes,1,opt,name=rate,proto3" json:"rate,omitempty"` } -func (x *GetOrderbookMovementResponse) Reset() { - *x = GetOrderbookMovementResponse{} +func (x *GetLatestFundingRateResponse) Reset() { + *x = GetLatestFundingRateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[199] + mi := &file_rpc_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetOrderbookMovementResponse) String() string { +func (x *GetLatestFundingRateResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetOrderbookMovementResponse) ProtoMessage() {} +func (*GetLatestFundingRateResponse) ProtoMessage() {} -func (x *GetOrderbookMovementResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[199] +func (x *GetLatestFundingRateResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[203] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13605,139 +13894,134 @@ func (x *GetOrderbookMovementResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetOrderbookMovementResponse.ProtoReflect.Descriptor instead. -func (*GetOrderbookMovementResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{199} -} - -func (x *GetOrderbookMovementResponse) GetNominalPercentage() float64 { - if x != nil { - return x.NominalPercentage - } - return 0 +// Deprecated: Use GetLatestFundingRateResponse.ProtoReflect.Descriptor instead. +func (*GetLatestFundingRateResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{203} } -func (x *GetOrderbookMovementResponse) GetImpactPercentage() float64 { +func (x *GetLatestFundingRateResponse) GetRate() *FundingData { if x != nil { - return x.ImpactPercentage + return x.Rate } - return 0 + return nil } -func (x *GetOrderbookMovementResponse) GetSlippageCost() float64 { - if x != nil { - return x.SlippageCost - } - return 0 +type ShutdownRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (x *GetOrderbookMovementResponse) GetCurrencyBought() string { - if x != nil { - return x.CurrencyBought +func (x *ShutdownRequest) Reset() { + *x = ShutdownRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[204] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return "" } -func (x *GetOrderbookMovementResponse) GetBought() float64 { - if x != nil { - return x.Bought - } - return 0 +func (x *ShutdownRequest) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *GetOrderbookMovementResponse) GetCurrencySold() string { - if x != nil { - return x.CurrencySold - } - return "" -} +func (*ShutdownRequest) ProtoMessage() {} -func (x *GetOrderbookMovementResponse) GetSold() float64 { - if x != nil { - return x.Sold +func (x *ShutdownRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[204] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return 0 + return mi.MessageOf(x) } -func (x *GetOrderbookMovementResponse) GetSideAffected() string { - if x != nil { - return x.SideAffected - } - return "" +// Deprecated: Use ShutdownRequest.ProtoReflect.Descriptor instead. +func (*ShutdownRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{204} } -func (x *GetOrderbookMovementResponse) GetUpdateProtocol() string { - if x != nil { - return x.UpdateProtocol - } - return "" +type ShutdownResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (x *GetOrderbookMovementResponse) GetFullOrderbookSideConsumed() bool { - if x != nil { - return x.FullOrderbookSideConsumed +func (x *ShutdownResponse) Reset() { + *x = ShutdownResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[205] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return false } -func (x *GetOrderbookMovementResponse) GetStartPrice() float64 { - if x != nil { - return x.StartPrice - } - return 0 +func (x *ShutdownResponse) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *GetOrderbookMovementResponse) GetEndPrice() float64 { - if x != nil { - return x.EndPrice - } - return 0 -} +func (*ShutdownResponse) ProtoMessage() {} -func (x *GetOrderbookMovementResponse) GetNoSlippageOccurred() bool { - if x != nil { - return x.NoSlippageOccurred +func (x *ShutdownResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[205] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return false + return mi.MessageOf(x) } -func (x *GetOrderbookMovementResponse) GetAverageOrderCost() float64 { - if x != nil { - return x.AverageOrderCost - } - return 0 +// Deprecated: Use ShutdownResponse.ProtoReflect.Descriptor instead. +func (*ShutdownResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{205} } -type GetOrderbookAmountByNominalRequest struct { +type GetTechnicalAnalysisRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` - NominalPercentage float64 `protobuf:"fixed64,6,opt,name=nominal_percentage,json=nominalPercentage,proto3" json:"nominal_percentage,omitempty"` - Sell bool `protobuf:"varint,7,opt,name=sell,proto3" json:"sell,omitempty"` - RequiresRestOrderbook bool `protobuf:"varint,8,opt,name=requires_rest_orderbook,json=requiresRestOrderbook,proto3" json:"requires_rest_orderbook,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` + AssetType string `protobuf:"bytes,3,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + AlgorithmType string `protobuf:"bytes,4,opt,name=algorithm_type,json=algorithmType,proto3" json:"algorithm_type,omitempty"` + Interval int64 `protobuf:"varint,5,opt,name=interval,proto3" json:"interval,omitempty"` + Start *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=start,proto3" json:"start,omitempty"` + End *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=end,proto3" json:"end,omitempty"` + Period int64 `protobuf:"varint,8,opt,name=period,proto3" json:"period,omitempty"` + FastPeriod int64 `protobuf:"varint,9,opt,name=fast_period,json=fastPeriod,proto3" json:"fast_period,omitempty"` + SlowPeriod int64 `protobuf:"varint,10,opt,name=slow_period,json=slowPeriod,proto3" json:"slow_period,omitempty"` + StandardDeviationUp float64 `protobuf:"fixed64,11,opt,name=standard_deviation_up,json=standardDeviationUp,proto3" json:"standard_deviation_up,omitempty"` + StandardDeviationDown float64 `protobuf:"fixed64,12,opt,name=standard_deviation_down,json=standardDeviationDown,proto3" json:"standard_deviation_down,omitempty"` + MovingAverageType int64 `protobuf:"varint,13,opt,name=moving_average_type,json=movingAverageType,proto3" json:"moving_average_type,omitempty"` + OtherExchange string `protobuf:"bytes,14,opt,name=other_exchange,json=otherExchange,proto3" json:"other_exchange,omitempty"` + OtherPair *CurrencyPair `protobuf:"bytes,15,opt,name=other_pair,json=otherPair,proto3" json:"other_pair,omitempty"` + OtherAssetType string `protobuf:"bytes,16,opt,name=other_asset_type,json=otherAssetType,proto3" json:"other_asset_type,omitempty"` } -func (x *GetOrderbookAmountByNominalRequest) Reset() { - *x = GetOrderbookAmountByNominalRequest{} +func (x *GetTechnicalAnalysisRequest) Reset() { + *x = GetTechnicalAnalysisRequest{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[200] + mi := &file_rpc_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetOrderbookAmountByNominalRequest) String() string { +func (x *GetTechnicalAnalysisRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetOrderbookAmountByNominalRequest) ProtoMessage() {} +func (*GetTechnicalAnalysisRequest) ProtoMessage() {} -func (x *GetOrderbookAmountByNominalRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[200] +func (x *GetTechnicalAnalysisRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[206] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13748,210 +14032,148 @@ func (x *GetOrderbookAmountByNominalRequest) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use GetOrderbookAmountByNominalRequest.ProtoReflect.Descriptor instead. -func (*GetOrderbookAmountByNominalRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{200} +// Deprecated: Use GetTechnicalAnalysisRequest.ProtoReflect.Descriptor instead. +func (*GetTechnicalAnalysisRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{206} } -func (x *GetOrderbookAmountByNominalRequest) GetExchange() string { +func (x *GetTechnicalAnalysisRequest) GetExchange() string { if x != nil { return x.Exchange } return "" } -func (x *GetOrderbookAmountByNominalRequest) GetAsset() string { +func (x *GetTechnicalAnalysisRequest) GetPair() *CurrencyPair { if x != nil { - return x.Asset + return x.Pair + } + return nil +} + +func (x *GetTechnicalAnalysisRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } -func (x *GetOrderbookAmountByNominalRequest) GetPair() *CurrencyPair { +func (x *GetTechnicalAnalysisRequest) GetAlgorithmType() string { if x != nil { - return x.Pair + return x.AlgorithmType } - return nil + return "" } -func (x *GetOrderbookAmountByNominalRequest) GetNominalPercentage() float64 { +func (x *GetTechnicalAnalysisRequest) GetInterval() int64 { if x != nil { - return x.NominalPercentage + return x.Interval } return 0 } -func (x *GetOrderbookAmountByNominalRequest) GetSell() bool { +func (x *GetTechnicalAnalysisRequest) GetStart() *timestamppb.Timestamp { if x != nil { - return x.Sell + return x.Start } - return false + return nil } -func (x *GetOrderbookAmountByNominalRequest) GetRequiresRestOrderbook() bool { +func (x *GetTechnicalAnalysisRequest) GetEnd() *timestamppb.Timestamp { if x != nil { - return x.RequiresRestOrderbook + return x.End } - return false + return nil } -type GetOrderbookAmountByNominalResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields +func (x *GetTechnicalAnalysisRequest) GetPeriod() int64 { + if x != nil { + return x.Period + } + return 0 +} - AmountRequired float64 `protobuf:"fixed64,1,opt,name=amount_required,json=amountRequired,proto3" json:"amount_required,omitempty"` - CurrencySelling string `protobuf:"bytes,2,opt,name=currency_selling,json=currencySelling,proto3" json:"currency_selling,omitempty"` - AmountReceived float64 `protobuf:"fixed64,3,opt,name=amount_received,json=amountReceived,proto3" json:"amount_received,omitempty"` - CurrencyBuying string `protobuf:"bytes,4,opt,name=currency_buying,json=currencyBuying,proto3" json:"currency_buying,omitempty"` - StartPrice float64 `protobuf:"fixed64,5,opt,name=start_price,json=startPrice,proto3" json:"start_price,omitempty"` - EndPrice float64 `protobuf:"fixed64,6,opt,name=end_price,json=endPrice,proto3" json:"end_price,omitempty"` - AverageOrderCost float64 `protobuf:"fixed64,7,opt,name=average_order_cost,json=averageOrderCost,proto3" json:"average_order_cost,omitempty"` - SideAffected string `protobuf:"bytes,8,opt,name=side_affected,json=sideAffected,proto3" json:"side_affected,omitempty"` - ApproximateNominalSlippagePercentage float64 `protobuf:"fixed64,9,opt,name=approximate_nominal_slippage_percentage,json=approximateNominalSlippagePercentage,proto3" json:"approximate_nominal_slippage_percentage,omitempty"` - UpdateProtocol string `protobuf:"bytes,10,opt,name=update_protocol,json=updateProtocol,proto3" json:"update_protocol,omitempty"` - FullOrderbookSideConsumed bool `protobuf:"varint,11,opt,name=full_orderbook_side_consumed,json=fullOrderbookSideConsumed,proto3" json:"full_orderbook_side_consumed,omitempty"` -} - -func (x *GetOrderbookAmountByNominalResponse) Reset() { - *x = GetOrderbookAmountByNominalResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[201] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetOrderbookAmountByNominalResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetOrderbookAmountByNominalResponse) ProtoMessage() {} - -func (x *GetOrderbookAmountByNominalResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[201] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use GetOrderbookAmountByNominalResponse.ProtoReflect.Descriptor instead. -func (*GetOrderbookAmountByNominalResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{201} -} - -func (x *GetOrderbookAmountByNominalResponse) GetAmountRequired() float64 { +func (x *GetTechnicalAnalysisRequest) GetFastPeriod() int64 { if x != nil { - return x.AmountRequired + return x.FastPeriod } return 0 } -func (x *GetOrderbookAmountByNominalResponse) GetCurrencySelling() string { - if x != nil { - return x.CurrencySelling - } - return "" -} - -func (x *GetOrderbookAmountByNominalResponse) GetAmountReceived() float64 { +func (x *GetTechnicalAnalysisRequest) GetSlowPeriod() int64 { if x != nil { - return x.AmountReceived + return x.SlowPeriod } return 0 } -func (x *GetOrderbookAmountByNominalResponse) GetCurrencyBuying() string { - if x != nil { - return x.CurrencyBuying - } - return "" -} - -func (x *GetOrderbookAmountByNominalResponse) GetStartPrice() float64 { +func (x *GetTechnicalAnalysisRequest) GetStandardDeviationUp() float64 { if x != nil { - return x.StartPrice + return x.StandardDeviationUp } return 0 } -func (x *GetOrderbookAmountByNominalResponse) GetEndPrice() float64 { +func (x *GetTechnicalAnalysisRequest) GetStandardDeviationDown() float64 { if x != nil { - return x.EndPrice + return x.StandardDeviationDown } return 0 } -func (x *GetOrderbookAmountByNominalResponse) GetAverageOrderCost() float64 { +func (x *GetTechnicalAnalysisRequest) GetMovingAverageType() int64 { if x != nil { - return x.AverageOrderCost + return x.MovingAverageType } return 0 } -func (x *GetOrderbookAmountByNominalResponse) GetSideAffected() string { +func (x *GetTechnicalAnalysisRequest) GetOtherExchange() string { if x != nil { - return x.SideAffected + return x.OtherExchange } return "" } -func (x *GetOrderbookAmountByNominalResponse) GetApproximateNominalSlippagePercentage() float64 { +func (x *GetTechnicalAnalysisRequest) GetOtherPair() *CurrencyPair { if x != nil { - return x.ApproximateNominalSlippagePercentage + return x.OtherPair } - return 0 + return nil } -func (x *GetOrderbookAmountByNominalResponse) GetUpdateProtocol() string { +func (x *GetTechnicalAnalysisRequest) GetOtherAssetType() string { if x != nil { - return x.UpdateProtocol + return x.OtherAssetType } return "" } -func (x *GetOrderbookAmountByNominalResponse) GetFullOrderbookSideConsumed() bool { - if x != nil { - return x.FullOrderbookSideConsumed - } - return false -} - -type GetOrderbookAmountByImpactRequest struct { +type ListOfSignals struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` - ImpactPercentage float64 `protobuf:"fixed64,6,opt,name=impact_percentage,json=impactPercentage,proto3" json:"impact_percentage,omitempty"` - Sell bool `protobuf:"varint,7,opt,name=sell,proto3" json:"sell,omitempty"` - RequiresRestOrderbook bool `protobuf:"varint,8,opt,name=requires_rest_orderbook,json=requiresRestOrderbook,proto3" json:"requires_rest_orderbook,omitempty"` + Signals []float64 `protobuf:"fixed64,1,rep,packed,name=signals,proto3" json:"signals,omitempty"` } -func (x *GetOrderbookAmountByImpactRequest) Reset() { - *x = GetOrderbookAmountByImpactRequest{} +func (x *ListOfSignals) Reset() { + *x = ListOfSignals{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[202] + mi := &file_rpc_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetOrderbookAmountByImpactRequest) String() string { +func (x *ListOfSignals) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetOrderbookAmountByImpactRequest) ProtoMessage() {} +func (*ListOfSignals) ProtoMessage() {} -func (x *GetOrderbookAmountByImpactRequest) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[202] +func (x *ListOfSignals) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[207] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13962,88 +14184,102 @@ func (x *GetOrderbookAmountByImpactRequest) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use GetOrderbookAmountByImpactRequest.ProtoReflect.Descriptor instead. -func (*GetOrderbookAmountByImpactRequest) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{202} +// Deprecated: Use ListOfSignals.ProtoReflect.Descriptor instead. +func (*ListOfSignals) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{207} } -func (x *GetOrderbookAmountByImpactRequest) GetExchange() string { +func (x *ListOfSignals) GetSignals() []float64 { if x != nil { - return x.Exchange + return x.Signals } - return "" + return nil } -func (x *GetOrderbookAmountByImpactRequest) GetAsset() string { - if x != nil { - return x.Asset - } - return "" +type GetTechnicalAnalysisResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Signals map[string]*ListOfSignals `protobuf:"bytes,1,rep,name=signals,proto3" json:"signals,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } -func (x *GetOrderbookAmountByImpactRequest) GetPair() *CurrencyPair { - if x != nil { - return x.Pair +func (x *GetTechnicalAnalysisResponse) Reset() { + *x = GetTechnicalAnalysisResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[208] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return nil } -func (x *GetOrderbookAmountByImpactRequest) GetImpactPercentage() float64 { - if x != nil { - return x.ImpactPercentage - } - return 0 +func (x *GetTechnicalAnalysisResponse) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *GetOrderbookAmountByImpactRequest) GetSell() bool { - if x != nil { - return x.Sell +func (*GetTechnicalAnalysisResponse) ProtoMessage() {} + +func (x *GetTechnicalAnalysisResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[208] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return false + return mi.MessageOf(x) } -func (x *GetOrderbookAmountByImpactRequest) GetRequiresRestOrderbook() bool { +// Deprecated: Use GetTechnicalAnalysisResponse.ProtoReflect.Descriptor instead. +func (*GetTechnicalAnalysisResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{208} +} + +func (x *GetTechnicalAnalysisResponse) GetSignals() map[string]*ListOfSignals { if x != nil { - return x.RequiresRestOrderbook + return x.Signals } - return false + return nil } -type GetOrderbookAmountByImpactResponse struct { +type GetMarginRatesHistoryRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - AmountRequired float64 `protobuf:"fixed64,1,opt,name=amount_required,json=amountRequired,proto3" json:"amount_required,omitempty"` - CurrencySelling string `protobuf:"bytes,2,opt,name=currency_selling,json=currencySelling,proto3" json:"currency_selling,omitempty"` - AmountReceived float64 `protobuf:"fixed64,3,opt,name=amount_received,json=amountReceived,proto3" json:"amount_received,omitempty"` - CurrencyBuying string `protobuf:"bytes,4,opt,name=currency_buying,json=currencyBuying,proto3" json:"currency_buying,omitempty"` - StartPrice float64 `protobuf:"fixed64,5,opt,name=start_price,json=startPrice,proto3" json:"start_price,omitempty"` - EndPrice float64 `protobuf:"fixed64,6,opt,name=end_price,json=endPrice,proto3" json:"end_price,omitempty"` - AverageOrderCost float64 `protobuf:"fixed64,7,opt,name=average_order_cost,json=averageOrderCost,proto3" json:"average_order_cost,omitempty"` - SideAffected string `protobuf:"bytes,8,opt,name=side_affected,json=sideAffected,proto3" json:"side_affected,omitempty"` - ApproximateImpactSlippagePercentage float64 `protobuf:"fixed64,9,opt,name=approximate_impact_slippage_percentage,json=approximateImpactSlippagePercentage,proto3" json:"approximate_impact_slippage_percentage,omitempty"` - UpdateProtocol string `protobuf:"bytes,10,opt,name=update_protocol,json=updateProtocol,proto3" json:"update_protocol,omitempty"` - FullOrderbookSideConsumed bool `protobuf:"varint,11,opt,name=full_orderbook_side_consumed,json=fullOrderbookSideConsumed,proto3" json:"full_orderbook_side_consumed,omitempty"` + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Currency string `protobuf:"bytes,3,opt,name=currency,proto3" json:"currency,omitempty"` + StartDate string `protobuf:"bytes,4,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` + EndDate string `protobuf:"bytes,5,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` + GetPredictedRate bool `protobuf:"varint,6,opt,name=get_predicted_rate,json=getPredictedRate,proto3" json:"get_predicted_rate,omitempty"` + GetLendingPayments bool `protobuf:"varint,7,opt,name=get_lending_payments,json=getLendingPayments,proto3" json:"get_lending_payments,omitempty"` + GetBorrowRates bool `protobuf:"varint,8,opt,name=get_borrow_rates,json=getBorrowRates,proto3" json:"get_borrow_rates,omitempty"` + GetBorrowCosts bool `protobuf:"varint,9,opt,name=get_borrow_costs,json=getBorrowCosts,proto3" json:"get_borrow_costs,omitempty"` + IncludeAllRates bool `protobuf:"varint,10,opt,name=include_all_rates,json=includeAllRates,proto3" json:"include_all_rates,omitempty"` + CalculateOffline bool `protobuf:"varint,11,opt,name=calculate_offline,json=calculateOffline,proto3" json:"calculate_offline,omitempty"` + TakerFeeRate string `protobuf:"bytes,12,opt,name=taker_fee_rate,json=takerFeeRate,proto3" json:"taker_fee_rate,omitempty"` + Rates []*MarginRate `protobuf:"bytes,13,rep,name=rates,proto3" json:"rates,omitempty"` } -func (x *GetOrderbookAmountByImpactResponse) Reset() { - *x = GetOrderbookAmountByImpactResponse{} +func (x *GetMarginRatesHistoryRequest) Reset() { + *x = GetMarginRatesHistoryRequest{} if protoimpl.UnsafeEnabled { - mi := &file_rpc_proto_msgTypes[203] + mi := &file_rpc_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *GetOrderbookAmountByImpactResponse) String() string { +func (x *GetMarginRatesHistoryRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetOrderbookAmountByImpactResponse) ProtoMessage() {} +func (*GetMarginRatesHistoryRequest) ProtoMessage() {} -func (x *GetOrderbookAmountByImpactResponse) ProtoReflect() protoreflect.Message { - mi := &file_rpc_proto_msgTypes[203] +func (x *GetMarginRatesHistoryRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[209] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14054,51 +14290,1063 @@ func (x *GetOrderbookAmountByImpactResponse) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use GetOrderbookAmountByImpactResponse.ProtoReflect.Descriptor instead. -func (*GetOrderbookAmountByImpactResponse) Descriptor() ([]byte, []int) { - return file_rpc_proto_rawDescGZIP(), []int{203} +// Deprecated: Use GetMarginRatesHistoryRequest.ProtoReflect.Descriptor instead. +func (*GetMarginRatesHistoryRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{209} } -func (x *GetOrderbookAmountByImpactResponse) GetAmountRequired() float64 { +func (x *GetMarginRatesHistoryRequest) GetExchange() string { if x != nil { - return x.AmountRequired + return x.Exchange } - return 0 + return "" } -func (x *GetOrderbookAmountByImpactResponse) GetCurrencySelling() string { +func (x *GetMarginRatesHistoryRequest) GetAsset() string { if x != nil { - return x.CurrencySelling + return x.Asset } return "" } -func (x *GetOrderbookAmountByImpactResponse) GetAmountReceived() float64 { +func (x *GetMarginRatesHistoryRequest) GetCurrency() string { if x != nil { - return x.AmountReceived + return x.Currency } - return 0 + return "" } -func (x *GetOrderbookAmountByImpactResponse) GetCurrencyBuying() string { +func (x *GetMarginRatesHistoryRequest) GetStartDate() string { if x != nil { - return x.CurrencyBuying + return x.StartDate } return "" } -func (x *GetOrderbookAmountByImpactResponse) GetStartPrice() float64 { +func (x *GetMarginRatesHistoryRequest) GetEndDate() string { if x != nil { - return x.StartPrice + return x.EndDate } - return 0 + return "" } -func (x *GetOrderbookAmountByImpactResponse) GetEndPrice() float64 { +func (x *GetMarginRatesHistoryRequest) GetGetPredictedRate() bool { if x != nil { - return x.EndPrice + return x.GetPredictedRate } - return 0 + return false +} + +func (x *GetMarginRatesHistoryRequest) GetGetLendingPayments() bool { + if x != nil { + return x.GetLendingPayments + } + return false +} + +func (x *GetMarginRatesHistoryRequest) GetGetBorrowRates() bool { + if x != nil { + return x.GetBorrowRates + } + return false +} + +func (x *GetMarginRatesHistoryRequest) GetGetBorrowCosts() bool { + if x != nil { + return x.GetBorrowCosts + } + return false +} + +func (x *GetMarginRatesHistoryRequest) GetIncludeAllRates() bool { + if x != nil { + return x.IncludeAllRates + } + return false +} + +func (x *GetMarginRatesHistoryRequest) GetCalculateOffline() bool { + if x != nil { + return x.CalculateOffline + } + return false +} + +func (x *GetMarginRatesHistoryRequest) GetTakerFeeRate() string { + if x != nil { + return x.TakerFeeRate + } + return "" +} + +func (x *GetMarginRatesHistoryRequest) GetRates() []*MarginRate { + if x != nil { + return x.Rates + } + return nil +} + +type LendingPayment struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Payment string `protobuf:"bytes,1,opt,name=payment,proto3" json:"payment,omitempty"` + Size string `protobuf:"bytes,2,opt,name=size,proto3" json:"size,omitempty"` +} + +func (x *LendingPayment) Reset() { + *x = LendingPayment{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[210] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LendingPayment) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LendingPayment) ProtoMessage() {} + +func (x *LendingPayment) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[210] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LendingPayment.ProtoReflect.Descriptor instead. +func (*LendingPayment) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{210} +} + +func (x *LendingPayment) GetPayment() string { + if x != nil { + return x.Payment + } + return "" +} + +func (x *LendingPayment) GetSize() string { + if x != nil { + return x.Size + } + return "" +} + +type BorrowCost struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Cost string `protobuf:"bytes,1,opt,name=cost,proto3" json:"cost,omitempty"` + Size string `protobuf:"bytes,2,opt,name=size,proto3" json:"size,omitempty"` +} + +func (x *BorrowCost) Reset() { + *x = BorrowCost{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[211] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BorrowCost) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BorrowCost) ProtoMessage() {} + +func (x *BorrowCost) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[211] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BorrowCost.ProtoReflect.Descriptor instead. +func (*BorrowCost) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{211} +} + +func (x *BorrowCost) GetCost() string { + if x != nil { + return x.Cost + } + return "" +} + +func (x *BorrowCost) GetSize() string { + if x != nil { + return x.Size + } + return "" +} + +type MarginRate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Time string `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"` + MarketBorrowSize string `protobuf:"bytes,2,opt,name=market_borrow_size,json=marketBorrowSize,proto3" json:"market_borrow_size,omitempty"` + HourlyRate string `protobuf:"bytes,3,opt,name=hourly_rate,json=hourlyRate,proto3" json:"hourly_rate,omitempty"` + YearlyRate string `protobuf:"bytes,4,opt,name=yearly_rate,json=yearlyRate,proto3" json:"yearly_rate,omitempty"` + HourlyBorrowRate string `protobuf:"bytes,5,opt,name=hourly_borrow_rate,json=hourlyBorrowRate,proto3" json:"hourly_borrow_rate,omitempty"` + YearlyBorrowRate string `protobuf:"bytes,6,opt,name=yearly_borrow_rate,json=yearlyBorrowRate,proto3" json:"yearly_borrow_rate,omitempty"` + LendingPayment *LendingPayment `protobuf:"bytes,7,opt,name=lending_payment,json=lendingPayment,proto3" json:"lending_payment,omitempty"` + BorrowCost *BorrowCost `protobuf:"bytes,8,opt,name=borrow_cost,json=borrowCost,proto3" json:"borrow_cost,omitempty"` +} + +func (x *MarginRate) Reset() { + *x = MarginRate{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[212] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MarginRate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MarginRate) ProtoMessage() {} + +func (x *MarginRate) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[212] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MarginRate.ProtoReflect.Descriptor instead. +func (*MarginRate) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{212} +} + +func (x *MarginRate) GetTime() string { + if x != nil { + return x.Time + } + return "" +} + +func (x *MarginRate) GetMarketBorrowSize() string { + if x != nil { + return x.MarketBorrowSize + } + return "" +} + +func (x *MarginRate) GetHourlyRate() string { + if x != nil { + return x.HourlyRate + } + return "" +} + +func (x *MarginRate) GetYearlyRate() string { + if x != nil { + return x.YearlyRate + } + return "" +} + +func (x *MarginRate) GetHourlyBorrowRate() string { + if x != nil { + return x.HourlyBorrowRate + } + return "" +} + +func (x *MarginRate) GetYearlyBorrowRate() string { + if x != nil { + return x.YearlyBorrowRate + } + return "" +} + +func (x *MarginRate) GetLendingPayment() *LendingPayment { + if x != nil { + return x.LendingPayment + } + return nil +} + +func (x *MarginRate) GetBorrowCost() *BorrowCost { + if x != nil { + return x.BorrowCost + } + return nil +} + +type GetMarginRatesHistoryResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Rates []*MarginRate `protobuf:"bytes,1,rep,name=rates,proto3" json:"rates,omitempty"` + TotalRates int64 `protobuf:"varint,2,opt,name=total_rates,json=totalRates,proto3" json:"total_rates,omitempty"` + SumBorrowCosts string `protobuf:"bytes,3,opt,name=sum_borrow_costs,json=sumBorrowCosts,proto3" json:"sum_borrow_costs,omitempty"` + AvgBorrowSize string `protobuf:"bytes,4,opt,name=avg_borrow_size,json=avgBorrowSize,proto3" json:"avg_borrow_size,omitempty"` + SumLendingPayments string `protobuf:"bytes,5,opt,name=sum_lending_payments,json=sumLendingPayments,proto3" json:"sum_lending_payments,omitempty"` + AvgLendingSize string `protobuf:"bytes,6,opt,name=avg_lending_size,json=avgLendingSize,proto3" json:"avg_lending_size,omitempty"` + LatestRate *MarginRate `protobuf:"bytes,7,opt,name=latest_rate,json=latestRate,proto3" json:"latest_rate,omitempty"` + PredictedRate *MarginRate `protobuf:"bytes,8,opt,name=predicted_rate,json=predictedRate,proto3" json:"predicted_rate,omitempty"` + TakerFeeRate string `protobuf:"bytes,9,opt,name=taker_fee_rate,json=takerFeeRate,proto3" json:"taker_fee_rate,omitempty"` +} + +func (x *GetMarginRatesHistoryResponse) Reset() { + *x = GetMarginRatesHistoryResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[213] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetMarginRatesHistoryResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMarginRatesHistoryResponse) ProtoMessage() {} + +func (x *GetMarginRatesHistoryResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[213] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetMarginRatesHistoryResponse.ProtoReflect.Descriptor instead. +func (*GetMarginRatesHistoryResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{213} +} + +func (x *GetMarginRatesHistoryResponse) GetRates() []*MarginRate { + if x != nil { + return x.Rates + } + return nil +} + +func (x *GetMarginRatesHistoryResponse) GetTotalRates() int64 { + if x != nil { + return x.TotalRates + } + return 0 +} + +func (x *GetMarginRatesHistoryResponse) GetSumBorrowCosts() string { + if x != nil { + return x.SumBorrowCosts + } + return "" +} + +func (x *GetMarginRatesHistoryResponse) GetAvgBorrowSize() string { + if x != nil { + return x.AvgBorrowSize + } + return "" +} + +func (x *GetMarginRatesHistoryResponse) GetSumLendingPayments() string { + if x != nil { + return x.SumLendingPayments + } + return "" +} + +func (x *GetMarginRatesHistoryResponse) GetAvgLendingSize() string { + if x != nil { + return x.AvgLendingSize + } + return "" +} + +func (x *GetMarginRatesHistoryResponse) GetLatestRate() *MarginRate { + if x != nil { + return x.LatestRate + } + return nil +} + +func (x *GetMarginRatesHistoryResponse) GetPredictedRate() *MarginRate { + if x != nil { + return x.PredictedRate + } + return nil +} + +func (x *GetMarginRatesHistoryResponse) GetTakerFeeRate() string { + if x != nil { + return x.TakerFeeRate + } + return "" +} + +type GetOrderbookMovementRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + Amount float64 `protobuf:"fixed64,6,opt,name=amount,proto3" json:"amount,omitempty"` + Sell bool `protobuf:"varint,7,opt,name=sell,proto3" json:"sell,omitempty"` + RequiresRestOrderbook bool `protobuf:"varint,8,opt,name=requires_rest_orderbook,json=requiresRestOrderbook,proto3" json:"requires_rest_orderbook,omitempty"` + Purchase bool `protobuf:"varint,9,opt,name=purchase,proto3" json:"purchase,omitempty"` +} + +func (x *GetOrderbookMovementRequest) Reset() { + *x = GetOrderbookMovementRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[214] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbookMovementRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbookMovementRequest) ProtoMessage() {} + +func (x *GetOrderbookMovementRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[214] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrderbookMovementRequest.ProtoReflect.Descriptor instead. +func (*GetOrderbookMovementRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{214} +} + +func (x *GetOrderbookMovementRequest) GetExchange() string { + if x != nil { + return x.Exchange + } + return "" +} + +func (x *GetOrderbookMovementRequest) GetAsset() string { + if x != nil { + return x.Asset + } + return "" +} + +func (x *GetOrderbookMovementRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair + } + return nil +} + +func (x *GetOrderbookMovementRequest) GetAmount() float64 { + if x != nil { + return x.Amount + } + return 0 +} + +func (x *GetOrderbookMovementRequest) GetSell() bool { + if x != nil { + return x.Sell + } + return false +} + +func (x *GetOrderbookMovementRequest) GetRequiresRestOrderbook() bool { + if x != nil { + return x.RequiresRestOrderbook + } + return false +} + +func (x *GetOrderbookMovementRequest) GetPurchase() bool { + if x != nil { + return x.Purchase + } + return false +} + +type GetOrderbookMovementResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + NominalPercentage float64 `protobuf:"fixed64,1,opt,name=nominal_percentage,json=nominalPercentage,proto3" json:"nominal_percentage,omitempty"` + ImpactPercentage float64 `protobuf:"fixed64,2,opt,name=impact_percentage,json=impactPercentage,proto3" json:"impact_percentage,omitempty"` + SlippageCost float64 `protobuf:"fixed64,3,opt,name=slippage_cost,json=slippageCost,proto3" json:"slippage_cost,omitempty"` + CurrencyBought string `protobuf:"bytes,4,opt,name=currency_bought,json=currencyBought,proto3" json:"currency_bought,omitempty"` + Bought float64 `protobuf:"fixed64,5,opt,name=bought,proto3" json:"bought,omitempty"` + CurrencySold string `protobuf:"bytes,6,opt,name=currency_sold,json=currencySold,proto3" json:"currency_sold,omitempty"` + Sold float64 `protobuf:"fixed64,7,opt,name=sold,proto3" json:"sold,omitempty"` + SideAffected string `protobuf:"bytes,8,opt,name=side_affected,json=sideAffected,proto3" json:"side_affected,omitempty"` + UpdateProtocol string `protobuf:"bytes,9,opt,name=update_protocol,json=updateProtocol,proto3" json:"update_protocol,omitempty"` + FullOrderbookSideConsumed bool `protobuf:"varint,10,opt,name=full_orderbook_side_consumed,json=fullOrderbookSideConsumed,proto3" json:"full_orderbook_side_consumed,omitempty"` + StartPrice float64 `protobuf:"fixed64,11,opt,name=start_price,json=startPrice,proto3" json:"start_price,omitempty"` + EndPrice float64 `protobuf:"fixed64,12,opt,name=end_price,json=endPrice,proto3" json:"end_price,omitempty"` + NoSlippageOccurred bool `protobuf:"varint,13,opt,name=no_slippage_occurred,json=noSlippageOccurred,proto3" json:"no_slippage_occurred,omitempty"` + AverageOrderCost float64 `protobuf:"fixed64,14,opt,name=average_order_cost,json=averageOrderCost,proto3" json:"average_order_cost,omitempty"` +} + +func (x *GetOrderbookMovementResponse) Reset() { + *x = GetOrderbookMovementResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[215] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbookMovementResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbookMovementResponse) ProtoMessage() {} + +func (x *GetOrderbookMovementResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[215] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrderbookMovementResponse.ProtoReflect.Descriptor instead. +func (*GetOrderbookMovementResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{215} +} + +func (x *GetOrderbookMovementResponse) GetNominalPercentage() float64 { + if x != nil { + return x.NominalPercentage + } + return 0 +} + +func (x *GetOrderbookMovementResponse) GetImpactPercentage() float64 { + if x != nil { + return x.ImpactPercentage + } + return 0 +} + +func (x *GetOrderbookMovementResponse) GetSlippageCost() float64 { + if x != nil { + return x.SlippageCost + } + return 0 +} + +func (x *GetOrderbookMovementResponse) GetCurrencyBought() string { + if x != nil { + return x.CurrencyBought + } + return "" +} + +func (x *GetOrderbookMovementResponse) GetBought() float64 { + if x != nil { + return x.Bought + } + return 0 +} + +func (x *GetOrderbookMovementResponse) GetCurrencySold() string { + if x != nil { + return x.CurrencySold + } + return "" +} + +func (x *GetOrderbookMovementResponse) GetSold() float64 { + if x != nil { + return x.Sold + } + return 0 +} + +func (x *GetOrderbookMovementResponse) GetSideAffected() string { + if x != nil { + return x.SideAffected + } + return "" +} + +func (x *GetOrderbookMovementResponse) GetUpdateProtocol() string { + if x != nil { + return x.UpdateProtocol + } + return "" +} + +func (x *GetOrderbookMovementResponse) GetFullOrderbookSideConsumed() bool { + if x != nil { + return x.FullOrderbookSideConsumed + } + return false +} + +func (x *GetOrderbookMovementResponse) GetStartPrice() float64 { + if x != nil { + return x.StartPrice + } + return 0 +} + +func (x *GetOrderbookMovementResponse) GetEndPrice() float64 { + if x != nil { + return x.EndPrice + } + return 0 +} + +func (x *GetOrderbookMovementResponse) GetNoSlippageOccurred() bool { + if x != nil { + return x.NoSlippageOccurred + } + return false +} + +func (x *GetOrderbookMovementResponse) GetAverageOrderCost() float64 { + if x != nil { + return x.AverageOrderCost + } + return 0 +} + +type GetOrderbookAmountByNominalRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + NominalPercentage float64 `protobuf:"fixed64,6,opt,name=nominal_percentage,json=nominalPercentage,proto3" json:"nominal_percentage,omitempty"` + Sell bool `protobuf:"varint,7,opt,name=sell,proto3" json:"sell,omitempty"` + RequiresRestOrderbook bool `protobuf:"varint,8,opt,name=requires_rest_orderbook,json=requiresRestOrderbook,proto3" json:"requires_rest_orderbook,omitempty"` +} + +func (x *GetOrderbookAmountByNominalRequest) Reset() { + *x = GetOrderbookAmountByNominalRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[216] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbookAmountByNominalRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbookAmountByNominalRequest) ProtoMessage() {} + +func (x *GetOrderbookAmountByNominalRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[216] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrderbookAmountByNominalRequest.ProtoReflect.Descriptor instead. +func (*GetOrderbookAmountByNominalRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{216} +} + +func (x *GetOrderbookAmountByNominalRequest) GetExchange() string { + if x != nil { + return x.Exchange + } + return "" +} + +func (x *GetOrderbookAmountByNominalRequest) GetAsset() string { + if x != nil { + return x.Asset + } + return "" +} + +func (x *GetOrderbookAmountByNominalRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair + } + return nil +} + +func (x *GetOrderbookAmountByNominalRequest) GetNominalPercentage() float64 { + if x != nil { + return x.NominalPercentage + } + return 0 +} + +func (x *GetOrderbookAmountByNominalRequest) GetSell() bool { + if x != nil { + return x.Sell + } + return false +} + +func (x *GetOrderbookAmountByNominalRequest) GetRequiresRestOrderbook() bool { + if x != nil { + return x.RequiresRestOrderbook + } + return false +} + +type GetOrderbookAmountByNominalResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AmountRequired float64 `protobuf:"fixed64,1,opt,name=amount_required,json=amountRequired,proto3" json:"amount_required,omitempty"` + CurrencySelling string `protobuf:"bytes,2,opt,name=currency_selling,json=currencySelling,proto3" json:"currency_selling,omitempty"` + AmountReceived float64 `protobuf:"fixed64,3,opt,name=amount_received,json=amountReceived,proto3" json:"amount_received,omitempty"` + CurrencyBuying string `protobuf:"bytes,4,opt,name=currency_buying,json=currencyBuying,proto3" json:"currency_buying,omitempty"` + StartPrice float64 `protobuf:"fixed64,5,opt,name=start_price,json=startPrice,proto3" json:"start_price,omitempty"` + EndPrice float64 `protobuf:"fixed64,6,opt,name=end_price,json=endPrice,proto3" json:"end_price,omitempty"` + AverageOrderCost float64 `protobuf:"fixed64,7,opt,name=average_order_cost,json=averageOrderCost,proto3" json:"average_order_cost,omitempty"` + SideAffected string `protobuf:"bytes,8,opt,name=side_affected,json=sideAffected,proto3" json:"side_affected,omitempty"` + ApproximateNominalSlippagePercentage float64 `protobuf:"fixed64,9,opt,name=approximate_nominal_slippage_percentage,json=approximateNominalSlippagePercentage,proto3" json:"approximate_nominal_slippage_percentage,omitempty"` + UpdateProtocol string `protobuf:"bytes,10,opt,name=update_protocol,json=updateProtocol,proto3" json:"update_protocol,omitempty"` + FullOrderbookSideConsumed bool `protobuf:"varint,11,opt,name=full_orderbook_side_consumed,json=fullOrderbookSideConsumed,proto3" json:"full_orderbook_side_consumed,omitempty"` +} + +func (x *GetOrderbookAmountByNominalResponse) Reset() { + *x = GetOrderbookAmountByNominalResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[217] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbookAmountByNominalResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbookAmountByNominalResponse) ProtoMessage() {} + +func (x *GetOrderbookAmountByNominalResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[217] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrderbookAmountByNominalResponse.ProtoReflect.Descriptor instead. +func (*GetOrderbookAmountByNominalResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{217} +} + +func (x *GetOrderbookAmountByNominalResponse) GetAmountRequired() float64 { + if x != nil { + return x.AmountRequired + } + return 0 +} + +func (x *GetOrderbookAmountByNominalResponse) GetCurrencySelling() string { + if x != nil { + return x.CurrencySelling + } + return "" +} + +func (x *GetOrderbookAmountByNominalResponse) GetAmountReceived() float64 { + if x != nil { + return x.AmountReceived + } + return 0 +} + +func (x *GetOrderbookAmountByNominalResponse) GetCurrencyBuying() string { + if x != nil { + return x.CurrencyBuying + } + return "" +} + +func (x *GetOrderbookAmountByNominalResponse) GetStartPrice() float64 { + if x != nil { + return x.StartPrice + } + return 0 +} + +func (x *GetOrderbookAmountByNominalResponse) GetEndPrice() float64 { + if x != nil { + return x.EndPrice + } + return 0 +} + +func (x *GetOrderbookAmountByNominalResponse) GetAverageOrderCost() float64 { + if x != nil { + return x.AverageOrderCost + } + return 0 +} + +func (x *GetOrderbookAmountByNominalResponse) GetSideAffected() string { + if x != nil { + return x.SideAffected + } + return "" +} + +func (x *GetOrderbookAmountByNominalResponse) GetApproximateNominalSlippagePercentage() float64 { + if x != nil { + return x.ApproximateNominalSlippagePercentage + } + return 0 +} + +func (x *GetOrderbookAmountByNominalResponse) GetUpdateProtocol() string { + if x != nil { + return x.UpdateProtocol + } + return "" +} + +func (x *GetOrderbookAmountByNominalResponse) GetFullOrderbookSideConsumed() bool { + if x != nil { + return x.FullOrderbookSideConsumed + } + return false +} + +type GetOrderbookAmountByImpactRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` + ImpactPercentage float64 `protobuf:"fixed64,6,opt,name=impact_percentage,json=impactPercentage,proto3" json:"impact_percentage,omitempty"` + Sell bool `protobuf:"varint,7,opt,name=sell,proto3" json:"sell,omitempty"` + RequiresRestOrderbook bool `protobuf:"varint,8,opt,name=requires_rest_orderbook,json=requiresRestOrderbook,proto3" json:"requires_rest_orderbook,omitempty"` +} + +func (x *GetOrderbookAmountByImpactRequest) Reset() { + *x = GetOrderbookAmountByImpactRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[218] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbookAmountByImpactRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbookAmountByImpactRequest) ProtoMessage() {} + +func (x *GetOrderbookAmountByImpactRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[218] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrderbookAmountByImpactRequest.ProtoReflect.Descriptor instead. +func (*GetOrderbookAmountByImpactRequest) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{218} +} + +func (x *GetOrderbookAmountByImpactRequest) GetExchange() string { + if x != nil { + return x.Exchange + } + return "" +} + +func (x *GetOrderbookAmountByImpactRequest) GetAsset() string { + if x != nil { + return x.Asset + } + return "" +} + +func (x *GetOrderbookAmountByImpactRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair + } + return nil +} + +func (x *GetOrderbookAmountByImpactRequest) GetImpactPercentage() float64 { + if x != nil { + return x.ImpactPercentage + } + return 0 +} + +func (x *GetOrderbookAmountByImpactRequest) GetSell() bool { + if x != nil { + return x.Sell + } + return false +} + +func (x *GetOrderbookAmountByImpactRequest) GetRequiresRestOrderbook() bool { + if x != nil { + return x.RequiresRestOrderbook + } + return false +} + +type GetOrderbookAmountByImpactResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AmountRequired float64 `protobuf:"fixed64,1,opt,name=amount_required,json=amountRequired,proto3" json:"amount_required,omitempty"` + CurrencySelling string `protobuf:"bytes,2,opt,name=currency_selling,json=currencySelling,proto3" json:"currency_selling,omitempty"` + AmountReceived float64 `protobuf:"fixed64,3,opt,name=amount_received,json=amountReceived,proto3" json:"amount_received,omitempty"` + CurrencyBuying string `protobuf:"bytes,4,opt,name=currency_buying,json=currencyBuying,proto3" json:"currency_buying,omitempty"` + StartPrice float64 `protobuf:"fixed64,5,opt,name=start_price,json=startPrice,proto3" json:"start_price,omitempty"` + EndPrice float64 `protobuf:"fixed64,6,opt,name=end_price,json=endPrice,proto3" json:"end_price,omitempty"` + AverageOrderCost float64 `protobuf:"fixed64,7,opt,name=average_order_cost,json=averageOrderCost,proto3" json:"average_order_cost,omitempty"` + SideAffected string `protobuf:"bytes,8,opt,name=side_affected,json=sideAffected,proto3" json:"side_affected,omitempty"` + ApproximateImpactSlippagePercentage float64 `protobuf:"fixed64,9,opt,name=approximate_impact_slippage_percentage,json=approximateImpactSlippagePercentage,proto3" json:"approximate_impact_slippage_percentage,omitempty"` + UpdateProtocol string `protobuf:"bytes,10,opt,name=update_protocol,json=updateProtocol,proto3" json:"update_protocol,omitempty"` + FullOrderbookSideConsumed bool `protobuf:"varint,11,opt,name=full_orderbook_side_consumed,json=fullOrderbookSideConsumed,proto3" json:"full_orderbook_side_consumed,omitempty"` +} + +func (x *GetOrderbookAmountByImpactResponse) Reset() { + *x = GetOrderbookAmountByImpactResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[219] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbookAmountByImpactResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbookAmountByImpactResponse) ProtoMessage() {} + +func (x *GetOrderbookAmountByImpactResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[219] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOrderbookAmountByImpactResponse.ProtoReflect.Descriptor instead. +func (*GetOrderbookAmountByImpactResponse) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{219} +} + +func (x *GetOrderbookAmountByImpactResponse) GetAmountRequired() float64 { + if x != nil { + return x.AmountRequired + } + return 0 +} + +func (x *GetOrderbookAmountByImpactResponse) GetCurrencySelling() string { + if x != nil { + return x.CurrencySelling + } + return "" +} + +func (x *GetOrderbookAmountByImpactResponse) GetAmountReceived() float64 { + if x != nil { + return x.AmountReceived + } + return 0 +} + +func (x *GetOrderbookAmountByImpactResponse) GetCurrencyBuying() string { + if x != nil { + return x.CurrencyBuying + } + return "" +} + +func (x *GetOrderbookAmountByImpactResponse) GetStartPrice() float64 { + if x != nil { + return x.StartPrice + } + return 0 +} + +func (x *GetOrderbookAmountByImpactResponse) GetEndPrice() float64 { + if x != nil { + return x.EndPrice + } + return 0 } func (x *GetOrderbookAmountByImpactResponse) GetAverageOrderCost() float64 { @@ -14642,7 +15890,7 @@ var file_rpc_proto_rawDesc = []byte{ 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x22, 0xf7, 0x01, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4f, 0x72, 0x64, 0x65, + 0x74, 0x22, 0x98, 0x02, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, @@ -14657,413 +15905,463 @@ var file_rpc_proto_rawDesc = []byte{ 0x1b, 0x0a, 0x09, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x65, 0x0a, 0x06, 0x54, - 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14, 0x0a, - 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x70, 0x72, - 0x69, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x66, 0x65, 0x65, 0x5f, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x65, 0x65, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x22, 0x7b, 0x0a, 0x13, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x72, 0x64, - 0x65, 0x72, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x0b, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, - 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x6f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x64, 0x65, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x06, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x22, - 0x88, 0x01, 0x0a, 0x14, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x16, - 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, - 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x64, 0x65, 0x22, 0xf2, 0x01, 0x0a, 0x15, 0x53, - 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, - 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x06, 0x6f, 0x72, 0x64, - 0x65, 0x72, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x6d, - 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x01, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x50, 0x72, 0x69, 0x63, 0x65, - 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x70, 0x72, 0x69, 0x63, - 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, - 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, - 0x61, 0x67, 0x65, 0x5f, 0x67, 0x61, 0x69, 0x6e, 0x5f, 0x6c, 0x6f, 0x73, 0x73, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x12, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x47, - 0x61, 0x69, 0x6e, 0x4c, 0x6f, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, - 0xae, 0x01, 0x0a, 0x10, 0x57, 0x68, 0x61, 0x6c, 0x65, 0x42, 0x6f, 0x6d, 0x62, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, + 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0x65, 0x0a, 0x06, + 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14, + 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x70, + 0x72, 0x69, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x66, 0x65, 0x65, 0x5f, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x65, 0x65, 0x41, 0x73, + 0x73, 0x65, 0x74, 0x22, 0x7b, 0x0a, 0x13, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x72, + 0x64, 0x65, 0x72, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0b, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x12, 0x19, 0x0a, + 0x08, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x64, + 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x06, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, + 0x22, 0xa9, 0x01, 0x0a, 0x14, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, + 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x64, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, + 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0xf2, 0x01, 0x0a, + 0x15, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x06, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x23, 0x0a, + 0x0d, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x50, 0x72, 0x69, + 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x70, 0x72, + 0x69, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x6d, 0x61, 0x78, 0x69, 0x6d, + 0x75, 0x6d, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x70, 0x65, 0x72, 0x63, 0x65, + 0x6e, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x67, 0x61, 0x69, 0x6e, 0x5f, 0x6c, 0x6f, 0x73, 0x73, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x12, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, + 0x65, 0x47, 0x61, 0x69, 0x6e, 0x4c, 0x6f, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x22, 0xae, 0x01, 0x0a, 0x10, 0x57, 0x68, 0x61, 0x6c, 0x65, 0x42, 0x6f, 0x6d, 0x62, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x21, 0x0a, 0x0c, + 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x0b, 0x70, 0x72, 0x69, 0x63, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, + 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, + 0x69, 0x64, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, + 0x70, 0x65, 0x22, 0xee, 0x01, 0x0a, 0x12, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, + 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, + 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x77, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0d, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, + 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, + 0x69, 0x64, 0x65, 0x22, 0xf6, 0x01, 0x0a, 0x18, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, + 0x74, 0x63, 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, + 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x77, 0x61, 0x6c, 0x6c, 0x65, + 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x64, 0x65, 0x22, 0xa8, 0x01, 0x0a, + 0x06, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x12, 0x42, 0x0a, 0x0c, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x6f, 0x72, 0x64, 0x65, + 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0x3e, 0x0a, 0x10, 0x4f, 0x72, 0x64, 0x65, 0x72, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x43, 0x0a, 0x19, 0x43, 0x61, 0x6e, 0x63, 0x65, + 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, + 0x64, 0x65, 0x72, 0x73, 0x52, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x22, 0x34, 0x0a, 0x16, + 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x22, 0x57, 0x0a, 0x17, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, 0x6c, 0x6c, 0x4f, + 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, + 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x06, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x47, + 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, + 0xae, 0x01, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, + 0x5f, 0x62, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x63, 0x68, 0x65, + 0x63, 0x6b, 0x42, 0x69, 0x64, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, + 0x61, 0x73, 0x6b, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x63, 0x68, 0x65, 0x63, + 0x6b, 0x41, 0x73, 0x6b, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, + 0x6f, 0x6b, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x0f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, + 0x22, 0xf5, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x69, 0x74, 0x65, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x69, 0x74, 0x65, 0x6d, 0x12, 0x42, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, + 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x22, 0xe6, 0x01, 0x0a, 0x0f, 0x41, 0x64, 0x64, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, + 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x69, 0x74, 0x65, 0x6d, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x69, 0x74, 0x65, 0x6d, 0x12, 0x42, 0x0a, 0x10, + 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, + 0x0f, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, - 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x72, - 0x69, 0x63, 0x65, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x0b, 0x70, 0x72, 0x69, 0x63, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x12, 0x0a, - 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x64, - 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, - 0x22, 0xee, 0x01, 0x0a, 0x12, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, + 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x22, 0x0a, 0x10, 0x41, 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x02, 0x69, 0x64, 0x22, 0x24, 0x0a, 0x12, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x22, 0x46, 0x0a, 0x28, 0x47, + 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, + 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x69, - 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, - 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, 0x28, 0x0a, - 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, - 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, - 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, - 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a, - 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x64, - 0x65, 0x22, 0xf6, 0x01, 0x0a, 0x18, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, - 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, - 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, - 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x72, 0x64, - 0x65, 0x72, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x72, - 0x64, 0x65, 0x72, 0x73, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, - 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x25, 0x0a, 0x0e, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, - 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x41, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x64, 0x65, 0x22, 0xa8, 0x01, 0x0a, 0x06, 0x4f, - 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x12, 0x42, 0x0a, 0x0c, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0x3e, 0x0a, 0x10, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x43, 0x0a, 0x19, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, - 0x61, 0x74, 0x63, 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x73, 0x52, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x22, 0x34, 0x0a, 0x16, 0x43, 0x61, - 0x6e, 0x63, 0x65, 0x6c, 0x41, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x22, 0x57, 0x0a, 0x17, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, 0x6c, 0x6c, 0x4f, 0x72, 0x64, - 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x6f, - 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x06, 0x6f, 0x72, 0x64, - 0x65, 0x72, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x47, 0x65, 0x74, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xae, 0x01, - 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, - 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, - 0x70, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x62, - 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x63, 0x68, 0x65, 0x63, 0x6b, - 0x42, 0x69, 0x64, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x61, 0x73, - 0x6b, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x41, - 0x73, 0x6b, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, - 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x6f, - 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xf5, - 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x12, 0x0a, 0x04, 0x69, 0x74, 0x65, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, - 0x69, 0x74, 0x65, 0x6d, 0x12, 0x42, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, - 0x69, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, - 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x65, 0x78, - 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x22, 0xe6, 0x01, 0x0a, 0x0f, 0x41, 0x64, 0x64, 0x45, 0x76, - 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, - 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, - 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x69, 0x74, 0x65, 0x6d, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x69, 0x74, 0x65, 0x6d, 0x12, 0x42, 0x0a, 0x10, 0x63, 0x6f, - 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, - 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x0f, 0x63, - 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x28, - 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, - 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, - 0x22, 0x0a, 0x10, 0x41, 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x02, 0x69, 0x64, 0x22, 0x24, 0x0a, 0x12, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x22, 0x46, 0x0a, 0x28, 0x47, 0x65, 0x74, - 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x22, 0x52, 0x0a, 0x0e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, - 0x65, 0x73, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x10, 0x0a, - 0x03, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, - 0x14, 0x0a, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, - 0x63, 0x68, 0x61, 0x69, 0x6e, 0x22, 0x48, 0x0a, 0x10, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x09, 0x61, 0x64, 0x64, - 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, - 0x72, 0x65, 0x73, 0x73, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, - 0xe3, 0x01, 0x0a, 0x29, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, - 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, - 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x40, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, - 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, - 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x1a, 0x56, 0x0a, - 0x0e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, - 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, - 0x79, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9a, 0x01, 0x0a, 0x26, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, - 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, - 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x6e, 0x67, 0x65, 0x22, 0x52, 0x0a, 0x0e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, + 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, + 0x67, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x22, 0x48, 0x0a, 0x10, 0x44, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x09, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, + 0x73, 0x22, 0xe3, 0x01, 0x0a, 0x29, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x5e, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x40, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, + 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x1a, + 0x56, 0x0a, 0x0e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x6b, 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9a, 0x01, 0x0a, 0x26, 0x47, 0x65, 0x74, 0x43, + 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x26, + 0x0a, 0x0e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x16, 0x0a, 0x06, + 0x62, 0x79, 0x70, 0x61, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x62, 0x79, + 0x70, 0x61, 0x73, 0x73, 0x22, 0x55, 0x0a, 0x27, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, + 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x22, 0x67, 0x0a, 0x21, 0x47, + 0x65, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x63, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x79, - 0x70, 0x61, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x62, 0x79, 0x70, 0x61, - 0x73, 0x73, 0x22, 0x55, 0x0a, 0x27, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, - 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x61, 0x67, 0x22, 0x67, 0x0a, 0x21, 0x47, 0x65, 0x74, - 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, - 0x72, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, + 0x65, 0x6e, 0x63, 0x79, 0x22, 0x3c, 0x0a, 0x22, 0x47, 0x65, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, + 0x61, 0x62, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x69, + 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x63, 0x68, 0x61, 0x69, + 0x6e, 0x73, 0x22, 0xaf, 0x01, 0x0a, 0x13, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x46, + 0x69, 0x61, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x0a, 0x0f, + 0x62, 0x61, 0x6e, 0x6b, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x62, 0x61, 0x6e, 0x6b, 0x41, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x49, 0x64, 0x22, 0xec, 0x01, 0x0a, 0x15, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, + 0x77, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x63, 0x72, - 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x63, 0x79, 0x22, 0x3c, 0x0a, 0x22, 0x47, 0x65, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, - 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x68, 0x61, 0x69, - 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, - 0x22, 0xaf, 0x01, 0x0a, 0x13, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x46, 0x69, 0x61, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, - 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, - 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x0a, 0x0f, 0x62, 0x61, - 0x6e, 0x6b, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0d, 0x62, 0x61, 0x6e, 0x6b, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, - 0x49, 0x64, 0x22, 0xec, 0x01, 0x0a, 0x15, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43, - 0x72, 0x79, 0x70, 0x74, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, - 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, - 0x73, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x61, - 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, - 0x54, 0x61, 0x67, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, - 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, - 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x63, - 0x68, 0x61, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x68, 0x61, 0x69, - 0x6e, 0x22, 0x3a, 0x0a, 0x10, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x2c, 0x0a, - 0x1a, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, - 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x54, 0x0a, 0x1b, 0x57, - 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x79, - 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x65, 0x76, - 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, - 0x74, 0x22, 0xa0, 0x01, 0x0a, 0x21, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x5f, + 0x74, 0x61, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x54, 0x61, 0x67, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, + 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x22, 0x3a, 0x0a, 0x10, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, + 0x2c, 0x0a, 0x1a, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x54, 0x0a, + 0x1b, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x05, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x22, 0xa0, 0x01, 0x0a, 0x21, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, + 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x79, 0x0a, 0x1d, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, + 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x44, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x54, 0x79, 0x70, 0x65, 0x22, 0x79, 0x0a, 0x1d, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, - 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x44, 0x61, 0x74, 0x65, 0x52, 0x65, + 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6c, + 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x22, 0x5b, 0x0a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x95, + 0x02, 0x0a, 0x17, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x6c, 0x45, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0x54, 0x0a, 0x16, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, + 0x61, 0x77, 0x6c, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xea, 0x01, 0x0a, + 0x16, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x12, 0x2f, 0x0a, 0x04, 0x66, 0x69, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x61, 0x74, 0x57, 0x69, 0x74, + 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x04, 0x66, 0x69, + 0x61, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x52, 0x06, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x22, 0xb8, 0x01, 0x0a, 0x13, 0x46, 0x69, + 0x61, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x62, 0x61, 0x6e, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x62, 0x61, 0x6e, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, + 0x0a, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x62, 0x73, 0x62, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x62, 0x73, 0x62, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x77, + 0x69, 0x66, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x77, 0x69, 0x66, 0x74, + 0x12, 0x12, 0x0a, 0x04, 0x69, 0x62, 0x61, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x69, 0x62, 0x61, 0x6e, 0x22, 0x79, 0x0a, 0x15, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x57, 0x69, + 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x18, 0x0a, + 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x5f, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x54, 0x61, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x13, 0x0a, 0x05, 0x74, 0x78, + 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x78, 0x49, 0x64, 0x22, + 0x31, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x6f, + 0x67, 0x67, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6c, 0x6f, 0x67, 0x67, + 0x65, 0x72, 0x22, 0x6e, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, + 0x0a, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x69, 0x6e, + 0x66, 0x6f, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x77, 0x61, 0x72, 0x6e, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x77, 0x61, 0x72, 0x6e, 0x12, 0x14, 0x0a, 0x05, + 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x22, 0x47, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, + 0x06, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6c, + 0x6f, 0x67, 0x67, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x22, 0x4b, 0x0a, 0x17, 0x47, + 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0xd8, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, + 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x60, 0x0a, 0x10, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x35, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x2e, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x1a, 0x5a, 0x0a, 0x14, 0x53, 0x75, 0x70, 0x70, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x2c, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x69, 0x72, 0x73, 0x53, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x97, 0x01, 0x0a, 0x16, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, + 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x05, 0x70, 0x61, 0x69, + 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x05, + 0x70, 0x61, 0x69, 0x72, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x80, 0x01, + 0x0a, 0x19, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, + 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, + 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x22, 0x3f, 0x0a, 0x21, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, + 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, - 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, - 0x5b, 0x0a, 0x22, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, - 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x95, 0x02, 0x0a, - 0x17, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x6c, 0x45, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, - 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, - 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, - 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x75, 0x70, 0x64, - 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, - 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x64, 0x41, 0x74, 0x22, 0x54, 0x0a, 0x16, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, - 0x6c, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x12, - 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, - 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xea, 0x01, 0x0a, 0x16, 0x57, - 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, - 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, - 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, - 0x2f, 0x0a, 0x04, 0x66, 0x69, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x61, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, - 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x04, 0x66, 0x69, 0x61, 0x74, - 0x12, 0x35, 0x0a, 0x06, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, - 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, - 0x06, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x22, 0xb8, 0x01, 0x0a, 0x13, 0x46, 0x69, 0x61, 0x74, - 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, - 0x1b, 0x0a, 0x09, 0x62, 0x61, 0x6e, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x62, 0x61, 0x6e, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, - 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, - 0x25, 0x0a, 0x0e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, - 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, - 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x62, 0x73, 0x62, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x03, 0x62, 0x73, 0x62, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x77, 0x69, 0x66, - 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x77, 0x69, 0x66, 0x74, 0x12, 0x12, - 0x0a, 0x04, 0x69, 0x62, 0x61, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x69, 0x62, - 0x61, 0x6e, 0x22, 0x79, 0x0a, 0x15, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x57, 0x69, 0x74, 0x68, - 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x61, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, - 0x5f, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x64, 0x64, 0x72, - 0x65, 0x73, 0x73, 0x54, 0x61, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x13, 0x0a, 0x05, 0x74, 0x78, 0x5f, 0x69, - 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x78, 0x49, 0x64, 0x22, 0x31, 0x0a, - 0x17, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x6f, 0x67, 0x67, - 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x72, - 0x22, 0x6e, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x69, 0x6e, 0x66, 0x6f, - 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x77, 0x61, 0x72, 0x6e, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x77, 0x61, 0x72, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, - 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, - 0x22, 0x47, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6c, - 0x6f, 0x67, 0x67, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6c, 0x6f, 0x67, - 0x67, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x22, 0x4b, 0x0a, 0x17, 0x47, 0x65, 0x74, - 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0xd8, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x45, 0x78, - 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x60, 0x0a, 0x10, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, - 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, - 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x73, 0x1a, 0x5a, 0x0a, 0x14, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, - 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, - 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, - 0x2c, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x69, 0x72, 0x73, 0x53, 0x75, 0x70, - 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, - 0x01, 0x22, 0x97, 0x01, 0x0a, 0x16, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, - 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x05, 0x70, 0x61, - 0x69, 0x72, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x80, 0x01, 0x0a, 0x19, - 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, - 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x3f, - 0x0a, 0x21, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, - 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, - 0x7d, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, + 0x65, 0x22, 0x7d, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, + 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, + 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x22, 0x3c, 0x0a, 0x1e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, + 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x99, + 0x01, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, + 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x42, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x22, 0x43, 0x0a, 0x15, 0x47, 0x65, + 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x75, 0x64, + 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, + 0xa4, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, + 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x3c, - 0x0a, 0x1e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x69, 0x63, - 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x99, 0x01, 0x0a, - 0x14, 0x47, 0x65, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, - 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, - 0x19, 0x0a, 0x08, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x42, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, - 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, - 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x22, 0x43, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x41, - 0x75, 0x64, 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x75, 0x64, 0x69, 0x74, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xa4, 0x01, - 0x0a, 0x15, 0x47, 0x65, 0x74, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0x88, 0x01, 0x0a, 0x0b, 0x53, 0x61, 0x76, 0x65, 0x64, + 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, + 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x64, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x72, 0x61, 0x64, 0x65, 0x5f, + 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x72, 0x61, 0x64, 0x65, 0x49, + 0x64, 0x22, 0xa7, 0x01, 0x0a, 0x13, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0c, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x2b, + 0x0a, 0x06, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, + 0x64, 0x65, 0x73, 0x52, 0x06, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x22, 0xfb, 0x01, 0x0a, 0x1d, + 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x54, 0x6f, 0x43, + 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, + 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x69, + 0x6d, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, + 0x12, 0x0a, 0x04, 0x73, 0x79, 0x6e, 0x63, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, + 0x79, 0x6e, 0x63, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x22, 0xe6, 0x02, 0x0a, 0x19, 0x47, 0x65, + 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, @@ -15073,1191 +16371,1289 @@ var file_rpc_proto_rawDesc = []byte{ 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x03, 0x65, 0x6e, 0x64, 0x22, 0x88, 0x01, 0x0a, 0x0b, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, - 0x61, 0x64, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, - 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, - 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x73, 0x69, 0x64, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, - 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, - 0x74, 0x61, 0x6d, 0x70, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x69, 0x64, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x72, 0x61, 0x64, 0x65, 0x49, 0x64, 0x22, - 0xa7, 0x01, 0x0a, 0x13, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x2b, 0x0a, 0x06, - 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, - 0x73, 0x52, 0x06, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x22, 0xfb, 0x01, 0x0a, 0x1d, 0x43, 0x6f, - 0x6e, 0x76, 0x65, 0x72, 0x74, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x54, 0x6f, 0x43, 0x61, 0x6e, - 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, - 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x69, 0x6d, 0x65, - 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x12, 0x0a, - 0x04, 0x73, 0x79, 0x6e, 0x63, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x79, 0x6e, - 0x63, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x22, 0xe6, 0x02, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x48, - 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, - 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, - 0x6e, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x76, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x49, - 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x78, 0x5f, 0x72, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x65, 0x78, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x79, 0x6e, 0x63, 0x18, 0x08, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x79, 0x6e, 0x63, 0x12, 0x15, 0x0a, 0x06, 0x75, 0x73, - 0x65, 0x5f, 0x64, 0x62, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x75, 0x73, 0x65, 0x44, - 0x62, 0x12, 0x37, 0x0a, 0x18, 0x66, 0x69, 0x6c, 0x6c, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, - 0x67, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x18, 0x0a, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x15, 0x66, 0x69, 0x6c, 0x6c, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, - 0x57, 0x69, 0x74, 0x68, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, - 0x72, 0x63, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, - 0x22, 0xce, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, - 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x03, 0x65, 0x6e, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x74, 0x69, 0x6d, + 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x78, 0x5f, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x65, + 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x79, 0x6e, 0x63, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x79, 0x6e, 0x63, 0x12, 0x15, 0x0a, 0x06, + 0x75, 0x73, 0x65, 0x5f, 0x64, 0x62, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x75, 0x73, + 0x65, 0x44, 0x62, 0x12, 0x37, 0x0a, 0x18, 0x66, 0x69, 0x6c, 0x6c, 0x5f, 0x6d, 0x69, 0x73, 0x73, + 0x69, 0x6e, 0x67, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x66, 0x69, 0x6c, 0x6c, 0x4d, 0x69, 0x73, 0x73, 0x69, + 0x6e, 0x67, 0x57, 0x69, 0x74, 0x68, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, + 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, + 0x63, 0x65, 0x22, 0xce, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, + 0x69, 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, + 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, + 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, + 0x03, 0x65, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, + 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x26, 0x0a, 0x06, 0x63, + 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x06, 0x63, 0x61, 0x6e, + 0x64, 0x6c, 0x65, 0x22, 0xa3, 0x01, 0x0a, 0x06, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x12, + 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x69, + 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x6f, 0x70, 0x65, 0x6e, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x04, 0x6f, 0x70, 0x65, 0x6e, 0x12, 0x14, 0x0a, 0x05, + 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x63, 0x6c, 0x6f, + 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, + 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, + 0x69, 0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x22, 0x78, 0x0a, 0x0a, 0x41, 0x75, 0x64, + 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x22, 0x62, 0x0a, 0x09, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x75, 0x75, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x19, 0x0a, 0x08, + 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x6e, 0x65, 0x78, 0x74, 0x52, 0x75, 0x6e, 0x22, 0x44, 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x29, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x41, 0x0a, + 0x14, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x22, 0x19, 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, + 0x70, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x18, 0x0a, 0x16, 0x47, + 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x19, 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x22, 0xa8, 0x01, 0x0a, 0x16, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x55, 0x70, + 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, + 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x1a, 0x0a, 0x08, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x64, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x08, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x64, 0x12, 0x1c, 0x0a, + 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x22, 0x47, 0x0a, 0x1a, 0x47, + 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x65, 0x61, 0x64, 0x53, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x06, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x06, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x22, 0x42, 0x0a, 0x15, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, + 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x4a, 0x0a, 0x18, 0x47, 0x43, 0x54, 0x53, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x4c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x12, 0x16, 0x0a, 0x06, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x22, 0x5e, 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2b, 0x0a, 0x07, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x07, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x73, 0x22, 0x6f, 0x0a, 0x16, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x29, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x3d, 0x0a, 0x0f, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x64, 0x61, 0x74, 0x61, 0x22, 0x63, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, - 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, - 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, - 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x1a, 0x0a, - 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x26, 0x0a, 0x06, 0x63, 0x61, 0x6e, - 0x64, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x06, 0x63, 0x61, 0x6e, 0x64, 0x6c, - 0x65, 0x22, 0xa3, 0x01, 0x0a, 0x06, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, - 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x6c, - 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x01, 0x52, 0x04, 0x6f, 0x70, 0x65, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6c, - 0x6f, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x63, 0x6c, 0x6f, 0x73, 0x65, - 0x12, 0x16, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x70, - 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, - 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x22, 0x78, 0x0a, 0x0a, 0x41, 0x75, 0x64, 0x69, 0x74, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x69, 0x64, 0x65, - 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x69, - 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, - 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, - 0x61, 0x67, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, - 0x70, 0x22, 0x62, 0x0a, 0x09, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x12, 0x12, - 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, - 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, - 0x78, 0x74, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, - 0x78, 0x74, 0x52, 0x75, 0x6e, 0x22, 0x44, 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x29, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x41, 0x0a, 0x14, 0x47, - 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, - 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x19, - 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x41, - 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x18, 0x0a, 0x16, 0x47, 0x43, 0x54, - 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x22, 0x19, 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x4c, 0x69, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xa8, - 0x01, 0x0a, 0x16, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x55, 0x70, 0x6c, 0x6f, - 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x64, - 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, - 0x1a, 0x0a, 0x08, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x08, 0x61, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6f, - 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, - 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x22, 0x47, 0x0a, 0x1a, 0x47, 0x43, 0x54, - 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x65, 0x61, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x22, 0x42, 0x0a, 0x15, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x06, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x06, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x22, 0x4a, 0x0a, 0x18, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x4c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x22, 0x5e, 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, - 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2b, 0x0a, 0x07, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x73, - 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x07, 0x73, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x73, 0x22, 0x6f, 0x0a, 0x16, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x29, 0x0a, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, - 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x06, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x12, - 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, - 0x61, 0x74, 0x61, 0x22, 0x3d, 0x0a, 0x0f, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, - 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, - 0x74, 0x61, 0x22, 0x63, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, - 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, - 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x50, 0x0a, 0x1a, 0x53, 0x65, 0x74, 0x45, 0x78, - 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x41, 0x0a, 0x23, 0x55, 0x70, 0x64, - 0x61, 0x74, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6f, - 0x72, 0x74, 0x65, 0x64, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x36, 0x0a, 0x18, - 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x22, 0x33, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x22, 0x35, 0x0a, 0x17, 0x57, 0x65, 0x62, - 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x22, 0x93, 0x02, 0x0a, 0x18, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, - 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, - 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x75, 0x70, - 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x73, 0x75, - 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, - 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, - 0x64, 0x12, 0x37, 0x0a, 0x17, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, - 0x65, 0x64, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x16, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, - 0x64, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x24, 0x0a, 0x0d, 0x61, 0x75, - 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, - 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x75, 0x72, 0x6c, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x55, 0x72, - 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, - 0x73, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x41, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x50, 0x0a, 0x1a, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, - 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x3e, 0x0a, 0x20, 0x57, 0x65, 0x62, 0x73, + 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, + 0x74, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x50, 0x0a, 0x1a, 0x53, 0x65, 0x74, + 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x69, 0x72, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x41, 0x0a, 0x23, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x53, 0x75, 0x70, + 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x36, + 0x0a, 0x18, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, + 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x33, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x22, 0x35, 0x0a, 0x17, 0x57, + 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x22, 0x93, 0x02, 0x0a, 0x18, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, + 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, + 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x64, 0x12, 0x37, 0x0a, 0x17, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x24, 0x0a, 0x0d, + 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, + 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x75, 0x72, + 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, + 0x55, 0x72, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x5f, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x72, 0x6f, 0x78, + 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x50, 0x0a, 0x1a, 0x57, 0x65, 0x62, 0x73, + 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x3e, 0x0a, 0x20, 0x57, 0x65, + 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, + 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x7b, 0x0a, 0x15, 0x57, 0x65, + 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x1a, 0x0a, + 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x84, 0x01, 0x0a, 0x21, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x7b, 0x0a, 0x15, 0x57, 0x65, 0x62, 0x73, - 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x1a, 0x0a, 0x08, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x16, 0x0a, - 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, - 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x84, 0x01, 0x0a, 0x21, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, - 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x43, 0x0a, 0x0d, 0x73, 0x75, 0x62, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, - 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x73, - 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x4c, 0x0a, 0x18, - 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x78, - 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x46, 0x0a, 0x16, 0x57, 0x65, - 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, - 0x72, 0x6c, 0x22, 0xd3, 0x01, 0x0a, 0x1f, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, - 0x6e, 0x67, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, - 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, - 0x70, 0x61, 0x69, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, - 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0xb6, 0x01, 0x0a, 0x1e, 0x46, 0x69, 0x6e, - 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x72, 0x61, 0x64, 0x65, 0x50, 0x65, 0x72, - 0x69, 0x6f, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0c, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, - 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, - 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, - 0x64, 0x22, 0xcd, 0x01, 0x0a, 0x1c, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, - 0x67, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, - 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, 0x69, - 0x6f, 0x64, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x73, 0x73, 0x69, - 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x22, 0x57, 0x0a, 0x21, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x54, 0x72, 0x61, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x52, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, + 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x43, 0x0a, 0x0d, 0x73, 0x75, 0x62, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, + 0x6b, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x0d, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x4c, + 0x0a, 0x18, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x50, 0x72, + 0x6f, 0x78, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x22, 0x46, 0x0a, 0x16, + 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xa3, 0x06, 0x0a, 0x1b, 0x55, - 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, - 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, - 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, + 0x67, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x75, 0x72, 0x6c, 0x22, 0xd3, 0x01, 0x0a, 0x1f, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, + 0x73, 0x69, 0x6e, 0x67, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, + 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x28, 0x0a, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, + 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, + 0x61, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, + 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0xb6, 0x01, 0x0a, 0x1e, 0x46, + 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x72, 0x61, 0x64, 0x65, 0x50, + 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, + 0x0d, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x65, 0x6e, 0x64, 0x22, 0xcd, 0x01, 0x0a, 0x1c, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, + 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x73, + 0x73, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x22, 0x57, 0x0a, 0x21, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x54, 0x72, 0x61, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xa3, 0x06, 0x0a, + 0x1b, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, + 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, + 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, + 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x1a, + 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x53, + 0x69, 0x7a, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x61, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x64, 0x61, 0x74, + 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x74, + 0x72, 0x79, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x10, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, 0x6d, + 0x70, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x7a, + 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x53, 0x69, + 0x7a, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x5f, 0x6f, 0x6e, 0x6c, + 0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x4f, + 0x6e, 0x6c, 0x79, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x65, + 0x72, 0x76, 0x61, 0x6c, 0x12, 0x36, 0x0a, 0x17, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x5f, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, + 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, + 0x45, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x3a, 0x0a, 0x19, + 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x5f, 0x6a, 0x6f, 0x62, + 0x5f, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x17, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x4a, 0x6f, 0x62, + 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x64, 0x65, 0x63, 0x69, + 0x6d, 0x61, 0x6c, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, + 0x69, 0x73, 0x6f, 0x6e, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x16, 0x64, 0x65, 0x63, 0x69, + 0x6d, 0x61, 0x6c, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, + 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x17, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, + 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x11, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x15, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x45, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3c, 0x0a, 0x1a, 0x69, 0x73, + 0x73, 0x75, 0x65, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x70, 0x65, + 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x01, 0x52, 0x18, + 0x69, 0x73, 0x73, 0x75, 0x65, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x50, 0x65, + 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6c, + 0x61, 0x63, 0x65, 0x5f, 0x6f, 0x6e, 0x5f, 0x69, 0x73, 0x73, 0x75, 0x65, 0x18, 0x13, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x4f, 0x6e, 0x49, 0x73, 0x73, + 0x75, 0x65, 0x22, 0x56, 0x0a, 0x1b, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x53, 0x65, 0x71, 0x75, + 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x4a, 0x6f, 0x62, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x37, 0x0a, 0x04, 0x6a, 0x6f, 0x62, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, + 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x52, 0x04, 0x6a, 0x6f, 0x62, 0x73, 0x22, 0x58, 0x0a, 0x1c, 0x49, 0x6e, + 0x73, 0x65, 0x72, 0x74, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x4a, 0x6f, + 0x62, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x04, 0x6a, 0x6f, + 0x62, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x04, + 0x6a, 0x6f, 0x62, 0x73, 0x22, 0x4f, 0x0a, 0x1c, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, + 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x15, + 0x0a, 0x06, 0x6a, 0x6f, 0x62, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x6a, 0x6f, 0x62, 0x49, 0x64, 0x22, 0x70, 0x0a, 0x1f, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, + 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, 0x6b, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x66, 0x75, 0x6c, 0x6c, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x87, 0x07, 0x0a, 0x0e, 0x44, 0x61, 0x74, 0x61, + 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, + 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, - 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x1a, 0x0a, 0x08, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x08, + 0x65, 0x73, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x53, 0x69, 0x7a, - 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x64, 0x61, 0x74, 0x61, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x79, - 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x10, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, - 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, - 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x53, 0x69, 0x7a, 0x65, - 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, - 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x4f, 0x6e, 0x6c, - 0x79, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, - 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, - 0x61, 0x6c, 0x12, 0x36, 0x0a, 0x17, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, - 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0e, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x15, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x45, 0x78, - 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x72, - 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x6e, - 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x70, - 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x4e, 0x69, - 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, - 0x6c, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, - 0x6f, 0x6e, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, 0x16, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, - 0x6c, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, - 0x12, 0x36, 0x0a, 0x17, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x78, - 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x15, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x45, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3c, 0x0a, 0x1a, 0x69, 0x73, 0x73, 0x75, - 0x65, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x63, - 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x01, 0x52, 0x18, 0x69, 0x73, - 0x73, 0x75, 0x65, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x50, 0x65, 0x72, 0x63, - 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, - 0x65, 0x5f, 0x6f, 0x6e, 0x5f, 0x69, 0x73, 0x73, 0x75, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x4f, 0x6e, 0x49, 0x73, 0x73, 0x75, 0x65, - 0x22, 0x56, 0x0a, 0x1b, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, - 0x74, 0x69, 0x61, 0x6c, 0x4a, 0x6f, 0x62, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x37, 0x0a, 0x04, 0x6a, 0x6f, 0x62, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, - 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x52, 0x04, 0x6a, 0x6f, 0x62, 0x73, 0x22, 0x58, 0x0a, 0x1c, 0x49, 0x6e, 0x73, 0x65, - 0x72, 0x74, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x4a, 0x6f, 0x62, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x04, 0x6a, 0x6f, 0x62, 0x73, - 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x04, 0x6a, 0x6f, - 0x62, 0x73, 0x22, 0x4f, 0x0a, 0x1c, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, - 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x15, 0x0a, 0x06, - 0x6a, 0x6f, 0x62, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6a, 0x6f, - 0x62, 0x49, 0x64, 0x22, 0x70, 0x0a, 0x1f, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, - 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, - 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x66, 0x75, 0x6c, 0x6c, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x87, 0x07, 0x0a, 0x0e, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, - 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, 0x6b, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, - 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, - 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, - 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x09, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x10, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x4c, - 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x74, 0x72, - 0x79, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x10, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, - 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x7a, 0x65, - 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x53, 0x69, 0x7a, - 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x64, 0x61, 0x74, - 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x61, - 0x74, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x0e, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, - 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x36, 0x0a, 0x17, 0x6f, 0x76, 0x65, 0x72, 0x77, - 0x72, 0x69, 0x74, 0x65, 0x5f, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x61, - 0x74, 0x61, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, - 0x69, 0x74, 0x65, 0x45, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, - 0x3a, 0x0a, 0x19, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x5f, - 0x6a, 0x6f, 0x62, 0x5f, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x10, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x17, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, - 0x4a, 0x6f, 0x62, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x64, - 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x6d, - 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x18, 0x11, 0x20, 0x01, 0x28, 0x03, 0x52, 0x16, 0x64, - 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x61, - 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x17, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, - 0x72, 0x79, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, - 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3c, 0x0a, - 0x1a, 0x69, 0x73, 0x73, 0x75, 0x65, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, - 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, - 0x01, 0x52, 0x18, 0x69, 0x73, 0x73, 0x75, 0x65, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, - 0x65, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x72, - 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x5f, 0x6f, 0x6e, 0x5f, 0x69, 0x73, 0x73, 0x75, 0x65, 0x18, - 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x4f, 0x6e, - 0x49, 0x73, 0x73, 0x75, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x6a, 0x6f, 0x62, 0x5f, 0x72, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x73, 0x18, 0x15, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, - 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x0a, 0x6a, 0x6f, 0x62, 0x52, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5f, 0x73, - 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x69, 0x65, 0x73, 0x18, 0x16, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, - 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x69, 0x65, 0x73, 0x22, - 0xa0, 0x01, 0x0a, 0x14, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, - 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, - 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, - 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x68, 0x61, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x68, 0x61, 0x73, 0x44, 0x61, 0x74, 0x61, 0x12, 0x18, 0x0a, - 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x75, 0x6e, 0x5f, 0x64, - 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x75, 0x6e, 0x44, 0x61, - 0x74, 0x65, 0x22, 0x43, 0x0a, 0x0f, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, - 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x07, - 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x5c, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x44, 0x61, - 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x42, 0x65, 0x74, - 0x77, 0x65, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, - 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, - 0x64, 0x44, 0x61, 0x74, 0x65, 0x22, 0x64, 0x0a, 0x1e, 0x53, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, - 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, - 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x81, 0x01, 0x0a, 0x27, - 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x4a, 0x6f, 0x62, 0x50, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, - 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, - 0x69, 0x74, 0x65, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, - 0x73, 0x69, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x22, - 0xb9, 0x01, 0x0a, 0x12, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, 0x28, 0x0a, - 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, - 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x16, 0x0a, - 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x41, 0x0a, 0x13, 0x4d, - 0x6f, 0x64, 0x69, 0x66, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x6f, - 0x72, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6d, - 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64, 0x22, 0x38, - 0x0a, 0x1a, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x47, - 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x63, 0x0a, 0x1b, 0x43, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0x67, 0x0a, - 0x1f, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, - 0x61, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, - 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0x64, 0x0a, 0x1c, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0x63, 0x0a, 0x1b, - 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x44, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x22, 0x57, 0x0a, 0x15, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0f, 0x63, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x22, 0xbe, 0x01, 0x0a, 0x0d, 0x43, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1a, 0x0a, 0x08, - 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x29, - 0x0a, 0x10, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, - 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, - 0x61, 0x77, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x0e, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x45, 0x6e, 0x61, 0x62, 0x6c, - 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x65, 0x6e, - 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x74, 0x72, 0x61, - 0x64, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x22, 0x4f, 0x0a, 0x0b, 0x46, - 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, - 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x12, 0x12, - 0x0a, 0x04, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x61, - 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0xde, 0x03, 0x0a, - 0x0b, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1a, 0x0a, 0x08, + 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, + 0x74, 0x72, 0x79, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x10, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x74, 0x72, 0x79, 0x41, 0x74, 0x74, 0x65, + 0x6d, 0x70, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, + 0x7a, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x53, + 0x69, 0x7a, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0c, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x64, + 0x61, 0x74, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x64, 0x61, 0x74, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, + 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x36, 0x0a, 0x17, 0x6f, 0x76, 0x65, + 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, + 0x64, 0x61, 0x74, 0x61, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x6f, 0x76, 0x65, 0x72, + 0x77, 0x72, 0x69, 0x74, 0x65, 0x45, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, + 0x61, 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, + 0x65, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x10, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, + 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x38, 0x0a, + 0x18, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x5f, 0x63, + 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x18, 0x11, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x16, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x43, 0x6f, 0x6d, + 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x17, 0x73, 0x65, 0x63, 0x6f, 0x6e, + 0x64, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, + 0x61, 0x72, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x3c, 0x0a, 0x1a, 0x69, 0x73, 0x73, 0x75, 0x65, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, + 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x13, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x18, 0x69, 0x73, 0x73, 0x75, 0x65, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, + 0x6e, 0x63, 0x65, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x28, 0x0a, + 0x10, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x5f, 0x6f, 0x6e, 0x5f, 0x69, 0x73, 0x73, 0x75, + 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, + 0x4f, 0x6e, 0x49, 0x73, 0x73, 0x75, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x6a, 0x6f, 0x62, 0x5f, 0x72, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x15, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, + 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x0a, 0x6a, 0x6f, 0x62, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x69, 0x65, 0x73, 0x18, 0x16, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x69, 0x65, + 0x73, 0x22, 0xa0, 0x01, 0x0a, 0x14, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, + 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, + 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, + 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x68, 0x61, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x68, 0x61, 0x73, 0x44, 0x61, 0x74, 0x61, 0x12, + 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x75, 0x6e, + 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x75, 0x6e, + 0x44, 0x61, 0x74, 0x65, 0x22, 0x43, 0x0a, 0x0f, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x12, 0x30, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, + 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x5c, 0x0a, 0x20, 0x47, 0x65, 0x74, + 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x42, + 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, + 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, + 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x22, 0x64, 0x0a, 0x1e, 0x53, 0x65, 0x74, 0x44, 0x61, + 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, + 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, + 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x81, 0x01, + 0x0a, 0x27, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x50, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, + 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, + 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, + 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x73, 0x69, 0x74, 0x65, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, + 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, + 0x65, 0x22, 0xb9, 0x01, 0x0a, 0x12, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x4f, 0x72, 0x64, 0x65, + 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64, 0x12, + 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, + 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x41, 0x0a, + 0x13, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0f, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64, + 0x22, 0x38, 0x0a, 0x1a, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, + 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x63, 0x0a, 0x1b, 0x43, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x69, + 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, + 0x67, 0x0a, 0x1f, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x12, + 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0x64, 0x0a, 0x1c, 0x43, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, + 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, + 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0x63, + 0x0a, 0x1b, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x44, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x22, 0x57, 0x0a, 0x15, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0f, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0e, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x22, 0xbe, 0x01, 0x0a, + 0x0d, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1a, + 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, + 0x12, 0x29, 0x0a, 0x10, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x5f, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x77, 0x69, 0x74, 0x68, + 0x64, 0x72, 0x61, 0x77, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x64, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x45, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, + 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x74, + 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x22, 0x4f, 0x0a, + 0x0b, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, + 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x72, 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0xde, + 0x03, 0x0a, 0x0b, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1a, + 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, + 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, + 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x61, + 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, + 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, + 0x29, 0x0a, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, + 0x61, 0x74, 0x65, 0x52, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x0b, 0x6c, 0x61, + 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x52, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, + 0x12, 0x38, 0x0a, 0x0d, 0x75, 0x70, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x61, 0x74, + 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, 0x0c, 0x75, 0x70, + 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, + 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x75, 0x6d, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x6d, 0x12, 0x27, 0x0a, 0x0f, 0x70, + 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x29, 0x0a, 0x11, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6f, 0x66, 0x5f, + 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x4f, 0x66, 0x4e, 0x65, 0x78, 0x74, 0x52, 0x61, 0x74, 0x65, 0x22, + 0x9c, 0x08, 0x0a, 0x14, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x44, 0x0a, 0x1e, 0x6d, 0x61, 0x69, 0x6e, + 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x72, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x1c, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x61, 0x72, + 0x67, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x3c, + 0x0a, 0x1a, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, + 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x18, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x4d, 0x61, 0x72, 0x67, 0x69, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x3e, 0x0a, 0x1b, + 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x19, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x4c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0f, + 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x55, 0x73, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x70, 0x72, + 0x69, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x72, 0x6b, 0x50, + 0x72, 0x69, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, + 0x73, 0x69, 0x7a, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x62, 0x72, 0x65, 0x61, 0x6b, + 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0e, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x45, 0x76, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x70, 0x65, + 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x61, + 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, + 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x50, 0x6e, 0x6c, 0x12, 0x27, + 0x0a, 0x0f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x46, + 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x66, 0x72, 0x65, 0x65, 0x5f, + 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0e, 0x66, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x12, 0x29, 0x0a, 0x10, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x74, 0x6f, 0x74, 0x61, + 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x66, + 0x72, 0x6f, 0x7a, 0x65, 0x6e, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x0d, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0d, 0x66, 0x72, 0x6f, 0x7a, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x65, 0x71, 0x75, 0x69, 0x74, 0x79, 0x5f, 0x6f, 0x66, 0x5f, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, + 0x65, 0x71, 0x75, 0x69, 0x74, 0x79, 0x4f, 0x66, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, + 0x12, 0x29, 0x0a, 0x10, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x65, 0x71, + 0x75, 0x69, 0x74, 0x79, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x76, 0x61, 0x69, + 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x45, 0x71, 0x75, 0x69, 0x74, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x63, + 0x61, 0x73, 0x68, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x63, 0x61, 0x73, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x27, + 0x0a, 0x0f, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x65, 0x71, 0x75, 0x69, 0x74, + 0x79, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x45, 0x71, 0x75, 0x69, 0x74, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x71, 0x75, 0x69, 0x74, + 0x79, 0x5f, 0x75, 0x73, 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x71, 0x75, + 0x69, 0x74, 0x79, 0x55, 0x73, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x73, 0x6f, 0x6c, 0x61, 0x74, + 0x65, 0x64, 0x5f, 0x65, 0x71, 0x75, 0x69, 0x74, 0x79, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0e, 0x69, 0x73, 0x6f, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x45, 0x71, 0x75, 0x69, 0x74, 0x79, 0x12, + 0x31, 0x0a, 0x14, 0x69, 0x73, 0x6f, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x61, 0x62, + 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x69, + 0x73, 0x6f, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x4c, 0x69, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, + 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x73, 0x6f, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, + 0x70, 0x6c, 0x18, 0x15, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x73, 0x6f, 0x6c, 0x61, 0x74, + 0x65, 0x64, 0x55, 0x70, 0x6c, 0x12, 0x2b, 0x0a, 0x11, 0x6e, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x10, 0x6e, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, + 0x67, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x65, 0x71, 0x75, 0x69, + 0x74, 0x79, 0x18, 0x17, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x45, + 0x71, 0x75, 0x69, 0x74, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, + 0x79, 0x5f, 0x65, 0x71, 0x75, 0x69, 0x74, 0x79, 0x18, 0x18, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x45, 0x71, 0x75, 0x69, 0x74, 0x79, 0x22, 0xca, + 0x05, 0x0a, 0x0e, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x16, 0x0a, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, + 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x65, + 0x6e, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x65, 0x6e, + 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x10, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x44, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, + 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x70, + 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x70, + 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x2b, 0x0a, + 0x11, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, + 0x21, 0x0a, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, + 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x69, + 0x7a, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, + 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x75, 0x6e, 0x72, 0x65, + 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x61, + 0x6c, 0x69, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x21, 0x0a, 0x0c, + 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x0e, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x65, 0x12, + 0x1f, 0x0a, 0x0b, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0f, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x2c, 0x0a, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x43, + 0x0a, 0x0e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, + 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x52, 0x0d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, + 0x61, 0x74, 0x73, 0x12, 0x36, 0x0a, 0x0c, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x0b, + 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x22, 0xd3, 0x02, 0x0a, 0x19, + 0x47, 0x65, 0x74, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, + 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, + 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x35, 0x0a, 0x17, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, + 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, + 0x75, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x12, 0x30, 0x0a, 0x14, + 0x67, 0x65, 0x74, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x67, 0x65, 0x74, 0x46, + 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3b, + 0x0a, 0x1a, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x66, + 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x17, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x46, + 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, + 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x52, 0x61, 0x74, + 0x65, 0x22, 0xfb, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x61, 0x6e, 0x61, + 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x17, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x66, + 0x75, 0x6c, 0x6c, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, + 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x12, 0x30, 0x0a, 0x14, 0x67, 0x65, + 0x74, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x67, 0x65, 0x74, 0x46, 0x75, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3b, 0x0a, 0x1a, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x66, 0x75, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x17, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x46, 0x75, 0x6e, + 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x72, + 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x22, + 0x53, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, + 0x0a, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x74, 0x75, 0x72, + 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xbe, 0x01, 0x0a, 0x21, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, + 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, + 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x3d, 0x0a, 0x0f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, + 0x79, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x0e, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, + 0x67, 0x50, 0x61, 0x69, 0x72, 0x22, 0xc5, 0x01, 0x0a, 0x22, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, + 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x75, 0x6d, + 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, - 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x61, 0x79, 0x6d, - 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, - 0x6e, 0x63, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, - 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, - 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, - 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, - 0x65, 0x52, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x0b, 0x6c, 0x61, 0x74, 0x65, - 0x73, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, - 0x74, 0x65, 0x52, 0x0a, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, 0x38, - 0x0a, 0x0d, 0x75, 0x70, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, - 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, 0x0c, 0x75, 0x70, 0x63, 0x6f, - 0x6d, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x79, 0x6d, - 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x75, 0x6d, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, - 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x6d, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x61, 0x79, - 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0b, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0e, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x12, 0x29, 0x0a, 0x11, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6f, 0x66, 0x5f, 0x6e, 0x65, - 0x78, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, - 0x69, 0x6d, 0x65, 0x4f, 0x66, 0x4e, 0x65, 0x78, 0x74, 0x52, 0x61, 0x74, 0x65, 0x22, 0xb9, 0x04, - 0x0a, 0x14, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x44, 0x0a, 0x1e, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, - 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x71, - 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1c, - 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x61, 0x72, 0x67, 0x69, - 0x6e, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x3c, 0x0a, 0x1a, - 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x72, - 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x18, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, - 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x3e, 0x0a, 0x1b, 0x65, 0x73, - 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x19, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, - 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x55, - 0x73, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x70, 0x72, 0x69, 0x63, - 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x72, 0x6b, 0x50, 0x72, 0x69, - 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x69, - 0x7a, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x74, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x5f, 0x65, - 0x76, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0e, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x45, 0x76, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, - 0x2c, 0x0a, 0x12, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x5f, - 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x61, 0x76, 0x65, - 0x72, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1d, 0x0a, - 0x0a, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x09, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x50, 0x6e, 0x6c, 0x12, 0x27, 0x0a, 0x0f, - 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, - 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x46, 0x72, 0x61, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x66, 0x72, 0x65, 0x65, 0x5f, 0x63, 0x6f, - 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, - 0x66, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x29, - 0x0a, 0x10, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, - 0x61, 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, - 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x22, 0xca, 0x05, 0x0a, 0x0e, 0x46, 0x75, - 0x74, 0x75, 0x72, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, + 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x43, 0x0a, 0x0e, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, + 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0d, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x22, 0xef, 0x02, + 0x0a, 0x20, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x3d, + 0x0a, 0x0f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x69, + 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x0e, 0x75, + 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, + 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, + 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x3f, 0x0a, 0x1c, 0x72, 0x65, 0x73, 0x70, 0x65, + 0x63, 0x74, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, + 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x19, 0x72, + 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x35, 0x0a, 0x17, 0x73, 0x79, 0x6e, 0x63, + 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x6e, 0x61, + 0x67, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x73, 0x79, 0x6e, 0x63, 0x57, + 0x69, 0x74, 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x22, + 0x59, 0x0a, 0x21, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x4c, 0x0a, 0x18, 0x47, 0x65, + 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x22, 0x76, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x43, + 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, + 0x22, 0x75, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, - 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, - 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x61, 0x74, 0x65, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x44, - 0x61, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x64, - 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, - 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x72, 0x69, 0x63, - 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, - 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x70, 0x65, 0x6e, 0x69, 0x6e, 0x67, - 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x65, - 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x74, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x72, 0x65, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, - 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0b, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x25, 0x0a, - 0x0e, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x6e, 0x6c, 0x18, - 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, - 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, - 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x61, 0x6c, - 0x69, 0x73, 0x65, 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x69, - 0x6e, 0x67, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, - 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x72, - 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2c, 0x0a, 0x06, 0x6f, - 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x52, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x43, 0x0a, 0x0e, 0x70, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x74, 0x75, 0x72, - 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, - 0x0d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x36, - 0x0a, 0x0c, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x12, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, - 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x0b, 0x66, 0x75, 0x6e, 0x64, 0x69, - 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x22, 0xd3, 0x02, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x4d, 0x61, - 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x27, + 0x0a, 0x0f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x6d, 0x6f, 0x64, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x67, 0x0a, 0x19, 0x53, 0x65, 0x74, 0x43, 0x6f, + 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, - 0x12, 0x35, 0x0a, 0x17, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x66, 0x75, 0x6c, 0x6c, - 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x4f, 0x72, - 0x64, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x12, 0x30, 0x0a, 0x14, 0x67, 0x65, 0x74, 0x5f, 0x66, - 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x67, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, - 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3b, 0x0a, 0x1a, 0x69, 0x6e, 0x63, - 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, - 0x67, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, - 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, - 0x65, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x61, 0x74, 0x65, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, - 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x22, 0xfb, 0x01, 0x0a, - 0x1d, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, - 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, - 0x0a, 0x17, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x6f, - 0x72, 0x64, 0x65, 0x72, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x44, 0x61, 0x74, 0x61, 0x12, 0x30, 0x0a, 0x14, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x75, 0x6e, - 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x12, 0x67, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, - 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3b, 0x0a, 0x1a, 0x69, 0x6e, 0x63, 0x6c, 0x75, - 0x64, 0x65, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, - 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x69, 0x6e, 0x63, - 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, - 0x61, 0x74, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, - 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, 0x65, - 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x22, 0x53, 0x0a, 0x1b, 0x47, 0x65, - 0x74, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x70, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x50, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, - 0x99, 0x04, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, - 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, + 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, + 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, + 0x22, 0x72, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x22, 0x94, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, + 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, - 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, - 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, - 0x44, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x25, 0x0a, 0x0e, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, - 0x6d, 0x69, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, 0x65, - 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69, 0x74, - 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x67, - 0x65, 0x74, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, - 0x35, 0x0a, 0x17, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, - 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x4f, 0x72, 0x64, - 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x12, 0x30, 0x0a, 0x14, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x75, - 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x0b, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x67, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, - 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3b, 0x0a, 0x1a, 0x69, 0x6e, 0x63, 0x6c, - 0x75, 0x64, 0x65, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, - 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x69, 0x6e, - 0x63, 0x6c, 0x75, 0x64, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, - 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, - 0x5f, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, - 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, - 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x22, 0x94, 0x02, 0x0a, 0x1b, - 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, - 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x1f, - 0x0a, 0x0b, 0x73, 0x75, 0x62, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x75, 0x62, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, - 0x2c, 0x0a, 0x12, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, - 0x64, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x74, 0x6f, 0x74, - 0x61, 0x6c, 0x52, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x30, 0x0a, - 0x14, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, - 0x64, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x74, 0x6f, 0x74, - 0x61, 0x6c, 0x55, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x50, 0x6e, 0x6c, 0x12, - 0x1b, 0x0a, 0x09, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x6e, 0x6c, 0x12, 0x34, 0x0a, 0x09, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x50, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x22, 0xd2, 0x01, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, - 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, + 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, + 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0xa9, 0x02, 0x0a, 0x1b, + 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x61, + 0x72, 0x67, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x2b, 0x0a, - 0x11, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, - 0x77, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, - 0x65, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x61, - 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x5f, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, - 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x69, 0x6e, 0x63, 0x6c, 0x75, - 0x64, 0x65, 0x5f, 0x7a, 0x65, 0x72, 0x6f, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5a, 0x65, 0x72, - 0x6f, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0xbe, 0x05, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x43, - 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x75, 0x62, 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x75, 0x62, 0x41, 0x63, 0x63, 0x6f, 0x75, - 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, - 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x12, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x43, 0x75, 0x72, 0x72, 0x65, - 0x6e, 0x63, 0x79, 0x12, 0x4f, 0x0a, 0x25, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x5f, 0x6f, 0x66, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x73, - 0x70, 0x6f, 0x74, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x66, - 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x70, 0x6f, 0x74, 0x42, 0x61, 0x6c, 0x61, - 0x6e, 0x63, 0x65, 0x73, 0x12, 0x65, 0x0a, 0x30, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, - 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x5f, 0x62, - 0x79, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, - 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x2b, - 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, - 0x62, 0x75, 0x74, 0x65, 0x64, 0x42, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, - 0x70, 0x6f, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x75, - 0x73, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x75, 0x73, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, - 0x65, 0x72, 0x61, 0x6c, 0x12, 0x46, 0x0a, 0x0e, 0x75, 0x73, 0x65, 0x64, 0x5f, 0x62, 0x72, 0x65, - 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, - 0x55, 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x0d, 0x75, - 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x31, 0x0a, 0x14, - 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, - 0x65, 0x72, 0x61, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x61, 0x76, 0x61, 0x69, - 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, - 0x35, 0x0a, 0x16, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x63, - 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x15, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x6f, 0x6c, 0x6c, - 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, - 0x69, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, - 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x4c, 0x0a, - 0x12, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x64, - 0x6f, 0x77, 0x6e, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x46, 0x6f, 0x72, - 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x11, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x63, 0x79, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x4b, 0x0a, 0x12, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, - 0x6e, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x79, 0x50, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42, - 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x22, 0xf7, 0x04, 0x0a, 0x15, 0x43, 0x6f, 0x6c, - 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x63, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x38, - 0x0a, 0x18, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, - 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x16, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f, - 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, - 0x6c, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, - 0x6f, 0x74, 0x61, 0x6c, 0x46, 0x75, 0x6e, 0x64, 0x73, 0x12, 0x44, 0x0a, 0x1f, 0x61, 0x76, 0x61, - 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x75, 0x73, 0x65, 0x5f, 0x61, - 0x73, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x1b, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x46, 0x6f, 0x72, - 0x55, 0x73, 0x65, 0x41, 0x73, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, - 0x37, 0x0a, 0x18, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x5f, 0x66, 0x61, 0x69, 0x72, 0x5f, 0x6d, - 0x61, 0x72, 0x6b, 0x65, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x15, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x46, 0x61, 0x69, 0x72, 0x4d, 0x61, 0x72, - 0x6b, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x77, 0x65, 0x69, 0x67, - 0x68, 0x74, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x77, 0x65, 0x69, - 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x12, 0x37, 0x0a, 0x17, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, - 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, - 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x16, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, - 0x72, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x2c, 0x0a, 0x12, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x73, 0x63, 0x61, - 0x6c, 0x65, 0x64, 0x54, 0x6f, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x25, 0x0a, - 0x0e, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x6e, 0x6c, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, - 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x20, 0x0a, 0x0c, 0x66, 0x75, 0x6e, 0x64, 0x73, 0x5f, 0x69, 0x6e, - 0x5f, 0x75, 0x73, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x75, 0x6e, 0x64, - 0x73, 0x49, 0x6e, 0x55, 0x73, 0x65, 0x12, 0x3c, 0x0a, 0x1a, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, - 0x75, 0x73, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x61, 0x64, 0x64, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, - 0x55, 0x73, 0x65, 0x64, 0x12, 0x46, 0x0a, 0x0e, 0x75, 0x73, 0x65, 0x64, 0x5f, 0x62, 0x72, 0x65, - 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, - 0x55, 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x0d, 0x75, - 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x14, 0x0a, 0x05, - 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, - 0x6f, 0x72, 0x22, 0x8f, 0x02, 0x0a, 0x14, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, - 0x6c, 0x42, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x6f, - 0x70, 0x65, 0x6e, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x6e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x53, - 0x69, 0x7a, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, - 0x73, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x72, 0x6b, - 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, - 0x72, 0x6b, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, - 0x72, 0x65, 0x64, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, - 0x12, 0x32, 0x0a, 0x15, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, - 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x13, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, - 0x55, 0x73, 0x65, 0x64, 0x22, 0xae, 0x03, 0x0a, 0x17, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, - 0x72, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, - 0x12, 0x28, 0x0a, 0x10, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x73, 0x74, - 0x61, 0x6b, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6c, 0x6f, 0x63, 0x6b, - 0x65, 0x64, 0x49, 0x6e, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x12, 0x6c, 0x6f, - 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x6e, 0x66, 0x74, 0x5f, 0x62, 0x69, 0x64, 0x73, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, - 0x4e, 0x66, 0x74, 0x42, 0x69, 0x64, 0x73, 0x12, 0x31, 0x0a, 0x15, 0x6c, 0x6f, 0x63, 0x6b, 0x65, - 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x76, 0x6f, 0x75, 0x63, 0x68, 0x65, 0x72, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, - 0x46, 0x65, 0x65, 0x56, 0x6f, 0x75, 0x63, 0x68, 0x65, 0x72, 0x12, 0x4d, 0x0a, 0x24, 0x6c, 0x6f, - 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x6d, 0x61, 0x72, - 0x67, 0x69, 0x6e, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x66, 0x66, 0x65, - 0x72, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1f, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, - 0x49, 0x6e, 0x53, 0x70, 0x6f, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x46, 0x75, 0x6e, 0x64, - 0x69, 0x6e, 0x67, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x73, 0x12, 0x31, 0x0a, 0x15, 0x6c, 0x6f, 0x63, - 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x6f, 0x72, 0x64, 0x65, - 0x72, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, - 0x49, 0x6e, 0x53, 0x70, 0x6f, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x30, 0x0a, 0x14, - 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x61, 0x73, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, - 0x65, 0x72, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6c, 0x6f, 0x63, 0x6b, - 0x65, 0x64, 0x41, 0x73, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x26, - 0x0a, 0x0f, 0x75, 0x73, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, - 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x75, 0x73, 0x65, 0x64, 0x49, 0x6e, 0x46, - 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x13, 0x75, 0x73, 0x65, 0x64, 0x5f, 0x69, - 0x6e, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x18, 0x08, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x10, 0x75, 0x73, 0x65, 0x64, 0x49, 0x6e, 0x53, 0x70, 0x6f, 0x74, 0x4d, - 0x61, 0x72, 0x67, 0x69, 0x6e, 0x22, 0xe7, 0x02, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x46, 0x75, 0x6e, - 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, - 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, - 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, - 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, - 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x65, - 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x6e, - 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x12, 0x29, - 0x0a, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, - 0x74, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, - 0x65, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x72, 0x65, 0x73, - 0x70, 0x65, 0x63, 0x74, 0x5f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, - 0x69, 0x74, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x72, 0x65, 0x73, 0x70, 0x65, - 0x63, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x22, - 0x44, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, - 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x05, 0x72, 0x61, - 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x05, - 0x72, 0x61, 0x74, 0x65, 0x73, 0x22, 0xa6, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, - 0x65, 0x73, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, + 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, + 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, + 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, + 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x6f, 0x72, 0x69, 0x67, + 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6d, + 0x61, 0x72, 0x67, 0x69, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x17, 0x6f, 0x72, 0x69, + 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x4d, 0x61, + 0x72, 0x67, 0x69, 0x6e, 0x12, 0x30, 0x0a, 0x14, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, + 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x12, 0x6e, 0x65, 0x77, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, + 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, + 0x5f, 0x73, 0x69, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, 0x72, + 0x67, 0x69, 0x6e, 0x53, 0x69, 0x64, 0x65, 0x22, 0xee, 0x01, 0x0a, 0x1c, 0x43, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, + 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x6c, 0x6c, + 0x6f, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x12, 0x6e, 0x65, 0x77, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x65, + 0x64, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, + 0x6e, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, + 0x72, 0x67, 0x69, 0x6e, 0x53, 0x69, 0x64, 0x65, 0x22, 0x93, 0x01, 0x0a, 0x14, 0x53, 0x65, 0x74, + 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1f, 0x0a, + 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0x8d, + 0x01, 0x0a, 0x15, 0x53, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x22, 0xef, + 0x01, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, - 0x72, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x65, - 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x6e, - 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x22, 0x47, - 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, - 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, - 0x0a, 0x04, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, - 0x61, 0x52, 0x04, 0x72, 0x61, 0x74, 0x65, 0x22, 0x11, 0x0a, 0x0f, 0x53, 0x68, 0x75, 0x74, 0x64, - 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x53, 0x68, - 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa1, - 0x05, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, - 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, - 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, - 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x72, 0x12, 0x3d, 0x0a, 0x0f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x5f, + 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, + 0x52, 0x0e, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, 0x72, + 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x69, 0x64, 0x65, + 0x22, 0x8c, 0x02, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, - 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x6c, 0x67, - 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x30, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, - 0x70, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x2c, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, - 0x70, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, - 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x1f, - 0x0a, 0x0b, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x09, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x61, 0x73, 0x74, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, - 0x1f, 0x0a, 0x0b, 0x73, 0x6c, 0x6f, 0x77, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x0a, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x6c, 0x6f, 0x77, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, - 0x12, 0x32, 0x0a, 0x15, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x5f, 0x64, 0x65, 0x76, - 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x75, 0x70, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x13, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x55, 0x70, 0x12, 0x36, 0x0a, 0x17, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, - 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x18, - 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x44, - 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x6f, 0x77, 0x6e, 0x12, 0x2e, 0x0a, 0x13, - 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x5f, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x6d, 0x6f, 0x76, 0x69, 0x6e, - 0x67, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, - 0x6f, 0x74, 0x68, 0x65, 0x72, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x0e, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x45, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x0a, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x5f, 0x70, 0x61, 0x69, - 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x09, 0x6f, - 0x74, 0x68, 0x65, 0x72, 0x50, 0x61, 0x69, 0x72, 0x12, 0x28, 0x0a, 0x10, 0x6f, 0x74, 0x68, 0x65, - 0x72, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x10, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, - 0x70, 0x65, 0x22, 0x29, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x4f, 0x66, 0x53, 0x69, 0x67, 0x6e, - 0x61, 0x6c, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x01, 0x52, 0x07, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x22, 0xbe, 0x01, - 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, - 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4b, - 0x0a, 0x07, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x31, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x65, 0x63, 0x68, - 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x52, 0x07, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x1a, 0x51, 0x0a, 0x0c, 0x53, - 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2b, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4f, 0x66, 0x53, 0x69, 0x67, 0x6e, - 0x61, 0x6c, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x83, - 0x04, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, - 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1d, 0x0a, - 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, - 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x67, 0x65, 0x74, 0x5f, 0x70, - 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x10, 0x67, 0x65, 0x74, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, - 0x64, 0x52, 0x61, 0x74, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x67, 0x65, 0x74, 0x5f, 0x6c, 0x65, 0x6e, - 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x07, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x12, 0x67, 0x65, 0x74, 0x4c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, - 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x67, 0x65, 0x74, 0x5f, 0x62, - 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0e, 0x67, 0x65, 0x74, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x74, 0x65, - 0x73, 0x12, 0x28, 0x0a, 0x10, 0x67, 0x65, 0x74, 0x5f, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, - 0x63, 0x6f, 0x73, 0x74, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x67, 0x65, 0x74, - 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x43, 0x6f, 0x73, 0x74, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, - 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x41, - 0x6c, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x61, 0x6c, 0x63, 0x75, - 0x6c, 0x61, 0x74, 0x65, 0x5f, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x0b, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x10, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x66, 0x66, - 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x74, 0x61, 0x6b, 0x65, 0x72, 0x5f, 0x66, 0x65, - 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x74, 0x61, - 0x6b, 0x65, 0x72, 0x46, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x72, 0x61, - 0x74, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x52, 0x05, 0x72, - 0x61, 0x74, 0x65, 0x73, 0x22, 0x3e, 0x0a, 0x0e, 0x4c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, - 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, - 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, - 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, - 0x73, 0x69, 0x7a, 0x65, 0x22, 0x34, 0x0a, 0x0a, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x43, 0x6f, - 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x22, 0xe2, 0x02, 0x0a, 0x0a, 0x4d, - 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x69, 0x6d, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x2c, 0x0a, - 0x12, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x5f, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x73, - 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6d, 0x61, 0x72, 0x6b, 0x65, - 0x74, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x68, - 0x6f, 0x75, 0x72, 0x6c, 0x79, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0a, 0x68, 0x6f, 0x75, 0x72, 0x6c, 0x79, 0x52, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, - 0x79, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0a, 0x79, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x52, 0x61, 0x74, 0x65, 0x12, 0x2c, 0x0a, - 0x12, 0x68, 0x6f, 0x75, 0x72, 0x6c, 0x79, 0x5f, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x72, - 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x68, 0x6f, 0x75, 0x72, 0x6c, - 0x79, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x74, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x79, - 0x65, 0x61, 0x72, 0x6c, 0x79, 0x5f, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, 0x74, - 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x79, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x42, - 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x74, 0x65, 0x12, 0x3f, 0x0a, 0x0f, 0x6c, 0x65, 0x6e, - 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x65, 0x6e, 0x64, - 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0e, 0x6c, 0x65, 0x6e, 0x64, - 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x33, 0x0a, 0x0b, 0x62, 0x6f, - 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x43, - 0x6f, 0x73, 0x74, 0x52, 0x0a, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x43, 0x6f, 0x73, 0x74, 0x22, - 0xae, 0x03, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, - 0x65, 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x28, 0x0a, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, - 0x52, 0x61, 0x74, 0x65, 0x52, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x74, - 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, - 0x73, 0x75, 0x6d, 0x5f, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x73, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x75, 0x6d, 0x42, 0x6f, 0x72, 0x72, 0x6f, - 0x77, 0x43, 0x6f, 0x73, 0x74, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x61, 0x76, 0x67, 0x5f, 0x62, 0x6f, - 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0d, 0x61, 0x76, 0x67, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x30, - 0x0a, 0x14, 0x73, 0x75, 0x6d, 0x5f, 0x6c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, - 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x73, 0x75, - 0x6d, 0x4c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x12, 0x28, 0x0a, 0x10, 0x61, 0x76, 0x67, 0x5f, 0x6c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, - 0x73, 0x69, 0x7a, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x76, 0x67, 0x4c, - 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x33, 0x0a, 0x0b, 0x6c, 0x61, - 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, - 0x61, 0x74, 0x65, 0x52, 0x0a, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, - 0x39, 0x0a, 0x0e, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x61, 0x74, - 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x70, 0x72, 0x65, - 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x74, 0x61, - 0x6b, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0c, 0x74, 0x61, 0x6b, 0x65, 0x72, 0x46, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, - 0x22, 0xf9, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, - 0x6b, 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x70, 0x61, 0x69, 0x72, 0x12, 0x3d, 0x0a, 0x0f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, + 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, + 0x61, 0x69, 0x72, 0x52, 0x0e, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x50, + 0x61, 0x69, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, + 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x69, 0x64, 0x65, 0x22, + 0x8b, 0x02, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x12, 0x3d, 0x0a, 0x0f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, + 0x5f, 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, + 0x72, 0x52, 0x0e, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, + 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x1d, + 0x0a, 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x69, 0x64, 0x65, 0x22, 0x8a, 0x02, + 0x0a, 0x13, 0x53, 0x65, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, + 0x72, 0x12, 0x3d, 0x0a, 0x0f, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x5f, + 0x70, 0x61, 0x69, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, + 0x52, 0x0e, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, 0x72, + 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x69, 0x64, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x22, 0xd2, 0x01, 0x0a, 0x14, 0x47, + 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, + 0x5f, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, + 0x77, 0x6e, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x5f, + 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x63, + 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x12, + 0x2e, 0x0a, 0x13, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x7a, 0x65, 0x72, 0x6f, 0x5f, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5a, 0x65, 0x72, 0x6f, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, + 0xbe, 0x05, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x75, 0x62, + 0x5f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, + 0x73, 0x75, 0x62, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, + 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x4f, 0x0a, 0x25, 0x74, + 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x6f, 0x66, 0x5f, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x62, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x20, 0x74, 0x6f, 0x74, 0x61, + 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x66, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, + 0x53, 0x70, 0x6f, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x65, 0x0a, 0x30, + 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x76, 0x65, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x2b, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x64, 0x42, 0x79, 0x50, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x53, 0x70, 0x6f, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x75, 0x73, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, + 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x75, 0x73, + 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x46, 0x0a, 0x0e, + 0x75, 0x73, 0x65, 0x64, 0x5f, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, + 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, + 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x0d, 0x75, 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, 0x6b, + 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x31, 0x0a, 0x14, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, + 0x65, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x13, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x6c, + 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x35, 0x0a, 0x16, 0x6d, 0x61, 0x69, 0x6e, 0x74, + 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, + 0x61, 0x6e, 0x63, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x25, + 0x0a, 0x0e, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x6e, 0x6c, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, + 0x65, 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x4c, 0x0a, 0x12, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x5f, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x0a, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, + 0x52, 0x11, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, + 0x6f, 0x77, 0x6e, 0x12, 0x4b, 0x0a, 0x12, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x62, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x42, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, + 0x22, 0xf7, 0x04, 0x0a, 0x15, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x46, + 0x6f, 0x72, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x38, 0x0a, 0x18, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x64, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, + 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x64, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x46, 0x75, 0x6e, 0x64, + 0x73, 0x12, 0x44, 0x0a, 0x1f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x66, + 0x6f, 0x72, 0x5f, 0x75, 0x73, 0x65, 0x5f, 0x61, 0x73, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1b, 0x61, 0x76, 0x61, 0x69, + 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x41, 0x73, 0x43, 0x6f, 0x6c, + 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x37, 0x0a, 0x18, 0x61, 0x70, 0x70, 0x72, 0x6f, + 0x78, 0x5f, 0x66, 0x61, 0x69, 0x72, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x5f, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x61, 0x70, 0x70, 0x72, 0x6f, + 0x78, 0x46, 0x61, 0x69, 0x72, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x12, 0x1c, 0x0a, 0x09, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x12, 0x37, + 0x0a, 0x17, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x16, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x0a, 0x12, 0x73, 0x63, 0x61, 0x6c, 0x65, + 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x10, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x54, 0x6f, 0x43, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x75, 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, + 0x73, 0x65, 0x64, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x75, + 0x6e, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x64, 0x50, 0x6e, 0x6c, 0x12, 0x20, 0x0a, 0x0c, + 0x66, 0x75, 0x6e, 0x64, 0x73, 0x5f, 0x69, 0x6e, 0x5f, 0x75, 0x73, 0x65, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x66, 0x75, 0x6e, 0x64, 0x73, 0x49, 0x6e, 0x55, 0x73, 0x65, 0x12, 0x3c, + 0x0a, 0x1a, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6c, + 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x18, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x43, 0x6f, + 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x64, 0x12, 0x46, 0x0a, 0x0e, + 0x75, 0x73, 0x65, 0x64, 0x5f, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, + 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, + 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x0d, 0x75, 0x73, 0x65, 0x64, 0x42, 0x72, 0x65, 0x61, 0x6b, + 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x0d, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x8f, 0x02, 0x0a, 0x14, 0x43, + 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x42, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, + 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, + 0x69, 0x7a, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x6f, 0x72, 0x64, 0x65, + 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6f, 0x70, + 0x65, 0x6e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0c, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, + 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x61, 0x72, 0x6b, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, + 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x6d, 0x61, 0x72, 0x67, + 0x69, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x64, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x12, 0x32, 0x0a, 0x15, 0x74, 0x6f, 0x74, 0x61, + 0x6c, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x75, 0x73, 0x65, + 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, + 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x64, 0x22, 0xae, 0x03, 0x0a, + 0x17, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x64, 0x42, + 0x72, 0x65, 0x61, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x28, 0x0a, 0x10, 0x6c, 0x6f, 0x63, 0x6b, + 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x6b, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x53, 0x74, 0x61, 0x6b, + 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x12, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, + 0x6e, 0x66, 0x74, 0x5f, 0x62, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, + 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x4e, 0x66, 0x74, 0x42, 0x69, 0x64, 0x73, 0x12, + 0x31, 0x0a, 0x15, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x66, 0x65, 0x65, + 0x5f, 0x76, 0x6f, 0x75, 0x63, 0x68, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, + 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x46, 0x65, 0x65, 0x56, 0x6f, 0x75, 0x63, 0x68, + 0x65, 0x72, 0x12, 0x4d, 0x0a, 0x24, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, + 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x5f, 0x66, 0x75, 0x6e, 0x64, + 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x66, 0x66, 0x65, 0x72, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x1f, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x53, 0x70, 0x6f, 0x74, 0x4d, 0x61, + 0x72, 0x67, 0x69, 0x6e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x66, 0x66, 0x65, 0x72, + 0x73, 0x12, 0x31, 0x0a, 0x15, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x73, + 0x70, 0x6f, 0x74, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x12, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x49, 0x6e, 0x53, 0x70, 0x6f, 0x74, 0x4f, 0x72, + 0x64, 0x65, 0x72, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x61, + 0x73, 0x5f, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x12, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x41, 0x73, 0x43, 0x6f, 0x6c, 0x6c, + 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x26, 0x0a, 0x0f, 0x75, 0x73, 0x65, 0x64, 0x5f, 0x69, + 0x6e, 0x5f, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x75, 0x73, 0x65, 0x64, 0x49, 0x6e, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x2d, + 0x0a, 0x13, 0x75, 0x73, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x6d, + 0x61, 0x72, 0x67, 0x69, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x75, 0x73, 0x65, + 0x64, 0x49, 0x6e, 0x53, 0x70, 0x6f, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x22, 0xe7, 0x02, + 0x0a, 0x16, 0x47, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, + 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, + 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, 0x29, + 0x0a, 0x10, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, + 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, 0x65, + 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x12, 0x34, 0x0a, 0x16, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x5f, 0x68, 0x69, 0x73, + 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x14, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, + 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x22, 0x44, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x46, 0x75, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x29, 0x0a, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x22, 0xa6, 0x01, + 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, + 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, + 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, + 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, 0x65, + 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x22, 0x47, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, + 0x65, 0x73, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x04, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x04, 0x72, 0x61, 0x74, 0x65, 0x22, + 0x11, 0x0a, 0x0f, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x22, 0x12, 0x0a, 0x10, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa1, 0x05, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x54, 0x65, + 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x16, 0x0a, 0x06, - 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, - 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x6c, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x04, 0x73, 0x65, 0x6c, 0x6c, 0x12, 0x36, 0x0a, 0x17, 0x72, 0x65, 0x71, 0x75, - 0x69, 0x72, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, - 0x6f, 0x6f, 0x6b, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x72, 0x65, 0x71, 0x75, 0x69, - 0x72, 0x65, 0x73, 0x52, 0x65, 0x73, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, - 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x18, 0x09, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x08, 0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x22, 0xc6, 0x04, 0x0a, - 0x1c, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, 0x76, - 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2d, 0x0a, - 0x12, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, - 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, - 0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x2b, 0x0a, 0x11, - 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x50, - 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6c, 0x69, - 0x70, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x0c, 0x73, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x27, - 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x62, 0x6f, 0x75, 0x67, 0x68, - 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, - 0x79, 0x42, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x6f, 0x75, 0x67, 0x68, - 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x62, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x12, - 0x23, 0x0a, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x73, 0x6f, 0x6c, 0x64, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, - 0x53, 0x6f, 0x6c, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x6f, 0x6c, 0x64, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x01, 0x52, 0x04, 0x73, 0x6f, 0x6c, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x69, 0x64, 0x65, - 0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0c, 0x73, 0x69, 0x64, 0x65, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x12, 0x27, 0x0a, - 0x0f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, - 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, - 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x3f, 0x0a, 0x1c, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x6f, - 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x63, 0x6f, - 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x19, 0x66, 0x75, - 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x69, 0x64, 0x65, 0x43, - 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x6e, 0x64, 0x5f, - 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x65, 0x6e, 0x64, - 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6e, 0x6f, 0x5f, 0x73, 0x6c, 0x69, 0x70, - 0x70, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x18, 0x0d, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x12, 0x6e, 0x6f, 0x53, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x4f, - 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x76, 0x65, 0x72, 0x61, - 0x67, 0x65, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x0e, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x10, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x43, 0x6f, 0x73, 0x74, 0x22, 0xfb, 0x01, 0x0a, 0x22, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, - 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, - 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, - 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, - 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6d, 0x69, - 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, - 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x6c, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x65, 0x6c, 0x6c, 0x12, 0x36, 0x0a, 0x17, 0x72, - 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x72, 0x64, - 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x72, 0x65, - 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x52, 0x65, 0x73, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, - 0x6f, 0x6f, 0x6b, 0x22, 0x9d, 0x04, 0x0a, 0x23, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, - 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, 0x6d, 0x69, - 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x61, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, - 0x69, 0x72, 0x65, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, - 0x5f, 0x73, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, - 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x12, - 0x27, 0x0a, 0x0f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, - 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, - 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x62, 0x75, 0x79, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x42, 0x75, 0x79, 0x69, 0x6e, - 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x72, 0x69, - 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x6e, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, + 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x1d, 0x0a, 0x0a, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x61, + 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x30, + 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x12, 0x2c, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x16, + 0x0a, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, + 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, + 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x66, 0x61, 0x73, + 0x74, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6c, 0x6f, 0x77, 0x5f, + 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x6c, + 0x6f, 0x77, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x32, 0x0a, 0x15, 0x73, 0x74, 0x61, 0x6e, + 0x64, 0x61, 0x72, 0x64, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x75, + 0x70, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x13, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, + 0x64, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x12, 0x36, 0x0a, 0x17, + 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x73, + 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x44, 0x6f, 0x77, 0x6e, 0x12, 0x2e, 0x0a, 0x13, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x5f, 0x61, + 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x11, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x5f, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6f, 0x74, + 0x68, 0x65, 0x72, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x0a, 0x6f, + 0x74, 0x68, 0x65, 0x72, 0x5f, 0x70, 0x61, 0x69, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x09, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x50, 0x61, 0x69, 0x72, + 0x12, 0x28, 0x0a, 0x10, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6f, 0x74, 0x68, 0x65, + 0x72, 0x41, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x29, 0x0a, 0x0d, 0x4c, 0x69, + 0x73, 0x74, 0x4f, 0x66, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x73, + 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x01, 0x52, 0x07, 0x73, 0x69, + 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x22, 0xbe, 0x01, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x54, 0x65, 0x63, + 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4b, 0x0a, 0x07, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x47, 0x65, 0x74, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, + 0x6c, 0x79, 0x73, 0x69, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x69, + 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x6c, 0x73, 0x1a, 0x51, 0x0a, 0x0c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x4f, 0x66, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x83, 0x04, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x4d, 0x61, + 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, + 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x44, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x44, 0x61, 0x74, 0x65, 0x12, + 0x2c, 0x0a, 0x12, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, + 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x67, 0x65, 0x74, + 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x52, 0x61, 0x74, 0x65, 0x12, 0x30, 0x0a, + 0x14, 0x67, 0x65, 0x74, 0x5f, 0x6c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x67, 0x65, 0x74, + 0x4c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, + 0x28, 0x0a, 0x10, 0x67, 0x65, 0x74, 0x5f, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, + 0x74, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x67, 0x65, 0x74, 0x42, 0x6f, + 0x72, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x67, 0x65, 0x74, + 0x5f, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x73, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0e, 0x67, 0x65, 0x74, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x43, 0x6f, + 0x73, 0x74, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x61, + 0x6c, 0x6c, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x41, 0x6c, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, + 0x2b, 0x0a, 0x11, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x5f, 0x6f, 0x66, 0x66, + 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x63, 0x61, 0x6c, 0x63, + 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x24, 0x0a, 0x0e, + 0x74, 0x61, 0x6b, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x74, 0x61, 0x6b, 0x65, 0x72, 0x46, 0x65, 0x65, 0x52, 0x61, + 0x74, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x72, 0x67, 0x69, + 0x6e, 0x52, 0x61, 0x74, 0x65, 0x52, 0x05, 0x72, 0x61, 0x74, 0x65, 0x73, 0x22, 0x3e, 0x0a, 0x0e, + 0x4c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x18, + 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x22, 0x34, 0x0a, 0x0a, + 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x12, 0x12, + 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, + 0x7a, 0x65, 0x22, 0xe2, 0x02, 0x0a, 0x0a, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, + 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x5f, + 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x10, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x53, + 0x69, 0x7a, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x6f, 0x75, 0x72, 0x6c, 0x79, 0x5f, 0x72, 0x61, + 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x68, 0x6f, 0x75, 0x72, 0x6c, 0x79, + 0x52, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x79, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x5f, 0x72, + 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x79, 0x65, 0x61, 0x72, 0x6c, + 0x79, 0x52, 0x61, 0x74, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x68, 0x6f, 0x75, 0x72, 0x6c, 0x79, 0x5f, + 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x10, 0x68, 0x6f, 0x75, 0x72, 0x6c, 0x79, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x52, + 0x61, 0x74, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x79, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x5f, 0x62, 0x6f, + 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x10, 0x79, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x74, + 0x65, 0x12, 0x3f, 0x0a, 0x0f, 0x6c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, + 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, + 0x6e, 0x74, 0x52, 0x0e, 0x6c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6d, 0x65, + 0x6e, 0x74, 0x12, 0x33, 0x0a, 0x0b, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x73, + 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x43, 0x6f, 0x73, 0x74, 0x52, 0x0a, 0x62, 0x6f, 0x72, + 0x72, 0x6f, 0x77, 0x43, 0x6f, 0x73, 0x74, 0x22, 0xae, 0x03, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x4d, + 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, + 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x72, 0x61, 0x74, + 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x52, 0x05, 0x72, 0x61, + 0x74, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x72, 0x61, 0x74, + 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x52, + 0x61, 0x74, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x75, 0x6d, 0x5f, 0x62, 0x6f, 0x72, 0x72, + 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, + 0x73, 0x75, 0x6d, 0x42, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x43, 0x6f, 0x73, 0x74, 0x73, 0x12, 0x26, + 0x0a, 0x0f, 0x61, 0x76, 0x67, 0x5f, 0x62, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x5f, 0x73, 0x69, 0x7a, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x76, 0x67, 0x42, 0x6f, 0x72, 0x72, + 0x6f, 0x77, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x73, 0x75, 0x6d, 0x5f, 0x6c, 0x65, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x73, 0x75, 0x6d, 0x4c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x61, 0x76, 0x67, 0x5f, + 0x6c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x61, 0x76, 0x67, 0x4c, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x69, + 0x7a, 0x65, 0x12, 0x33, 0x0a, 0x0b, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x72, 0x61, 0x74, + 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x6c, 0x61, 0x74, + 0x65, 0x73, 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, 0x39, 0x0a, 0x0e, 0x70, 0x72, 0x65, 0x64, 0x69, + 0x63, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, + 0x61, 0x74, 0x65, 0x52, 0x0d, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x65, 0x64, 0x52, 0x61, + 0x74, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x74, 0x61, 0x6b, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x65, 0x5f, + 0x72, 0x61, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x74, 0x61, 0x6b, 0x65, + 0x72, 0x46, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x22, 0xf9, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, + 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, + 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, + 0x70, 0x61, 0x69, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, + 0x73, 0x65, 0x6c, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x65, 0x6c, 0x6c, + 0x12, 0x36, 0x0a, 0x17, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x73, + 0x74, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x15, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x52, 0x65, 0x73, 0x74, 0x4f, + 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x75, 0x72, 0x63, + 0x68, 0x61, 0x73, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x70, 0x75, 0x72, 0x63, + 0x68, 0x61, 0x73, 0x65, 0x22, 0xc6, 0x04, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, + 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, + 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x11, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, + 0x74, 0x61, 0x67, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x70, + 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x10, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, + 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x73, 0x6c, 0x69, 0x70, 0x70, 0x61, + 0x67, 0x65, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x5f, 0x62, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x42, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x62, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x06, 0x62, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x5f, 0x73, 0x6f, 0x6c, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x6f, 0x6c, 0x64, 0x12, 0x12, 0x0a, 0x04, + 0x73, 0x6f, 0x6c, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x04, 0x73, 0x6f, 0x6c, 0x64, + 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, + 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x69, 0x64, 0x65, 0x41, 0x66, 0x66, + 0x65, 0x63, 0x74, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x3f, + 0x0a, 0x1c, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, + 0x5f, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x19, 0x66, 0x75, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, + 0x6f, 0x6f, 0x6b, 0x53, 0x69, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x12, + 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x72, 0x69, 0x63, 0x65, + 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x6e, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0c, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x30, 0x0a, + 0x14, 0x6e, 0x6f, 0x5f, 0x73, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x63, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x6e, 0x6f, 0x53, + 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x4f, 0x63, 0x63, 0x75, 0x72, 0x72, 0x65, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, - 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x61, 0x76, 0x65, - 0x72, 0x61, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x23, 0x0a, - 0x0d, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x18, 0x08, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x69, 0x64, 0x65, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, - 0x65, 0x64, 0x12, 0x55, 0x0a, 0x27, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, - 0x65, 0x5f, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x6c, 0x69, 0x70, 0x70, 0x61, - 0x67, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x09, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x24, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, - 0x4e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x53, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x50, - 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x75, 0x70, 0x64, - 0x61, 0x74, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x0a, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0e, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, - 0x6f, 0x6c, 0x12, 0x3f, 0x0a, 0x1c, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, - 0x62, 0x6f, 0x6f, 0x6b, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, - 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x19, 0x66, 0x75, 0x6c, 0x6c, 0x4f, 0x72, - 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x69, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x75, - 0x6d, 0x65, 0x64, 0x22, 0xf8, 0x01, 0x0a, 0x21, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, - 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x6d, 0x70, 0x61, - 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, - 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, - 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, - 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x10, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, - 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x04, 0x73, 0x65, 0x6c, 0x6c, 0x12, 0x36, 0x0a, 0x17, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, - 0x65, 0x73, 0x5f, 0x72, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, - 0x6b, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, - 0x73, 0x52, 0x65, 0x73, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x22, 0x9a, - 0x04, 0x0a, 0x22, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, - 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, - 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x29, - 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x73, 0x65, 0x6c, 0x6c, 0x69, - 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, - 0x63, 0x79, 0x53, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6d, 0x6f, - 0x75, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x01, 0x52, 0x0e, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, - 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x62, - 0x75, 0x79, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x42, 0x75, 0x79, 0x69, 0x6e, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, - 0x65, 0x6e, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x08, 0x65, 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x76, 0x65, - 0x72, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x4f, 0x72, - 0x64, 0x65, 0x72, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x69, 0x64, 0x65, 0x5f, - 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, - 0x73, 0x69, 0x64, 0x65, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x12, 0x53, 0x0a, 0x26, - 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x6d, 0x70, 0x61, - 0x63, 0x74, 0x5f, 0x73, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x63, - 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x23, 0x61, 0x70, - 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x53, + 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x61, 0x76, 0x65, + 0x72, 0x61, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x73, 0x74, 0x22, 0xfb, 0x01, + 0x0a, 0x22, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x12, 0x14, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, + 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x65, 0x72, 0x63, + 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x11, 0x6e, 0x6f, + 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, + 0x12, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, + 0x65, 0x6c, 0x6c, 0x12, 0x36, 0x0a, 0x17, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x5f, + 0x72, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x22, 0x9d, 0x04, 0x0a, 0x23, + 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x72, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x29, 0x0a, 0x10, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x73, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, + 0x53, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x5f, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x0e, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, + 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x62, 0x75, 0x79, + 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x42, 0x75, 0x79, 0x69, 0x6e, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x6e, + 0x64, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x65, + 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x76, 0x65, 0x72, 0x61, + 0x67, 0x65, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x10, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, + 0x72, 0x43, 0x6f, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x61, 0x66, + 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x69, + 0x64, 0x65, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x12, 0x55, 0x0a, 0x27, 0x61, 0x70, + 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x5f, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, + 0x6c, 0x5f, 0x73, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, + 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x24, 0x61, 0x70, 0x70, + 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x4e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x53, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x75, 0x70, 0x64, 0x61, @@ -16265,807 +17661,911 @@ var file_rpc_proto_rawDesc = []byte{ 0x6c, 0x6c, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x19, 0x66, 0x75, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, - 0x69, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x32, 0xc2, 0x63, 0x0a, 0x15, - 0x47, 0x6f, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x54, 0x72, 0x61, 0x64, 0x65, 0x72, 0x53, 0x65, - 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x4f, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, - 0x12, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, - 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x13, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0d, 0x12, 0x0b, 0x2f, 0x76, 0x31, 0x2f, 0x67, - 0x65, 0x74, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x67, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, - 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x53, 0x75, 0x73, 0x62, 0x73, 0x79, 0x74, 0x65, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x76, - 0x31, 0x2f, 0x67, 0x65, 0x74, 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x12, - 0x68, 0x0a, 0x0f, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, - 0x65, 0x6d, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, - 0x72, 0x69, 0x63, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, - 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, - 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x12, 0x6a, 0x0a, 0x10, 0x44, 0x69, 0x73, - 0x61, 0x62, 0x6c, 0x65, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x12, 0x1f, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x75, - 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, - 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x75, 0x62, 0x73, - 0x79, 0x73, 0x74, 0x65, 0x6d, 0x12, 0x6f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x50, 0x43, 0x45, - 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x50, 0x43, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x50, 0x43, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x72, 0x70, 0x63, 0x65, 0x6e, 0x64, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x93, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x43, 0x6f, - 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6c, 0x61, 0x79, - 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6c, - 0x61, 0x79, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, - 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x12, 0x63, 0x0a, 0x0c, - 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, - 0x10, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x73, 0x12, 0x6e, 0x0a, 0x0f, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x45, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x6e, 0x65, 0x72, 0x69, 0x63, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x3a, 0x01, 0x2a, 0x22, 0x13, 0x2f, 0x76, - 0x31, 0x2f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x12, 0x73, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x6e, 0x65, 0x72, 0x69, 0x63, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x6e, 0x66, - 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x74, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x22, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x45, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, - 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6f, 0x74, 0x70, 0x12, 0x73, 0x0a, 0x13, - 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, 0x43, 0x6f, - 0x64, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x69, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x22, 0xf8, 0x01, 0x0a, 0x21, + 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x42, 0x79, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x73, + 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x52, 0x04, 0x70, 0x61, 0x69, 0x72, 0x12, 0x2b, 0x0a, + 0x11, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, + 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x65, + 0x6c, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x65, 0x6c, 0x6c, 0x12, 0x36, + 0x0a, 0x17, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x73, 0x74, 0x5f, + 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x15, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x52, 0x65, 0x73, 0x74, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x22, 0x9a, 0x04, 0x0a, 0x22, 0x47, 0x65, 0x74, 0x4f, 0x72, + 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x49, + 0x6d, 0x70, 0x61, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, + 0x0f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x5f, 0x73, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x65, 0x6c, 0x6c, 0x69, 0x6e, + 0x67, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x63, 0x65, + 0x69, 0x76, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x61, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x62, 0x75, 0x79, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x42, 0x75, 0x79, + 0x69, 0x6e, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x70, 0x72, 0x69, + 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, + 0x72, 0x69, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x6e, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x63, + 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x6f, 0x72, 0x64, + 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x10, 0x61, + 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x73, 0x74, 0x12, + 0x23, 0x0a, 0x0d, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x69, 0x64, 0x65, 0x41, 0x66, 0x66, 0x65, + 0x63, 0x74, 0x65, 0x64, 0x12, 0x53, 0x0a, 0x26, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, + 0x61, 0x74, 0x65, 0x5f, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x73, 0x6c, 0x69, 0x70, 0x70, + 0x61, 0x67, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x23, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, + 0x65, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x53, 0x6c, 0x69, 0x70, 0x70, 0x61, 0x67, 0x65, 0x50, + 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x12, 0x3f, 0x0a, 0x1c, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, + 0x62, 0x6f, 0x6f, 0x6b, 0x5f, 0x73, 0x69, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, + 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x19, 0x66, 0x75, 0x6c, 0x6c, 0x4f, 0x72, + 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x69, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x75, + 0x6d, 0x65, 0x64, 0x32, 0xa8, 0x6a, 0x0a, 0x15, 0x47, 0x6f, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, + 0x54, 0x72, 0x61, 0x64, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x4f, 0x0a, + 0x07, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x13, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x0d, 0x12, 0x0b, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x67, + 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x12, + 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x75, 0x73, 0x62, 0x73, 0x79, + 0x74, 0x65, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x73, 0x75, 0x62, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x68, 0x0a, 0x0f, 0x45, 0x6e, 0x61, 0x62, 0x6c, + 0x65, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x75, 0x62, 0x73, 0x79, + 0x73, 0x74, 0x65, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, - 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6f, 0x74, 0x70, - 0x73, 0x12, 0x6c, 0x0a, 0x0e, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, - 0x65, 0x72, 0x69, 0x63, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x76, 0x31, - 0x2f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, - 0x57, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x12, 0x18, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x3a, 0x01, 0x2a, 0x22, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x67, - 0x65, 0x74, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x12, 0x5b, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x54, - 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x69, - 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x16, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x74, 0x69, - 0x63, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x63, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x12, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x22, 0x10, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, - 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x12, 0x67, 0x0a, 0x0d, 0x47, 0x65, - 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x12, 0x1c, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, - 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, - 0x12, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, - 0x6f, 0x6b, 0x73, 0x12, 0x6b, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, - 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x76, - 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x66, 0x6f, - 0x12, 0x71, 0x0a, 0x11, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, - 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, - 0x31, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x69, - 0x6e, 0x66, 0x6f, 0x12, 0x79, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, - 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x1d, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, - 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, 0x63, 0x63, 0x6f, 0x75, - 0x6e, 0x74, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x30, 0x01, 0x12, 0x57, - 0x0a, 0x09, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0f, 0x12, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, - 0x74, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x63, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x50, 0x6f, - 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x12, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x76, 0x31, 0x2f, - 0x67, 0x65, 0x74, 0x70, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x12, 0x7f, 0x0a, 0x13, - 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x53, 0x75, 0x6d, 0x6d, - 0x61, 0x72, 0x79, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x53, 0x75, 0x6d, - 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x70, 0x6f, 0x72, - 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x76, 0x0a, - 0x13, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x41, 0x64, 0x64, - 0x72, 0x65, 0x73, 0x73, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, - 0x64, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x3a, 0x01, 0x2a, 0x22, 0x17, 0x2f, 0x76, - 0x31, 0x2f, 0x61, 0x64, 0x64, 0x70, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x61, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x7f, 0x0a, 0x16, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, - 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, - 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, - 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, + 0x31, 0x2f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, + 0x6d, 0x12, 0x6a, 0x0a, 0x10, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x75, 0x62, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x76, 0x31, 0x2f, - 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x61, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x77, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, - 0x65, 0x78, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x20, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x50, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, - 0x74, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, - 0x67, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x52, 0x61, 0x74, 0x65, 0x73, - 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, - 0x65, 0x78, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, - 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x66, 0x6f, - 0x72, 0x65, 0x78, 0x72, 0x61, 0x74, 0x65, 0x73, 0x12, 0x5a, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x4f, - 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x12, 0x3a, 0x01, 0x2a, 0x22, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, - 0x64, 0x65, 0x72, 0x73, 0x12, 0x52, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, - 0x12, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, - 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, - 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x76, 0x31, 0x2f, - 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x62, 0x0a, 0x0b, 0x53, 0x75, 0x62, 0x6d, - 0x69, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, - 0x6d, 0x69, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x76, 0x31, - 0x2f, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x6a, 0x0a, 0x0d, - 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x1c, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, - 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, - 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x69, 0x6d, 0x75, 0x6c, - 0x61, 0x74, 0x65, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x5e, 0x0a, 0x09, 0x57, 0x68, 0x61, 0x6c, - 0x65, 0x42, 0x6f, 0x6d, 0x62, 0x12, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, - 0x68, 0x61, 0x6c, 0x65, 0x42, 0x6f, 0x6d, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, - 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x3a, 0x01, 0x2a, 0x22, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x77, - 0x68, 0x61, 0x6c, 0x65, 0x62, 0x6f, 0x6d, 0x62, 0x12, 0x5e, 0x0a, 0x0b, 0x43, 0x61, 0x6e, 0x63, - 0x65, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, - 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x61, 0x6e, - 0x63, 0x65, 0x6c, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x7a, 0x0a, 0x11, 0x43, 0x61, 0x6e, 0x63, - 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x20, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, - 0x63, 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, - 0x61, 0x74, 0x63, 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x01, 0x2a, 0x22, 0x15, 0x2f, - 0x76, 0x31, 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x62, 0x61, 0x74, 0x63, 0x68, 0x6f, 0x72, - 0x64, 0x65, 0x72, 0x73, 0x12, 0x72, 0x0a, 0x0f, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, 0x6c, - 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, - 0x3a, 0x01, 0x2a, 0x22, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x61, - 0x6c, 0x6c, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x57, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x45, - 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, - 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x15, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x0f, 0x12, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x76, 0x65, 0x6e, 0x74, - 0x73, 0x12, 0x56, 0x0a, 0x08, 0x41, 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x17, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x76, 0x31, - 0x2f, 0x61, 0x64, 0x64, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x5e, 0x0a, 0x0b, 0x52, 0x65, 0x6d, - 0x6f, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, - 0x6d, 0x6f, 0x76, 0x65, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0xb2, 0x01, 0x0a, 0x21, 0x47, 0x65, - 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, - 0x30, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, - 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x31, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, - 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, - 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, - 0x1d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x64, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0xaa, - 0x01, 0x0a, 0x1f, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, + 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x69, 0x73, + 0x61, 0x62, 0x6c, 0x65, 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x12, 0x6f, 0x0a, + 0x0f, 0x47, 0x65, 0x74, 0x52, 0x50, 0x43, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, + 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x50, 0x43, + 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x50, 0x43, + 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, + 0x65, 0x74, 0x72, 0x70, 0x63, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x93, + 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, + 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, + 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x72, 0x65, 0x6c, 0x61, + 0x79, 0x65, 0x72, 0x73, 0x12, 0x63, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, + 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, + 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x6e, 0x0a, 0x0f, 0x44, 0x69, 0x73, + 0x61, 0x62, 0x6c, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x22, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x45, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, + 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x18, 0x3a, 0x01, 0x2a, 0x22, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, + 0x65, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x73, 0x0a, 0x0f, 0x47, 0x65, 0x74, + 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x45, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, + 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x74, + 0x0a, 0x12, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, + 0x43, 0x6f, 0x64, 0x65, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, + 0x6e, 0x65, 0x72, 0x69, 0x63, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, + 0x12, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x6f, 0x74, 0x70, 0x12, 0x73, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, 0x43, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x4f, 0x54, 0x50, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x4f, 0x54, 0x50, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6f, 0x74, 0x70, 0x73, 0x12, 0x6c, 0x0a, 0x0e, 0x45, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x22, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x45, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, + 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x65, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x57, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x54, 0x69, + 0x63, 0x6b, 0x65, 0x72, 0x12, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, + 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x3a, 0x01, + 0x2a, 0x22, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, + 0x12, 0x5b, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x19, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x16, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, + 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x63, 0x0a, + 0x0c, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x12, 0x1b, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, + 0x6f, 0x6f, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, + 0x22, 0x10, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, + 0x6f, 0x6b, 0x12, 0x67, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, + 0x6f, 0x6b, 0x73, 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, + 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, + 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, + 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x12, 0x6b, 0x0a, 0x0e, 0x47, + 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, 0x63, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x71, 0x0a, 0x11, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x79, 0x0a, 0x14, 0x47, + 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x53, 0x74, 0x72, + 0x65, 0x61, 0x6d, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, + 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, + 0x67, 0x65, 0x74, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x74, + 0x72, 0x65, 0x61, 0x6d, 0x30, 0x01, 0x12, 0x57, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x12, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0f, + 0x12, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, + 0x63, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x12, + 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, + 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, + 0x69, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x12, 0x12, 0x10, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x70, 0x6f, 0x72, 0x74, 0x66, + 0x6f, 0x6c, 0x69, 0x6f, 0x12, 0x7f, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, + 0x6f, 0x6c, 0x69, 0x6f, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x22, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, + 0x6f, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, + 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x76, + 0x31, 0x2f, 0x67, 0x65, 0x74, 0x70, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x73, 0x75, + 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x76, 0x0a, 0x13, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x72, 0x74, + 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x22, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, + 0x69, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, + 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x1c, 0x3a, 0x01, 0x2a, 0x22, 0x17, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x64, 0x64, 0x70, 0x6f, 0x72, + 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x7f, 0x0a, + 0x16, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, + 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, + 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, + 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x70, 0x6f, + 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x77, + 0x0a, 0x11, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x73, 0x12, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, + 0x46, 0x6f, 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, + 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x67, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6f, + 0x72, 0x65, 0x78, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, + 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x72, 0x61, 0x74, 0x65, 0x73, + 0x12, 0x5a, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x18, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x3a, 0x01, 0x2a, 0x22, 0x0d, 0x2f, + 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x52, 0x0a, 0x08, + 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, + 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, + 0x12, 0x62, 0x0a, 0x0b, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, + 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4f, + 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, + 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x12, 0x6a, 0x0a, 0x0d, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, + 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, + 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x6d, + 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, + 0x76, 0x31, 0x2f, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x6f, 0x72, 0x64, 0x65, 0x72, + 0x12, 0x5e, 0x0a, 0x09, 0x57, 0x68, 0x61, 0x6c, 0x65, 0x42, 0x6f, 0x6d, 0x62, 0x12, 0x18, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x68, 0x61, 0x6c, 0x65, 0x42, 0x6f, 0x6d, 0x62, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x3a, 0x01, + 0x2a, 0x22, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x68, 0x61, 0x6c, 0x65, 0x62, 0x6f, 0x6d, 0x62, + 0x12, 0x5e, 0x0a, 0x0b, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, + 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4f, + 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, + 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6f, 0x72, 0x64, 0x65, 0x72, + 0x12, 0x7a, 0x0a, 0x11, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, + 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, + 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x72, 0x64, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x1a, 0x3a, 0x01, 0x2a, 0x22, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x65, + 0x6c, 0x62, 0x61, 0x74, 0x63, 0x68, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x72, 0x0a, 0x0f, + 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, + 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, + 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x41, + 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x3a, 0x01, 0x2a, 0x22, 0x13, 0x2f, 0x76, 0x31, + 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x61, 0x6c, 0x6c, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, + 0x12, 0x57, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x18, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x47, 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0f, 0x12, 0x0d, 0x2f, 0x76, 0x31, 0x2f, + 0x67, 0x65, 0x74, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x56, 0x0a, 0x08, 0x41, 0x64, 0x64, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, + 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, + 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x64, 0x64, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x12, 0x5e, 0x0a, 0x0b, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x12, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, + 0x22, 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x12, 0xb2, 0x01, 0x0a, 0x21, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x30, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, - 0x73, 0x73, 0x12, 0x2e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, - 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, - 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x3a, 0x01, 0x2a, 0x22, 0x1b, - 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x64, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x1a, - 0x47, 0x65, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, - 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, - 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, - 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x29, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x23, 0x3a, 0x01, 0x2a, 0x22, 0x1e, 0x2f, 0x76, - 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x72, - 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x12, 0x6c, 0x0a, 0x11, - 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x46, 0x69, 0x61, 0x74, 0x46, 0x75, 0x6e, 0x64, - 0x73, 0x12, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, - 0x72, 0x61, 0x77, 0x46, 0x69, 0x61, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, - 0x3a, 0x01, 0x2a, 0x22, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, - 0x77, 0x66, 0x69, 0x61, 0x74, 0x66, 0x75, 0x6e, 0x64, 0x73, 0x12, 0x8b, 0x01, 0x0a, 0x1b, 0x57, - 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x46, 0x75, 0x6e, 0x64, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43, 0x72, 0x79, 0x70, - 0x74, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x33, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2d, 0x3a, 0x01, 0x2a, 0x22, 0x28, - 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x69, 0x74, 0x68, 0x64, - 0x72, 0x61, 0x77, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x66, 0x75, 0x6e, 0x64, 0x73, 0x77, 0x66, - 0x69, 0x61, 0x74, 0x66, 0x75, 0x6e, 0x64, 0x73, 0x12, 0x82, 0x01, 0x0a, 0x13, 0x57, 0x69, 0x74, - 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x44, - 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, - 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, - 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x79, 0x49, - 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x1c, 0x3a, 0x01, 0x2a, 0x22, 0x17, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, - 0x61, 0x77, 0x61, 0x6c, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x62, 0x79, 0x69, 0x64, 0x12, 0x9d, 0x01, - 0x0a, 0x1a, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, - 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x29, 0x2e, 0x67, + 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, + 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0xaa, 0x01, 0x0a, 0x1f, 0x47, 0x65, 0x74, 0x43, 0x72, + 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2e, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x20, 0x3a, 0x01, 0x2a, 0x22, 0x1b, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, + 0x72, 0x79, 0x70, 0x74, 0x6f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, + 0x61, 0x62, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x69, + 0x6e, 0x73, 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, + 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x43, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, + 0x62, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x69, 0x6e, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x23, 0x3a, 0x01, 0x2a, 0x22, 0x1e, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, 0x76, 0x61, + 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x73, 0x12, 0x6c, 0x0a, 0x11, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, + 0x46, 0x69, 0x61, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x73, 0x12, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x46, 0x69, 0x61, 0x74, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x01, 0x2a, 0x22, 0x15, 0x2f, 0x76, 0x31, + 0x2f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x66, 0x69, 0x61, 0x74, 0x66, 0x75, 0x6e, + 0x64, 0x73, 0x12, 0x8b, 0x01, 0x0a, 0x1b, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x43, + 0x72, 0x79, 0x70, 0x74, 0x6f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x46, 0x75, 0x6e, + 0x64, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, + 0x64, 0x72, 0x61, 0x77, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, + 0x72, 0x61, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x33, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x2d, 0x3a, 0x01, 0x2a, 0x22, 0x28, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68, + 0x64, 0x72, 0x61, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x6f, 0x66, 0x75, 0x6e, 0x64, 0x73, 0x77, 0x66, 0x69, 0x61, 0x74, 0x66, 0x75, 0x6e, 0x64, 0x73, + 0x12, 0x82, 0x01, 0x0a, 0x13, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x44, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x3a, 0x01, 0x2a, 0x22, 0x17, 0x2f, 0x76, + 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x62, 0x79, 0x69, 0x64, 0x12, 0x9d, 0x01, 0x0a, 0x1a, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, + 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, + 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, + 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x2a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, + 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68, + 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x62, 0x79, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x91, 0x01, 0x0a, 0x16, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, + 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x44, 0x61, 0x74, 0x65, + 0x12, 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, + 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x44, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, + 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x3a, 0x01, 0x2a, 0x22, 0x19, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x65, 0x76, - 0x65, 0x6e, 0x74, 0x62, 0x79, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x91, 0x01, - 0x0a, 0x16, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, - 0x74, 0x73, 0x42, 0x79, 0x44, 0x61, 0x74, 0x65, 0x12, 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, - 0x74, 0x73, 0x42, 0x79, 0x44, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x2a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, - 0x77, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x45, 0x78, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x1e, 0x3a, 0x01, 0x2a, 0x22, 0x19, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x69, 0x74, 0x68, - 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x62, 0x79, 0x64, 0x61, 0x74, - 0x65, 0x12, 0x73, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, - 0x12, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x76, 0x0a, 0x10, 0x53, 0x65, 0x74, 0x4c, 0x6f, 0x67, - 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x01, 0x2a, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, + 0x65, 0x6e, 0x74, 0x62, 0x79, 0x64, 0x61, 0x74, 0x65, 0x12, 0x73, 0x0a, 0x10, 0x47, 0x65, 0x74, + 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1f, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, + 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, + 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x76, - 0x0a, 0x10, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, - 0x72, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x0a, 0x10, 0x53, 0x65, 0x74, 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x4c, + 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x73, + 0x4c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x01, 0x2a, - 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x70, 0x61, 0x69, 0x72, 0x73, 0x12, 0x6a, 0x0a, 0x0f, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, - 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x3a, 0x01, 0x2a, 0x22, 0x13, 0x2f, - 0x76, 0x31, 0x2f, 0x73, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x70, 0x61, - 0x69, 0x72, 0x12, 0x74, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, - 0x6f, 0x6b, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, - 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, - 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, - 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x30, 0x01, 0x12, 0x8c, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, - 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, - 0x6b, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x12, 0x1e, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, - 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, - 0x74, 0x72, 0x65, 0x61, 0x6d, 0x30, 0x01, 0x12, 0x68, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x54, 0x69, - 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, - 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, - 0x67, 0x65, 0x74, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x30, - 0x01, 0x12, 0x80, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x26, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x54, - 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x12, 0x1b, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, - 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x30, 0x01, 0x12, 0x67, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, - 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x65, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x41, 0x75, 0x64, 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x76, 0x31, 0x2f, - 0x67, 0x65, 0x74, 0x61, 0x75, 0x64, 0x69, 0x74, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x6b, 0x0a, - 0x10, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, - 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, - 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x12, 0x6b, 0x0a, 0x0f, 0x47, 0x43, - 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x1e, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x01, - 0x2a, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x2f, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x78, 0x0a, 0x13, 0x47, 0x43, 0x54, 0x53, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x52, 0x65, 0x61, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x12, 0x22, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x52, 0x65, 0x61, 0x64, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, - 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x72, 0x65, 0x61, - 0x64, 0x12, 0x70, 0x0a, 0x0f, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, - 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, - 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, - 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x12, 0x6c, 0x0a, 0x0e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, - 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, - 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, - 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x12, 0x65, 0x0a, 0x0d, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, - 0x6f, 0x70, 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, - 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x2f, 0x73, 0x74, 0x6f, 0x70, 0x12, 0x6e, 0x0a, 0x10, 0x47, 0x43, 0x54, 0x53, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x41, 0x6c, 0x6c, 0x12, 0x1f, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, - 0x74, 0x6f, 0x70, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x01, - 0x2a, 0x22, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x2f, 0x73, 0x74, 0x6f, 0x70, 0x61, 0x6c, 0x6c, 0x12, 0x73, 0x0a, 0x10, 0x47, 0x43, 0x54, 0x53, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x12, 0x1f, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4c, - 0x69, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, - 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x77, 0x0a, - 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x4c, 0x6f, - 0x61, 0x64, 0x54, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x12, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x4c, - 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, + 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x74, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x76, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, + 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x01, 0x2a, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, + 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x70, 0x61, 0x69, 0x72, 0x73, 0x12, 0x6a, + 0x0a, 0x0f, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, + 0x72, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x45, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, + 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x18, 0x3a, 0x01, 0x2a, 0x22, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x74, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x70, 0x61, 0x69, 0x72, 0x12, 0x74, 0x0a, 0x12, 0x47, 0x65, + 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, + 0x12, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x30, 0x01, + 0x12, 0x8c, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, + 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x53, 0x74, 0x72, + 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x12, 0x1e, 0x2f, + 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6f, 0x72, + 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x30, 0x01, 0x12, + 0x68, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, + 0x61, 0x6d, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, + 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x69, 0x63, 0x6b, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x74, 0x69, 0x63, 0x6b, 0x65, + 0x72, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x30, 0x01, 0x12, 0x80, 0x01, 0x0a, 0x17, 0x47, 0x65, + 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x53, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x26, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, + 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x12, 0x1b, 0x2f, + 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x74, 0x69, + 0x63, 0x6b, 0x65, 0x72, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x30, 0x01, 0x12, 0x67, 0x0a, 0x0d, + 0x47, 0x65, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x64, 0x69, 0x74, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x13, 0x12, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, 0x75, 0x64, 0x69, 0x74, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x6b, 0x0a, 0x10, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x3a, 0x01, 0x2a, 0x22, 0x16, - 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x61, 0x75, - 0x74, 0x6f, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x7b, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, - 0x74, 0x6f, 0x72, 0x69, 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x12, 0x21, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, - 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, - 0x6f, 0x72, 0x69, 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x76, 0x31, - 0x2f, 0x67, 0x65, 0x74, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x63, 0x61, 0x6e, 0x64, - 0x6c, 0x65, 0x73, 0x12, 0x6a, 0x0a, 0x10, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, + 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x65, 0x12, 0x6b, 0x0a, 0x0f, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x55, + 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x01, 0x2a, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, + 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x12, + 0x78, 0x0a, 0x13, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x65, 0x61, 0x64, + 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x65, 0x61, 0x64, 0x53, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x2f, 0x72, 0x65, 0x61, 0x64, 0x12, 0x70, 0x0a, 0x0f, 0x47, 0x43, 0x54, + 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1e, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x6c, 0x0a, 0x0e, 0x47, + 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1d, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x65, 0x0a, 0x0d, 0x47, 0x43, 0x54, + 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, + 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x73, - 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, - 0x73, 0x0a, 0x13, 0x53, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, + 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x76, + 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x73, 0x74, 0x6f, 0x70, + 0x12, 0x6e, 0x0a, 0x10, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, + 0x70, 0x41, 0x6c, 0x6c, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, + 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x41, 0x6c, 0x6c, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x01, 0x2a, 0x22, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, + 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x73, 0x74, 0x6f, 0x70, 0x61, 0x6c, 0x6c, + 0x12, 0x73, 0x0a, 0x10, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4c, 0x69, 0x73, + 0x74, 0x41, 0x6c, 0x6c, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, + 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x3a, 0x01, + 0x2a, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x77, 0x0a, 0x17, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x4c, 0x6f, 0x61, 0x64, 0x54, 0x6f, 0x67, 0x67, 0x6c, 0x65, + 0x12, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x43, 0x54, 0x53, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x4c, 0x6f, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, + 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x1b, 0x3a, 0x01, 0x2a, 0x22, 0x16, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x61, 0x75, 0x74, 0x6f, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x7b, + 0x0a, 0x12, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x43, 0x61, 0x6e, + 0x64, 0x6c, 0x65, 0x73, 0x12, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, + 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x43, 0x61, 0x6e, 0x64, + 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x68, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x69, 0x63, 0x63, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x12, 0x6a, 0x0a, 0x10, 0x53, + 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, + 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, + 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x16, 0x12, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x73, 0x0a, 0x13, 0x53, 0x65, 0x74, 0x41, 0x6c, + 0x6c, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x22, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, + 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x74, 0x61, 0x6c, 0x6c, 0x65, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x70, 0x61, 0x69, 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, + 0x1c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x53, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x2b, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x76, 0x31, - 0x2f, 0x73, 0x65, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x70, - 0x61, 0x69, 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x1c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, - 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x2b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x53, 0x75, 0x70, - 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, - 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x22, 0x12, 0x20, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x65, - 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, - 0x70, 0x61, 0x69, 0x72, 0x73, 0x12, 0x77, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, - 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x20, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, - 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x73, - 0x0a, 0x10, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x49, 0x6e, - 0x66, 0x6f, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, - 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, - 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, - 0x76, 0x31, 0x2f, 0x77, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x67, 0x65, 0x74, 0x69, - 0x6e, 0x66, 0x6f, 0x12, 0x73, 0x0a, 0x13, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, - 0x53, 0x65, 0x74, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, - 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x12, - 0x17, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x65, - 0x74, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x97, 0x01, 0x0a, 0x19, 0x57, 0x65, 0x62, - 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x28, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, - 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x25, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x1f, 0x12, 0x1d, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, - 0x65, 0x74, 0x67, 0x65, 0x74, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x12, 0x6d, 0x0a, 0x11, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, - 0x65, 0x74, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x12, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x50, 0x72, 0x6f, - 0x78, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, - 0x77, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x65, 0x74, 0x70, 0x72, 0x6f, 0x78, - 0x79, 0x12, 0x67, 0x0a, 0x0f, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, - 0x74, 0x55, 0x52, 0x4c, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, - 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x65, 0x62, 0x73, 0x6f, - 0x63, 0x6b, 0x65, 0x74, 0x73, 0x65, 0x74, 0x75, 0x72, 0x6c, 0x12, 0x6a, 0x0a, 0x0f, 0x47, 0x65, - 0x74, 0x52, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x1d, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, - 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, - 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x70, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, - 0x74, 0x6f, 0x72, 0x69, 0x63, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, - 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, + 0x6e, 0x73, 0x65, 0x22, 0x28, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x12, 0x20, 0x2f, 0x76, 0x31, + 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x70, 0x61, 0x69, 0x72, 0x73, 0x12, 0x77, 0x0a, + 0x11, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, + 0x74, 0x73, 0x12, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, + 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, + 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, - 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, - 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x30, 0x01, 0x12, 0x68, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x53, - 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, - 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, - 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x73, 0x61, 0x76, 0x65, 0x64, 0x74, 0x72, 0x61, 0x64, - 0x65, 0x73, 0x12, 0x87, 0x01, 0x0a, 0x16, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x54, 0x72, - 0x61, 0x64, 0x65, 0x73, 0x54, 0x6f, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x12, 0x25, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x54, 0x72, - 0x61, 0x64, 0x65, 0x73, 0x54, 0x6f, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, - 0x12, 0x1a, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x74, 0x72, 0x61, - 0x64, 0x65, 0x73, 0x74, 0x6f, 0x63, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x12, 0x9d, 0x01, 0x0a, - 0x1f, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x61, 0x76, 0x65, - 0x64, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, - 0x12, 0x27, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, - 0x73, 0x73, 0x69, 0x6e, 0x67, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, - 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x49, 0x6e, - 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x2b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x25, 0x12, 0x23, 0x2f, 0x76, 0x31, 0x2f, 0x66, 0x69, 0x6e, - 0x64, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x73, 0x61, 0x76, 0x65, 0x64, 0x63, 0x61, 0x6e, - 0x64, 0x6c, 0x65, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x12, 0x9a, 0x01, 0x0a, - 0x1e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x61, 0x76, 0x65, - 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x12, - 0x26, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, - 0x73, 0x69, 0x6e, 0x67, 0x54, 0x72, 0x61, 0x64, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x65, - 0x72, 0x76, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2a, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x24, 0x12, 0x22, 0x2f, 0x76, 0x31, 0x2f, 0x66, 0x69, 0x6e, 0x64, 0x6d, - 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x73, 0x61, 0x76, 0x65, 0x64, 0x74, 0x72, 0x61, 0x64, 0x65, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x12, 0x88, 0x01, 0x0a, 0x1a, 0x53, 0x65, - 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x72, 0x61, 0x64, 0x65, 0x50, 0x72, - 0x6f, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x72, 0x61, - 0x64, 0x65, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, - 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x20, 0x12, 0x1e, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x74, 0x65, 0x78, 0x63, - 0x68, 0x61, 0x6e, 0x67, 0x65, 0x74, 0x72, 0x61, 0x64, 0x65, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, - 0x73, 0x69, 0x6e, 0x67, 0x12, 0x86, 0x01, 0x0a, 0x14, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, - 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x12, 0x23, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, - 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x73, 0x65, - 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, - 0x3a, 0x01, 0x2a, 0x22, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x70, 0x73, 0x65, 0x72, 0x74, 0x64, - 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x12, 0x81, 0x01, - 0x0a, 0x18, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, - 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x27, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, - 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, - 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x22, 0x24, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x64, 0x61, 0x74, 0x61, - 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x12, 0x71, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x44, 0x61, - 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x12, 0x16, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, - 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x22, 0x24, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, - 0x63, 0x74, 0x69, 0x76, 0x65, 0x64, 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, - 0x6a, 0x6f, 0x62, 0x73, 0x12, 0x85, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, - 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x42, 0x65, 0x74, 0x77, 0x65, - 0x65, 0x6e, 0x12, 0x28, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x44, - 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x42, 0x65, - 0x74, 0x77, 0x65, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x22, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x12, 0x1d, 0x2f, - 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x64, 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x6a, 0x6f, 0x62, 0x73, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x12, 0x81, 0x01, 0x0a, - 0x18, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, - 0x6f, 0x62, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x27, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, - 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x64, 0x61, 0x74, 0x61, 0x68, - 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, - 0x12, 0x82, 0x01, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, - 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x26, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, - 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, - 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x3a, 0x01, 0x2a, 0x22, 0x1b, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, - 0x74, 0x64, 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x73, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x9d, 0x01, 0x0a, 0x20, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x50, 0x72, - 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x12, 0x2f, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, - 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x50, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, - 0x73, 0x69, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, + 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x73, 0x0a, 0x10, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, + 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1f, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, + 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x65, 0x62, 0x73, 0x6f, + 0x63, 0x6b, 0x65, 0x74, 0x67, 0x65, 0x74, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x73, 0x0a, 0x13, 0x57, + 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x45, 0x6e, 0x61, 0x62, 0x6c, + 0x65, 0x64, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, + 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x65, 0x62, + 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x65, 0x74, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x12, 0x97, 0x01, 0x0a, 0x19, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, + 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x28, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, + 0x74, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x47, 0x65, 0x74, 0x53, 0x75, + 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x12, 0x1d, 0x2f, 0x76, 0x31, + 0x2f, 0x77, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x67, 0x65, 0x74, 0x73, 0x75, 0x62, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x6d, 0x0a, 0x11, 0x57, 0x65, + 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x12, + 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, + 0x65, 0x74, 0x53, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, + 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x77, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, + 0x74, 0x73, 0x65, 0x74, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x12, 0x67, 0x0a, 0x0f, 0x57, 0x65, 0x62, + 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x74, 0x55, 0x52, 0x4c, 0x12, 0x1e, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x53, + 0x65, 0x74, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, + 0x76, 0x31, 0x2f, 0x77, 0x65, 0x62, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x65, 0x74, 0x75, + 0x72, 0x6c, 0x12, 0x6a, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x54, + 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x74, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x61, + 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, + 0x65, 0x74, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x70, + 0x0a, 0x11, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x54, 0x72, 0x61, + 0x64, 0x65, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, + 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x61, 0x76, 0x65, + 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, + 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x30, 0x01, + 0x12, 0x68, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, + 0x65, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x53, + 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x64, + 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x73, + 0x61, 0x76, 0x65, 0x64, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x12, 0x87, 0x01, 0x0a, 0x16, 0x43, + 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x54, 0x6f, 0x43, 0x61, + 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, + 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x54, 0x72, 0x61, 0x64, 0x65, 0x73, 0x54, 0x6f, 0x43, 0x61, + 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, + 0x63, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, + 0x6e, 0x76, 0x65, 0x72, 0x74, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x74, 0x6f, 0x63, 0x61, 0x6e, + 0x64, 0x6c, 0x65, 0x73, 0x12, 0x9d, 0x01, 0x0a, 0x1f, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, + 0x73, 0x69, 0x6e, 0x67, 0x53, 0x61, 0x76, 0x65, 0x64, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x49, + 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x12, 0x27, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x43, 0x61, 0x6e, + 0x64, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x4d, + 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x25, 0x12, + 0x23, 0x2f, 0x76, 0x31, 0x2f, 0x66, 0x69, 0x6e, 0x64, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, + 0x73, 0x61, 0x76, 0x65, 0x64, 0x63, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x76, 0x61, 0x6c, 0x73, 0x12, 0x9a, 0x01, 0x0a, 0x1e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, + 0x73, 0x69, 0x6e, 0x67, 0x53, 0x61, 0x76, 0x65, 0x64, 0x54, 0x72, 0x61, 0x64, 0x65, 0x49, 0x6e, + 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x12, 0x26, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x72, 0x61, 0x64, + 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x4d, 0x69, 0x73, + 0x73, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x24, 0x12, 0x22, 0x2f, + 0x76, 0x31, 0x2f, 0x66, 0x69, 0x6e, 0x64, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x73, 0x61, + 0x76, 0x65, 0x64, 0x74, 0x72, 0x61, 0x64, 0x65, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, + 0x73, 0x12, 0x88, 0x01, 0x0a, 0x1a, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x54, 0x72, 0x61, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, + 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x45, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x72, 0x61, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, + 0x73, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x29, 0x3a, 0x01, 0x2a, 0x22, - 0x24, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x61, 0x74, 0x61, 0x68, - 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, - 0x69, 0x73, 0x69, 0x74, 0x65, 0x12, 0x68, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x6e, 0x61, - 0x67, 0x65, 0x64, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x01, 0x2a, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, - 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, - 0x5f, 0x0a, 0x0b, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x1a, - 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x4f, 0x72, - 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, - 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x6f, 0x72, 0x64, 0x65, 0x72, - 0x12, 0x79, 0x0a, 0x13, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x47, 0x65, - 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x19, 0x12, 0x17, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, - 0x73, 0x74, 0x61, 0x74, 0x65, 0x67, 0x65, 0x74, 0x61, 0x6c, 0x6c, 0x12, 0x76, 0x0a, 0x14, 0x43, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, - 0x69, 0x6e, 0x67, 0x12, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, - 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x73, 0x74, 0x61, 0x74, 0x65, 0x74, 0x72, 0x61, 0x64, - 0x69, 0x6e, 0x67, 0x12, 0x76, 0x0a, 0x14, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x12, 0x23, 0x2e, 0x67, 0x63, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x12, 0x1e, 0x2f, 0x76, + 0x31, 0x2f, 0x73, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x74, 0x72, 0x61, + 0x64, 0x65, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x12, 0x86, 0x01, 0x0a, + 0x14, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x12, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, + 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, + 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x3a, 0x01, 0x2a, 0x22, 0x18, 0x2f, 0x76, 0x31, + 0x2f, 0x75, 0x70, 0x73, 0x65, 0x72, 0x74, 0x64, 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x12, 0x81, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, + 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x12, 0x27, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x44, + 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, + 0x4a, 0x6f, 0x62, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x76, 0x31, + 0x2f, 0x67, 0x65, 0x74, 0x64, 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, + 0x6f, 0x62, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x71, 0x0a, 0x18, 0x47, 0x65, 0x74, + 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, + 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, + 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x64, 0x61, 0x74, + 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x73, 0x12, 0x85, 0x01, 0x0a, + 0x19, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, + 0x6f, 0x62, 0x73, 0x42, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x12, 0x28, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x42, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, + 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x22, 0x25, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x12, 0x1d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x64, 0x61, + 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x73, 0x62, 0x65, 0x74, + 0x77, 0x65, 0x65, 0x6e, 0x12, 0x81, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, + 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, + 0x79, 0x12, 0x27, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, + 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, + 0x6f, 0x62, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x76, 0x31, 0x2f, + 0x67, 0x65, 0x74, 0x64, 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, + 0x62, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x82, 0x01, 0x0a, 0x17, 0x53, 0x65, 0x74, + 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x12, 0x26, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, + 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x3a, 0x01, 0x2a, + 0x22, 0x1b, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x74, 0x64, 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, + 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, 0x62, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x9d, 0x01, + 0x0a, 0x20, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x50, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, + 0x74, 0x65, 0x12, 0x2f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4a, 0x6f, 0x62, + 0x50, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, + 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x29, 0x3a, 0x01, 0x2a, 0x22, 0x24, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x61, 0x74, 0x61, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x6a, 0x6f, + 0x62, 0x70, 0x72, 0x65, 0x72, 0x65, 0x71, 0x75, 0x69, 0x73, 0x69, 0x74, 0x65, 0x12, 0x68, 0x0a, + 0x10, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x4f, 0x72, 0x64, 0x65, 0x72, + 0x73, 0x12, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, + 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x01, + 0x2a, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, + 0x64, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x5f, 0x0a, 0x0b, 0x4d, 0x6f, 0x64, 0x69, 0x66, + 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x6f, 0x64, 0x69, + 0x66, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x6f, 0x64, + 0x69, 0x66, 0x79, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x79, 0x0a, 0x13, 0x43, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x12, + 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x76, 0x31, 0x2f, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x73, 0x74, 0x61, 0x74, 0x65, 0x67, 0x65, 0x74, + 0x61, 0x6c, 0x6c, 0x12, 0x76, 0x0a, 0x14, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x73, - 0x74, 0x61, 0x74, 0x65, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x12, 0x79, 0x0a, 0x15, 0x43, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, - 0x64, 0x72, 0x61, 0x77, 0x12, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, - 0x72, 0x61, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, 0x2f, 0x76, 0x31, - 0x2f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x73, 0x74, 0x61, 0x74, 0x65, 0x77, 0x69, - 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x12, 0x82, 0x01, 0x0a, 0x18, 0x43, 0x75, 0x72, 0x72, 0x65, - 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x50, - 0x61, 0x69, 0x72, 0x12, 0x27, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, - 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, - 0x67, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, - 0x76, 0x31, 0x2f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x73, 0x74, 0x61, 0x74, 0x65, - 0x74, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x70, 0x61, 0x69, 0x72, 0x12, 0x7f, 0x0a, 0x13, 0x47, - 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x12, 0x22, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, - 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x66, 0x75, 0x74, 0x75, - 0x72, 0x65, 0x73, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x67, 0x0a, 0x0d, - 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x1c, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, - 0x65, 0x72, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, - 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x13, 0x12, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, 0x6f, 0x6c, 0x6c, 0x61, - 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x53, 0x0a, 0x08, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, - 0x6e, 0x12, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, - 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x14, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0e, 0x12, 0x0c, 0x2f, 0x76, - 0x31, 0x2f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x83, 0x01, 0x0a, 0x14, 0x47, - 0x65, 0x74, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, 0x6c, 0x79, - 0x73, 0x69, 0x73, 0x12, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x54, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, - 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x74, - 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, - 0x12, 0x87, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, - 0x74, 0x65, 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x24, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, - 0x65, 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, - 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, - 0x19, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x72, 0x61, - 0x74, 0x65, 0x73, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x7c, 0x0a, 0x12, 0x47, 0x65, - 0x74, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x6e, - 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, - 0x12, 0x16, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x88, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, - 0x41, 0x6c, 0x6c, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x41, 0x6c, 0x6c, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x63, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, - 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, - 0x61, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x6f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, - 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x47, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x47, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, - 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x72, - 0x61, 0x74, 0x65, 0x73, 0x12, 0x83, 0x01, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, - 0x73, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x12, 0x23, 0x2e, - 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, - 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4c, - 0x61, 0x74, 0x65, 0x73, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, - 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x66, - 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x72, 0x61, 0x74, 0x65, 0x12, 0x83, 0x01, 0x0a, 0x14, 0x47, - 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, 0x76, 0x65, 0x6d, - 0x65, 0x6e, 0x74, 0x12, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, - 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, - 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, - 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, - 0x12, 0x9f, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, + 0x74, 0x61, 0x74, 0x65, 0x74, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x76, 0x0a, 0x14, 0x43, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x44, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x12, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x73, 0x74, 0x61, 0x74, 0x65, 0x64, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x12, 0x79, 0x0a, 0x15, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x12, 0x24, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, + 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x1b, 0x12, 0x19, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x73, 0x74, 0x61, 0x74, 0x65, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x12, 0x82, + 0x01, 0x0a, 0x18, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, 0x72, 0x12, 0x27, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, + 0x6e, 0x65, 0x72, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x73, 0x74, 0x61, 0x74, 0x65, 0x74, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x70, + 0x61, 0x69, 0x72, 0x12, 0x9b, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, + 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, + 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x53, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, + 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, + 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x20, 0x12, 0x1e, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, + 0x79, 0x12, 0x97, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, + 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, + 0x28, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, + 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4f, 0x72, 0x64, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x12, 0x1d, 0x2f, 0x76, + 0x31, 0x2f, 0x67, 0x65, 0x74, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x12, 0x67, 0x0a, 0x0d, 0x47, + 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x1c, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, + 0x72, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x13, 0x12, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x12, 0x53, 0x0a, 0x08, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x12, 0x17, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, + 0x77, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x14, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0e, 0x12, 0x0c, 0x2f, 0x76, 0x31, + 0x2f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x83, 0x01, 0x0a, 0x14, 0x47, 0x65, + 0x74, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x73, + 0x69, 0x73, 0x12, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, + 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x47, 0x65, 0x74, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x41, 0x6e, 0x61, + 0x6c, 0x79, 0x73, 0x69, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x74, 0x65, + 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x69, 0x73, 0x12, + 0x87, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, + 0x65, 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, + 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, + 0x69, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x73, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, + 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x72, 0x61, 0x74, + 0x65, 0x73, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x7c, 0x0a, 0x12, 0x47, 0x65, 0x74, + 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x6e, 0x61, + 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, + 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, + 0x16, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x88, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x41, + 0x6c, 0x6c, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x25, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x41, + 0x6c, 0x6c, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, 0x1a, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x61, + 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x64, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x6f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, + 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, + 0x65, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, + 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x72, 0x61, + 0x74, 0x65, 0x73, 0x12, 0x83, 0x01, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, + 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x12, 0x23, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x46, + 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x61, + 0x74, 0x65, 0x73, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, + 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x66, 0x75, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x72, 0x61, 0x74, 0x65, 0x12, 0x83, 0x01, 0x0a, 0x14, 0x47, 0x65, + 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x12, 0x23, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, + 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x4d, 0x6f, 0x76, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, + 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, + 0x9f, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, + 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x12, + 0x2a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, + 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, 0x6d, + 0x69, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, - 0x12, 0x2a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, - 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, - 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, - 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x4e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, - 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x21, 0x12, 0x1f, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, - 0x6f, 0x6f, 0x6b, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x62, 0x79, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, - 0x61, 0x6c, 0x12, 0x9b, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, - 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x6d, 0x70, 0x61, 0x63, - 0x74, 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, - 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x49, - 0x6d, 0x70, 0x61, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x67, - 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, + 0x12, 0x1f, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, + 0x6f, 0x6b, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x62, 0x79, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, + 0x6c, 0x12, 0x9b, 0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, - 0x12, 0x1e, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, - 0x6f, 0x6b, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x62, 0x79, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, - 0x42, 0x30, 0x5a, 0x2e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, - 0x68, 0x72, 0x61, 0x73, 0x68, 0x65, 0x72, 0x2d, 0x63, 0x6f, 0x72, 0x70, 0x2f, 0x67, 0x6f, 0x63, - 0x72, 0x79, 0x70, 0x74, 0x6f, 0x74, 0x72, 0x61, 0x64, 0x65, 0x72, 0x2f, 0x67, 0x63, 0x74, 0x72, - 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x12, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x6d, + 0x70, 0x61, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, + 0x6b, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x12, + 0x1e, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, + 0x6b, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x62, 0x79, 0x69, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x12, + 0x77, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, + 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x20, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, + 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x17, 0x12, 0x15, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, + 0x65, 0x72, 0x61, 0x6c, 0x6d, 0x6f, 0x64, 0x65, 0x12, 0x5f, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x4c, + 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, + 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, + 0x74, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x7a, 0x0a, 0x11, 0x53, 0x65, 0x74, + 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x20, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x61, + 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x21, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x43, 0x6f, 0x6c, + 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x01, 0x2a, 0x22, 0x15, + 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, + 0x6c, 0x6d, 0x6f, 0x64, 0x65, 0x12, 0x6a, 0x0a, 0x0d, 0x53, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, + 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x53, 0x65, 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, + 0x74, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, + 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x74, 0x79, 0x70, + 0x65, 0x12, 0x62, 0x0a, 0x0b, 0x53, 0x65, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, + 0x12, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x4c, 0x65, 0x76, + 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, + 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6c, 0x65, 0x76, + 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x86, 0x01, 0x0a, 0x14, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x12, 0x23, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x61, 0x72, 0x67, 0x69, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x1d, 0x3a, 0x01, 0x2a, 0x22, 0x18, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x42, 0x30, + 0x5a, 0x2e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x74, 0x68, 0x72, + 0x61, 0x73, 0x68, 0x65, 0x72, 0x2d, 0x63, 0x6f, 0x72, 0x70, 0x2f, 0x67, 0x6f, 0x63, 0x72, 0x79, + 0x70, 0x74, 0x6f, 0x74, 0x72, 0x61, 0x64, 0x65, 0x72, 0x2f, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -17080,7 +18580,7 @@ func file_rpc_proto_rawDescGZIP() []byte { return file_rpc_proto_rawDescData } -var file_rpc_proto_msgTypes = make([]protoimpl.MessageInfo, 218) +var file_rpc_proto_msgTypes = make([]protoimpl.MessageInfo, 234) var file_rpc_proto_goTypes = []interface{}{ (*GetInfoRequest)(nil), // 0: gctrpc.GetInfoRequest (*GetInfoResponse)(nil), // 1: gctrpc.GetInfoResponse @@ -17259,57 +18759,73 @@ var file_rpc_proto_goTypes = []interface{}{ (*GetManagedPositionRequest)(nil), // 174: gctrpc.GetManagedPositionRequest (*GetAllManagedPositionsRequest)(nil), // 175: gctrpc.GetAllManagedPositionsRequest (*GetManagedPositionsResponse)(nil), // 176: gctrpc.GetManagedPositionsResponse - (*GetFuturesPositionsRequest)(nil), // 177: gctrpc.GetFuturesPositionsRequest - (*GetFuturesPositionsResponse)(nil), // 178: gctrpc.GetFuturesPositionsResponse - (*GetCollateralRequest)(nil), // 179: gctrpc.GetCollateralRequest - (*GetCollateralResponse)(nil), // 180: gctrpc.GetCollateralResponse - (*CollateralForCurrency)(nil), // 181: gctrpc.CollateralForCurrency - (*CollateralByPosition)(nil), // 182: gctrpc.CollateralByPosition - (*CollateralUsedBreakdown)(nil), // 183: gctrpc.CollateralUsedBreakdown - (*GetFundingRatesRequest)(nil), // 184: gctrpc.GetFundingRatesRequest - (*GetFundingRatesResponse)(nil), // 185: gctrpc.GetFundingRatesResponse - (*GetLatestFundingRateRequest)(nil), // 186: gctrpc.GetLatestFundingRateRequest - (*GetLatestFundingRateResponse)(nil), // 187: gctrpc.GetLatestFundingRateResponse - (*ShutdownRequest)(nil), // 188: gctrpc.ShutdownRequest - (*ShutdownResponse)(nil), // 189: gctrpc.ShutdownResponse - (*GetTechnicalAnalysisRequest)(nil), // 190: gctrpc.GetTechnicalAnalysisRequest - (*ListOfSignals)(nil), // 191: gctrpc.ListOfSignals - (*GetTechnicalAnalysisResponse)(nil), // 192: gctrpc.GetTechnicalAnalysisResponse - (*GetMarginRatesHistoryRequest)(nil), // 193: gctrpc.GetMarginRatesHistoryRequest - (*LendingPayment)(nil), // 194: gctrpc.LendingPayment - (*BorrowCost)(nil), // 195: gctrpc.BorrowCost - (*MarginRate)(nil), // 196: gctrpc.MarginRate - (*GetMarginRatesHistoryResponse)(nil), // 197: gctrpc.GetMarginRatesHistoryResponse - (*GetOrderbookMovementRequest)(nil), // 198: gctrpc.GetOrderbookMovementRequest - (*GetOrderbookMovementResponse)(nil), // 199: gctrpc.GetOrderbookMovementResponse - (*GetOrderbookAmountByNominalRequest)(nil), // 200: gctrpc.GetOrderbookAmountByNominalRequest - (*GetOrderbookAmountByNominalResponse)(nil), // 201: gctrpc.GetOrderbookAmountByNominalResponse - (*GetOrderbookAmountByImpactRequest)(nil), // 202: gctrpc.GetOrderbookAmountByImpactRequest - (*GetOrderbookAmountByImpactResponse)(nil), // 203: gctrpc.GetOrderbookAmountByImpactResponse - nil, // 204: gctrpc.GetInfoResponse.SubsystemStatusEntry - nil, // 205: gctrpc.GetInfoResponse.RpcEndpointsEntry - nil, // 206: gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry - nil, // 207: gctrpc.GetSusbsytemsResponse.SubsystemsStatusEntry - nil, // 208: gctrpc.GetRPCEndpointsResponse.EndpointsEntry - nil, // 209: gctrpc.GetExchangeOTPsResponse.OtpCodesEntry - nil, // 210: gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry - nil, // 211: gctrpc.OnlineCoins.CoinsEntry - nil, // 212: gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry - nil, // 213: gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry - nil, // 214: gctrpc.Orders.OrderStatusEntry - nil, // 215: gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry - nil, // 216: gctrpc.GetExchangePairsResponse.SupportedAssetsEntry - nil, // 217: gctrpc.GetTechnicalAnalysisResponse.SignalsEntry - (*timestamppb.Timestamp)(nil), // 218: google.protobuf.Timestamp + (*GetFuturesPositionsSummaryRequest)(nil), // 177: gctrpc.GetFuturesPositionsSummaryRequest + (*GetFuturesPositionsSummaryResponse)(nil), // 178: gctrpc.GetFuturesPositionsSummaryResponse + (*GetFuturesPositionsOrdersRequest)(nil), // 179: gctrpc.GetFuturesPositionsOrdersRequest + (*GetFuturesPositionsOrdersResponse)(nil), // 180: gctrpc.GetFuturesPositionsOrdersResponse + (*GetCollateralModeRequest)(nil), // 181: gctrpc.GetCollateralModeRequest + (*GetCollateralModeResponse)(nil), // 182: gctrpc.GetCollateralModeResponse + (*SetCollateralModeRequest)(nil), // 183: gctrpc.SetCollateralModeRequest + (*SetCollateralModeResponse)(nil), // 184: gctrpc.SetCollateralModeResponse + (*GetMarginTypeRequest)(nil), // 185: gctrpc.GetMarginTypeRequest + (*GetMarginTypeResponse)(nil), // 186: gctrpc.GetMarginTypeResponse + (*ChangePositionMarginRequest)(nil), // 187: gctrpc.ChangePositionMarginRequest + (*ChangePositionMarginResponse)(nil), // 188: gctrpc.ChangePositionMarginResponse + (*SetMarginTypeRequest)(nil), // 189: gctrpc.SetMarginTypeRequest + (*SetMarginTypeResponse)(nil), // 190: gctrpc.SetMarginTypeResponse + (*GetLeverageRequest)(nil), // 191: gctrpc.GetLeverageRequest + (*GetLeverageResponse)(nil), // 192: gctrpc.GetLeverageResponse + (*SetLeverageRequest)(nil), // 193: gctrpc.SetLeverageRequest + (*SetLeverageResponse)(nil), // 194: gctrpc.SetLeverageResponse + (*GetCollateralRequest)(nil), // 195: gctrpc.GetCollateralRequest + (*GetCollateralResponse)(nil), // 196: gctrpc.GetCollateralResponse + (*CollateralForCurrency)(nil), // 197: gctrpc.CollateralForCurrency + (*CollateralByPosition)(nil), // 198: gctrpc.CollateralByPosition + (*CollateralUsedBreakdown)(nil), // 199: gctrpc.CollateralUsedBreakdown + (*GetFundingRatesRequest)(nil), // 200: gctrpc.GetFundingRatesRequest + (*GetFundingRatesResponse)(nil), // 201: gctrpc.GetFundingRatesResponse + (*GetLatestFundingRateRequest)(nil), // 202: gctrpc.GetLatestFundingRateRequest + (*GetLatestFundingRateResponse)(nil), // 203: gctrpc.GetLatestFundingRateResponse + (*ShutdownRequest)(nil), // 204: gctrpc.ShutdownRequest + (*ShutdownResponse)(nil), // 205: gctrpc.ShutdownResponse + (*GetTechnicalAnalysisRequest)(nil), // 206: gctrpc.GetTechnicalAnalysisRequest + (*ListOfSignals)(nil), // 207: gctrpc.ListOfSignals + (*GetTechnicalAnalysisResponse)(nil), // 208: gctrpc.GetTechnicalAnalysisResponse + (*GetMarginRatesHistoryRequest)(nil), // 209: gctrpc.GetMarginRatesHistoryRequest + (*LendingPayment)(nil), // 210: gctrpc.LendingPayment + (*BorrowCost)(nil), // 211: gctrpc.BorrowCost + (*MarginRate)(nil), // 212: gctrpc.MarginRate + (*GetMarginRatesHistoryResponse)(nil), // 213: gctrpc.GetMarginRatesHistoryResponse + (*GetOrderbookMovementRequest)(nil), // 214: gctrpc.GetOrderbookMovementRequest + (*GetOrderbookMovementResponse)(nil), // 215: gctrpc.GetOrderbookMovementResponse + (*GetOrderbookAmountByNominalRequest)(nil), // 216: gctrpc.GetOrderbookAmountByNominalRequest + (*GetOrderbookAmountByNominalResponse)(nil), // 217: gctrpc.GetOrderbookAmountByNominalResponse + (*GetOrderbookAmountByImpactRequest)(nil), // 218: gctrpc.GetOrderbookAmountByImpactRequest + (*GetOrderbookAmountByImpactResponse)(nil), // 219: gctrpc.GetOrderbookAmountByImpactResponse + nil, // 220: gctrpc.GetInfoResponse.SubsystemStatusEntry + nil, // 221: gctrpc.GetInfoResponse.RpcEndpointsEntry + nil, // 222: gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry + nil, // 223: gctrpc.GetSusbsytemsResponse.SubsystemsStatusEntry + nil, // 224: gctrpc.GetRPCEndpointsResponse.EndpointsEntry + nil, // 225: gctrpc.GetExchangeOTPsResponse.OtpCodesEntry + nil, // 226: gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry + nil, // 227: gctrpc.OnlineCoins.CoinsEntry + nil, // 228: gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry + nil, // 229: gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry + nil, // 230: gctrpc.Orders.OrderStatusEntry + nil, // 231: gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry + nil, // 232: gctrpc.GetExchangePairsResponse.SupportedAssetsEntry + nil, // 233: gctrpc.GetTechnicalAnalysisResponse.SignalsEntry + (*timestamppb.Timestamp)(nil), // 234: google.protobuf.Timestamp } var file_rpc_proto_depIdxs = []int32{ - 204, // 0: gctrpc.GetInfoResponse.subsystem_status:type_name -> gctrpc.GetInfoResponse.SubsystemStatusEntry - 205, // 1: gctrpc.GetInfoResponse.rpc_endpoints:type_name -> gctrpc.GetInfoResponse.RpcEndpointsEntry - 206, // 2: gctrpc.GetCommunicationRelayersResponse.communication_relayers:type_name -> gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry - 207, // 3: gctrpc.GetSusbsytemsResponse.subsystems_status:type_name -> gctrpc.GetSusbsytemsResponse.SubsystemsStatusEntry - 208, // 4: gctrpc.GetRPCEndpointsResponse.endpoints:type_name -> gctrpc.GetRPCEndpointsResponse.EndpointsEntry - 209, // 5: gctrpc.GetExchangeOTPsResponse.otp_codes:type_name -> gctrpc.GetExchangeOTPsResponse.OtpCodesEntry - 210, // 6: gctrpc.GetExchangeInfoResponse.supported_assets:type_name -> gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry + 220, // 0: gctrpc.GetInfoResponse.subsystem_status:type_name -> gctrpc.GetInfoResponse.SubsystemStatusEntry + 221, // 1: gctrpc.GetInfoResponse.rpc_endpoints:type_name -> gctrpc.GetInfoResponse.RpcEndpointsEntry + 222, // 2: gctrpc.GetCommunicationRelayersResponse.communication_relayers:type_name -> gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry + 223, // 3: gctrpc.GetSusbsytemsResponse.subsystems_status:type_name -> gctrpc.GetSusbsytemsResponse.SubsystemsStatusEntry + 224, // 4: gctrpc.GetRPCEndpointsResponse.endpoints:type_name -> gctrpc.GetRPCEndpointsResponse.EndpointsEntry + 225, // 5: gctrpc.GetExchangeOTPsResponse.otp_codes:type_name -> gctrpc.GetExchangeOTPsResponse.OtpCodesEntry + 226, // 6: gctrpc.GetExchangeInfoResponse.supported_assets:type_name -> gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry 21, // 7: gctrpc.GetTickerRequest.pair:type_name -> gctrpc.CurrencyPair 21, // 8: gctrpc.TickerResponse.pair:type_name -> gctrpc.CurrencyPair 22, // 9: gctrpc.Tickers.tickers:type_name -> gctrpc.TickerResponse @@ -17324,12 +18840,12 @@ var file_rpc_proto_depIdxs = []int32{ 33, // 18: gctrpc.GetAccountInfoResponse.accounts:type_name -> gctrpc.Account 38, // 19: gctrpc.GetPortfolioResponse.portfolio:type_name -> gctrpc.PortfolioAddress 43, // 20: gctrpc.OfflineCoins.addresses:type_name -> gctrpc.OfflineCoinSummary - 211, // 21: gctrpc.OnlineCoins.coins:type_name -> gctrpc.OnlineCoins.CoinsEntry + 227, // 21: gctrpc.OnlineCoins.coins:type_name -> gctrpc.OnlineCoins.CoinsEntry 42, // 22: gctrpc.GetPortfolioSummaryResponse.coin_totals:type_name -> gctrpc.Coin 42, // 23: gctrpc.GetPortfolioSummaryResponse.coins_offline:type_name -> gctrpc.Coin - 212, // 24: gctrpc.GetPortfolioSummaryResponse.coins_offline_summary:type_name -> gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry + 228, // 24: gctrpc.GetPortfolioSummaryResponse.coins_offline_summary:type_name -> gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry 42, // 25: gctrpc.GetPortfolioSummaryResponse.coins_online:type_name -> gctrpc.Coin - 213, // 26: gctrpc.GetPortfolioSummaryResponse.coins_online_summary:type_name -> gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry + 229, // 26: gctrpc.GetPortfolioSummaryResponse.coins_online_summary:type_name -> gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry 51, // 27: gctrpc.GetForexProvidersResponse.forex_providers:type_name -> gctrpc.ForexProvider 54, // 28: gctrpc.GetForexRatesResponse.forex_rates:type_name -> gctrpc.ForexRatesConversion 57, // 29: gctrpc.OrderDetails.trades:type_name -> gctrpc.TradeHistory @@ -17343,7 +18859,7 @@ var file_rpc_proto_depIdxs = []int32{ 21, // 37: gctrpc.WhaleBombRequest.pair:type_name -> gctrpc.CurrencyPair 21, // 38: gctrpc.CancelOrderRequest.pair:type_name -> gctrpc.CurrencyPair 21, // 39: gctrpc.CancelBatchOrdersRequest.pair:type_name -> gctrpc.CurrencyPair - 214, // 40: gctrpc.Orders.order_status:type_name -> gctrpc.Orders.OrderStatusEntry + 230, // 40: gctrpc.Orders.order_status:type_name -> gctrpc.Orders.OrderStatusEntry 69, // 41: gctrpc.CancelBatchOrdersResponse.orders:type_name -> gctrpc.Orders 69, // 42: gctrpc.CancelAllOrdersResponse.orders:type_name -> gctrpc.Orders 74, // 43: gctrpc.GetEventsResponse.condition_params:type_name -> gctrpc.ConditionParams @@ -17351,16 +18867,16 @@ var file_rpc_proto_depIdxs = []int32{ 74, // 45: gctrpc.AddEventRequest.condition_params:type_name -> gctrpc.ConditionParams 21, // 46: gctrpc.AddEventRequest.pair:type_name -> gctrpc.CurrencyPair 80, // 47: gctrpc.DepositAddresses.addresses:type_name -> gctrpc.DepositAddress - 215, // 48: gctrpc.GetCryptocurrencyDepositAddressesResponse.addresses:type_name -> gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry + 231, // 48: gctrpc.GetCryptocurrencyDepositAddressesResponse.addresses:type_name -> gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry 95, // 49: gctrpc.WithdrawalEventByIDResponse.event:type_name -> gctrpc.WithdrawalEventResponse 95, // 50: gctrpc.WithdrawalEventsByExchangeResponse.event:type_name -> gctrpc.WithdrawalEventResponse 96, // 51: gctrpc.WithdrawalEventResponse.exchange:type_name -> gctrpc.WithdrawlExchangeEvent 97, // 52: gctrpc.WithdrawalEventResponse.request:type_name -> gctrpc.WithdrawalRequestEvent - 218, // 53: gctrpc.WithdrawalEventResponse.created_at:type_name -> google.protobuf.Timestamp - 218, // 54: gctrpc.WithdrawalEventResponse.updated_at:type_name -> google.protobuf.Timestamp + 234, // 53: gctrpc.WithdrawalEventResponse.created_at:type_name -> google.protobuf.Timestamp + 234, // 54: gctrpc.WithdrawalEventResponse.updated_at:type_name -> google.protobuf.Timestamp 98, // 55: gctrpc.WithdrawalRequestEvent.fiat:type_name -> gctrpc.FiatWithdrawalEvent 99, // 56: gctrpc.WithdrawalRequestEvent.crypto:type_name -> gctrpc.CryptoWithdrawalEvent - 216, // 57: gctrpc.GetExchangePairsResponse.supported_assets:type_name -> gctrpc.GetExchangePairsResponse.SupportedAssetsEntry + 232, // 57: gctrpc.GetExchangePairsResponse.supported_assets:type_name -> gctrpc.GetExchangePairsResponse.SupportedAssetsEntry 21, // 58: gctrpc.SetExchangePairRequest.pairs:type_name -> gctrpc.CurrencyPair 21, // 59: gctrpc.GetOrderbookStreamRequest.pair:type_name -> gctrpc.CurrencyPair 21, // 60: gctrpc.GetTickerStreamRequest.pair:type_name -> gctrpc.CurrencyPair @@ -17400,257 +18916,290 @@ var file_rpc_proto_depIdxs = []int32{ 171, // 94: gctrpc.FuturePosition.funding_data:type_name -> gctrpc.FundingData 21, // 95: gctrpc.GetManagedPositionRequest.pair:type_name -> gctrpc.CurrencyPair 173, // 96: gctrpc.GetManagedPositionsResponse.positions:type_name -> gctrpc.FuturePosition - 21, // 97: gctrpc.GetFuturesPositionsRequest.pair:type_name -> gctrpc.CurrencyPair - 173, // 98: gctrpc.GetFuturesPositionsResponse.positions:type_name -> gctrpc.FuturePosition - 183, // 99: gctrpc.GetCollateralResponse.used_breakdown:type_name -> gctrpc.CollateralUsedBreakdown - 181, // 100: gctrpc.GetCollateralResponse.currency_breakdown:type_name -> gctrpc.CollateralForCurrency - 182, // 101: gctrpc.GetCollateralResponse.position_breakdown:type_name -> gctrpc.CollateralByPosition - 183, // 102: gctrpc.CollateralForCurrency.used_breakdown:type_name -> gctrpc.CollateralUsedBreakdown - 21, // 103: gctrpc.GetFundingRatesRequest.pair:type_name -> gctrpc.CurrencyPair - 171, // 104: gctrpc.GetFundingRatesResponse.rates:type_name -> gctrpc.FundingData - 21, // 105: gctrpc.GetLatestFundingRateRequest.pair:type_name -> gctrpc.CurrencyPair - 171, // 106: gctrpc.GetLatestFundingRateResponse.rate:type_name -> gctrpc.FundingData - 21, // 107: gctrpc.GetTechnicalAnalysisRequest.pair:type_name -> gctrpc.CurrencyPair - 218, // 108: gctrpc.GetTechnicalAnalysisRequest.start:type_name -> google.protobuf.Timestamp - 218, // 109: gctrpc.GetTechnicalAnalysisRequest.end:type_name -> google.protobuf.Timestamp - 21, // 110: gctrpc.GetTechnicalAnalysisRequest.other_pair:type_name -> gctrpc.CurrencyPair - 217, // 111: gctrpc.GetTechnicalAnalysisResponse.signals:type_name -> gctrpc.GetTechnicalAnalysisResponse.SignalsEntry - 196, // 112: gctrpc.GetMarginRatesHistoryRequest.rates:type_name -> gctrpc.MarginRate - 194, // 113: gctrpc.MarginRate.lending_payment:type_name -> gctrpc.LendingPayment - 195, // 114: gctrpc.MarginRate.borrow_cost:type_name -> gctrpc.BorrowCost - 196, // 115: gctrpc.GetMarginRatesHistoryResponse.rates:type_name -> gctrpc.MarginRate - 196, // 116: gctrpc.GetMarginRatesHistoryResponse.latest_rate:type_name -> gctrpc.MarginRate - 196, // 117: gctrpc.GetMarginRatesHistoryResponse.predicted_rate:type_name -> gctrpc.MarginRate - 21, // 118: gctrpc.GetOrderbookMovementRequest.pair:type_name -> gctrpc.CurrencyPair - 21, // 119: gctrpc.GetOrderbookAmountByNominalRequest.pair:type_name -> gctrpc.CurrencyPair - 21, // 120: gctrpc.GetOrderbookAmountByImpactRequest.pair:type_name -> gctrpc.CurrencyPair - 9, // 121: gctrpc.GetInfoResponse.RpcEndpointsEntry.value:type_name -> gctrpc.RPCEndpoint - 3, // 122: gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry.value:type_name -> gctrpc.CommunicationRelayer - 9, // 123: gctrpc.GetRPCEndpointsResponse.EndpointsEntry.value:type_name -> gctrpc.RPCEndpoint - 18, // 124: gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry.value:type_name -> gctrpc.PairsSupported - 44, // 125: gctrpc.OnlineCoins.CoinsEntry.value:type_name -> gctrpc.OnlineCoinSummary - 45, // 126: gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry.value:type_name -> gctrpc.OfflineCoins - 46, // 127: gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry.value:type_name -> gctrpc.OnlineCoins - 81, // 128: gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry.value:type_name -> gctrpc.DepositAddresses - 18, // 129: gctrpc.GetExchangePairsResponse.SupportedAssetsEntry.value:type_name -> gctrpc.PairsSupported - 191, // 130: gctrpc.GetTechnicalAnalysisResponse.SignalsEntry.value:type_name -> gctrpc.ListOfSignals - 0, // 131: gctrpc.GoCryptoTraderService.GetInfo:input_type -> gctrpc.GetInfoRequest - 6, // 132: gctrpc.GoCryptoTraderService.GetSubsystems:input_type -> gctrpc.GetSubsystemsRequest - 5, // 133: gctrpc.GoCryptoTraderService.EnableSubsystem:input_type -> gctrpc.GenericSubsystemRequest - 5, // 134: gctrpc.GoCryptoTraderService.DisableSubsystem:input_type -> gctrpc.GenericSubsystemRequest - 8, // 135: gctrpc.GoCryptoTraderService.GetRPCEndpoints:input_type -> gctrpc.GetRPCEndpointsRequest - 2, // 136: gctrpc.GoCryptoTraderService.GetCommunicationRelayers:input_type -> gctrpc.GetCommunicationRelayersRequest - 12, // 137: gctrpc.GoCryptoTraderService.GetExchanges:input_type -> gctrpc.GetExchangesRequest - 11, // 138: gctrpc.GoCryptoTraderService.DisableExchange:input_type -> gctrpc.GenericExchangeNameRequest - 11, // 139: gctrpc.GoCryptoTraderService.GetExchangeInfo:input_type -> gctrpc.GenericExchangeNameRequest - 11, // 140: gctrpc.GoCryptoTraderService.GetExchangeOTPCode:input_type -> gctrpc.GenericExchangeNameRequest - 15, // 141: gctrpc.GoCryptoTraderService.GetExchangeOTPCodes:input_type -> gctrpc.GetExchangeOTPsRequest - 11, // 142: gctrpc.GoCryptoTraderService.EnableExchange:input_type -> gctrpc.GenericExchangeNameRequest - 20, // 143: gctrpc.GoCryptoTraderService.GetTicker:input_type -> gctrpc.GetTickerRequest - 23, // 144: gctrpc.GoCryptoTraderService.GetTickers:input_type -> gctrpc.GetTickersRequest - 26, // 145: gctrpc.GoCryptoTraderService.GetOrderbook:input_type -> gctrpc.GetOrderbookRequest - 29, // 146: gctrpc.GoCryptoTraderService.GetOrderbooks:input_type -> gctrpc.GetOrderbooksRequest - 32, // 147: gctrpc.GoCryptoTraderService.GetAccountInfo:input_type -> gctrpc.GetAccountInfoRequest - 32, // 148: gctrpc.GoCryptoTraderService.UpdateAccountInfo:input_type -> gctrpc.GetAccountInfoRequest - 32, // 149: gctrpc.GoCryptoTraderService.GetAccountInfoStream:input_type -> gctrpc.GetAccountInfoRequest - 36, // 150: gctrpc.GoCryptoTraderService.GetConfig:input_type -> gctrpc.GetConfigRequest - 39, // 151: gctrpc.GoCryptoTraderService.GetPortfolio:input_type -> gctrpc.GetPortfolioRequest - 41, // 152: gctrpc.GoCryptoTraderService.GetPortfolioSummary:input_type -> gctrpc.GetPortfolioSummaryRequest - 48, // 153: gctrpc.GoCryptoTraderService.AddPortfolioAddress:input_type -> gctrpc.AddPortfolioAddressRequest - 49, // 154: gctrpc.GoCryptoTraderService.RemovePortfolioAddress:input_type -> gctrpc.RemovePortfolioAddressRequest - 50, // 155: gctrpc.GoCryptoTraderService.GetForexProviders:input_type -> gctrpc.GetForexProvidersRequest - 53, // 156: gctrpc.GoCryptoTraderService.GetForexRates:input_type -> gctrpc.GetForexRatesRequest - 58, // 157: gctrpc.GoCryptoTraderService.GetOrders:input_type -> gctrpc.GetOrdersRequest - 60, // 158: gctrpc.GoCryptoTraderService.GetOrder:input_type -> gctrpc.GetOrderRequest - 61, // 159: gctrpc.GoCryptoTraderService.SubmitOrder:input_type -> gctrpc.SubmitOrderRequest - 64, // 160: gctrpc.GoCryptoTraderService.SimulateOrder:input_type -> gctrpc.SimulateOrderRequest - 66, // 161: gctrpc.GoCryptoTraderService.WhaleBomb:input_type -> gctrpc.WhaleBombRequest - 67, // 162: gctrpc.GoCryptoTraderService.CancelOrder:input_type -> gctrpc.CancelOrderRequest - 68, // 163: gctrpc.GoCryptoTraderService.CancelBatchOrders:input_type -> gctrpc.CancelBatchOrdersRequest - 71, // 164: gctrpc.GoCryptoTraderService.CancelAllOrders:input_type -> gctrpc.CancelAllOrdersRequest - 73, // 165: gctrpc.GoCryptoTraderService.GetEvents:input_type -> gctrpc.GetEventsRequest - 76, // 166: gctrpc.GoCryptoTraderService.AddEvent:input_type -> gctrpc.AddEventRequest - 78, // 167: gctrpc.GoCryptoTraderService.RemoveEvent:input_type -> gctrpc.RemoveEventRequest - 79, // 168: gctrpc.GoCryptoTraderService.GetCryptocurrencyDepositAddresses:input_type -> gctrpc.GetCryptocurrencyDepositAddressesRequest - 83, // 169: gctrpc.GoCryptoTraderService.GetCryptocurrencyDepositAddress:input_type -> gctrpc.GetCryptocurrencyDepositAddressRequest - 85, // 170: gctrpc.GoCryptoTraderService.GetAvailableTransferChains:input_type -> gctrpc.GetAvailableTransferChainsRequest - 87, // 171: gctrpc.GoCryptoTraderService.WithdrawFiatFunds:input_type -> gctrpc.WithdrawFiatRequest - 88, // 172: gctrpc.GoCryptoTraderService.WithdrawCryptocurrencyFunds:input_type -> gctrpc.WithdrawCryptoRequest - 90, // 173: gctrpc.GoCryptoTraderService.WithdrawalEventByID:input_type -> gctrpc.WithdrawalEventByIDRequest - 92, // 174: gctrpc.GoCryptoTraderService.WithdrawalEventsByExchange:input_type -> gctrpc.WithdrawalEventsByExchangeRequest - 93, // 175: gctrpc.GoCryptoTraderService.WithdrawalEventsByDate:input_type -> gctrpc.WithdrawalEventsByDateRequest - 100, // 176: gctrpc.GoCryptoTraderService.GetLoggerDetails:input_type -> gctrpc.GetLoggerDetailsRequest - 102, // 177: gctrpc.GoCryptoTraderService.SetLoggerDetails:input_type -> gctrpc.SetLoggerDetailsRequest - 103, // 178: gctrpc.GoCryptoTraderService.GetExchangePairs:input_type -> gctrpc.GetExchangePairsRequest - 105, // 179: gctrpc.GoCryptoTraderService.SetExchangePair:input_type -> gctrpc.SetExchangePairRequest - 106, // 180: gctrpc.GoCryptoTraderService.GetOrderbookStream:input_type -> gctrpc.GetOrderbookStreamRequest - 107, // 181: gctrpc.GoCryptoTraderService.GetExchangeOrderbookStream:input_type -> gctrpc.GetExchangeOrderbookStreamRequest - 108, // 182: gctrpc.GoCryptoTraderService.GetTickerStream:input_type -> gctrpc.GetTickerStreamRequest - 109, // 183: gctrpc.GoCryptoTraderService.GetExchangeTickerStream:input_type -> gctrpc.GetExchangeTickerStreamRequest - 110, // 184: gctrpc.GoCryptoTraderService.GetAuditEvent:input_type -> gctrpc.GetAuditEventRequest - 121, // 185: gctrpc.GoCryptoTraderService.GCTScriptExecute:input_type -> gctrpc.GCTScriptExecuteRequest - 126, // 186: gctrpc.GoCryptoTraderService.GCTScriptUpload:input_type -> gctrpc.GCTScriptUploadRequest - 127, // 187: gctrpc.GoCryptoTraderService.GCTScriptReadScript:input_type -> gctrpc.GCTScriptReadScriptRequest - 124, // 188: gctrpc.GoCryptoTraderService.GCTScriptStatus:input_type -> gctrpc.GCTScriptStatusRequest - 128, // 189: gctrpc.GoCryptoTraderService.GCTScriptQuery:input_type -> gctrpc.GCTScriptQueryRequest - 122, // 190: gctrpc.GoCryptoTraderService.GCTScriptStop:input_type -> gctrpc.GCTScriptStopRequest - 123, // 191: gctrpc.GoCryptoTraderService.GCTScriptStopAll:input_type -> gctrpc.GCTScriptStopAllRequest - 125, // 192: gctrpc.GoCryptoTraderService.GCTScriptListAll:input_type -> gctrpc.GCTScriptListAllRequest - 129, // 193: gctrpc.GoCryptoTraderService.GCTScriptAutoLoadToggle:input_type -> gctrpc.GCTScriptAutoLoadRequest - 116, // 194: gctrpc.GoCryptoTraderService.GetHistoricCandles:input_type -> gctrpc.GetHistoricCandlesRequest - 133, // 195: gctrpc.GoCryptoTraderService.SetExchangeAsset:input_type -> gctrpc.SetExchangeAssetRequest - 134, // 196: gctrpc.GoCryptoTraderService.SetAllExchangePairs:input_type -> gctrpc.SetExchangeAllPairsRequest - 135, // 197: gctrpc.GoCryptoTraderService.UpdateExchangeSupportedPairs:input_type -> gctrpc.UpdateExchangeSupportedPairsRequest - 136, // 198: gctrpc.GoCryptoTraderService.GetExchangeAssets:input_type -> gctrpc.GetExchangeAssetsRequest - 138, // 199: gctrpc.GoCryptoTraderService.WebsocketGetInfo:input_type -> gctrpc.WebsocketGetInfoRequest - 140, // 200: gctrpc.GoCryptoTraderService.WebsocketSetEnabled:input_type -> gctrpc.WebsocketSetEnabledRequest - 141, // 201: gctrpc.GoCryptoTraderService.WebsocketGetSubscriptions:input_type -> gctrpc.WebsocketGetSubscriptionsRequest - 144, // 202: gctrpc.GoCryptoTraderService.WebsocketSetProxy:input_type -> gctrpc.WebsocketSetProxyRequest - 145, // 203: gctrpc.GoCryptoTraderService.WebsocketSetURL:input_type -> gctrpc.WebsocketSetURLRequest - 112, // 204: gctrpc.GoCryptoTraderService.GetRecentTrades:input_type -> gctrpc.GetSavedTradesRequest - 112, // 205: gctrpc.GoCryptoTraderService.GetHistoricTrades:input_type -> gctrpc.GetSavedTradesRequest - 112, // 206: gctrpc.GoCryptoTraderService.GetSavedTrades:input_type -> gctrpc.GetSavedTradesRequest - 115, // 207: gctrpc.GoCryptoTraderService.ConvertTradesToCandles:input_type -> gctrpc.ConvertTradesToCandlesRequest - 146, // 208: gctrpc.GoCryptoTraderService.FindMissingSavedCandleIntervals:input_type -> gctrpc.FindMissingCandlePeriodsRequest - 147, // 209: gctrpc.GoCryptoTraderService.FindMissingSavedTradeIntervals:input_type -> gctrpc.FindMissingTradePeriodsRequest - 149, // 210: gctrpc.GoCryptoTraderService.SetExchangeTradeProcessing:input_type -> gctrpc.SetExchangeTradeProcessingRequest - 150, // 211: gctrpc.GoCryptoTraderService.UpsertDataHistoryJob:input_type -> gctrpc.UpsertDataHistoryJobRequest - 154, // 212: gctrpc.GoCryptoTraderService.GetDataHistoryJobDetails:input_type -> gctrpc.GetDataHistoryJobDetailsRequest - 0, // 213: gctrpc.GoCryptoTraderService.GetActiveDataHistoryJobs:input_type -> gctrpc.GetInfoRequest - 158, // 214: gctrpc.GoCryptoTraderService.GetDataHistoryJobsBetween:input_type -> gctrpc.GetDataHistoryJobsBetweenRequest - 154, // 215: gctrpc.GoCryptoTraderService.GetDataHistoryJobSummary:input_type -> gctrpc.GetDataHistoryJobDetailsRequest - 159, // 216: gctrpc.GoCryptoTraderService.SetDataHistoryJobStatus:input_type -> gctrpc.SetDataHistoryJobStatusRequest - 160, // 217: gctrpc.GoCryptoTraderService.UpdateDataHistoryJobPrerequisite:input_type -> gctrpc.UpdateDataHistoryJobPrerequisiteRequest - 58, // 218: gctrpc.GoCryptoTraderService.GetManagedOrders:input_type -> gctrpc.GetOrdersRequest - 161, // 219: gctrpc.GoCryptoTraderService.ModifyOrder:input_type -> gctrpc.ModifyOrderRequest - 163, // 220: gctrpc.GoCryptoTraderService.CurrencyStateGetAll:input_type -> gctrpc.CurrencyStateGetAllRequest - 164, // 221: gctrpc.GoCryptoTraderService.CurrencyStateTrading:input_type -> gctrpc.CurrencyStateTradingRequest - 167, // 222: gctrpc.GoCryptoTraderService.CurrencyStateDeposit:input_type -> gctrpc.CurrencyStateDepositRequest - 166, // 223: gctrpc.GoCryptoTraderService.CurrencyStateWithdraw:input_type -> gctrpc.CurrencyStateWithdrawRequest - 165, // 224: gctrpc.GoCryptoTraderService.CurrencyStateTradingPair:input_type -> gctrpc.CurrencyStateTradingPairRequest - 177, // 225: gctrpc.GoCryptoTraderService.GetFuturesPositions:input_type -> gctrpc.GetFuturesPositionsRequest - 179, // 226: gctrpc.GoCryptoTraderService.GetCollateral:input_type -> gctrpc.GetCollateralRequest - 188, // 227: gctrpc.GoCryptoTraderService.Shutdown:input_type -> gctrpc.ShutdownRequest - 190, // 228: gctrpc.GoCryptoTraderService.GetTechnicalAnalysis:input_type -> gctrpc.GetTechnicalAnalysisRequest - 193, // 229: gctrpc.GoCryptoTraderService.GetMarginRatesHistory:input_type -> gctrpc.GetMarginRatesHistoryRequest - 174, // 230: gctrpc.GoCryptoTraderService.GetManagedPosition:input_type -> gctrpc.GetManagedPositionRequest - 175, // 231: gctrpc.GoCryptoTraderService.GetAllManagedPositions:input_type -> gctrpc.GetAllManagedPositionsRequest - 184, // 232: gctrpc.GoCryptoTraderService.GetFundingRates:input_type -> gctrpc.GetFundingRatesRequest - 186, // 233: gctrpc.GoCryptoTraderService.GetLatestFundingRate:input_type -> gctrpc.GetLatestFundingRateRequest - 198, // 234: gctrpc.GoCryptoTraderService.GetOrderbookMovement:input_type -> gctrpc.GetOrderbookMovementRequest - 200, // 235: gctrpc.GoCryptoTraderService.GetOrderbookAmountByNominal:input_type -> gctrpc.GetOrderbookAmountByNominalRequest - 202, // 236: gctrpc.GoCryptoTraderService.GetOrderbookAmountByImpact:input_type -> gctrpc.GetOrderbookAmountByImpactRequest - 1, // 237: gctrpc.GoCryptoTraderService.GetInfo:output_type -> gctrpc.GetInfoResponse - 7, // 238: gctrpc.GoCryptoTraderService.GetSubsystems:output_type -> gctrpc.GetSusbsytemsResponse - 132, // 239: gctrpc.GoCryptoTraderService.EnableSubsystem:output_type -> gctrpc.GenericResponse - 132, // 240: gctrpc.GoCryptoTraderService.DisableSubsystem:output_type -> gctrpc.GenericResponse - 10, // 241: gctrpc.GoCryptoTraderService.GetRPCEndpoints:output_type -> gctrpc.GetRPCEndpointsResponse - 4, // 242: gctrpc.GoCryptoTraderService.GetCommunicationRelayers:output_type -> gctrpc.GetCommunicationRelayersResponse - 13, // 243: gctrpc.GoCryptoTraderService.GetExchanges:output_type -> gctrpc.GetExchangesResponse - 132, // 244: gctrpc.GoCryptoTraderService.DisableExchange:output_type -> gctrpc.GenericResponse - 19, // 245: gctrpc.GoCryptoTraderService.GetExchangeInfo:output_type -> gctrpc.GetExchangeInfoResponse - 14, // 246: gctrpc.GoCryptoTraderService.GetExchangeOTPCode:output_type -> gctrpc.GetExchangeOTPResponse - 16, // 247: gctrpc.GoCryptoTraderService.GetExchangeOTPCodes:output_type -> gctrpc.GetExchangeOTPsResponse - 132, // 248: gctrpc.GoCryptoTraderService.EnableExchange:output_type -> gctrpc.GenericResponse - 22, // 249: gctrpc.GoCryptoTraderService.GetTicker:output_type -> gctrpc.TickerResponse - 25, // 250: gctrpc.GoCryptoTraderService.GetTickers:output_type -> gctrpc.GetTickersResponse - 28, // 251: gctrpc.GoCryptoTraderService.GetOrderbook:output_type -> gctrpc.OrderbookResponse - 31, // 252: gctrpc.GoCryptoTraderService.GetOrderbooks:output_type -> gctrpc.GetOrderbooksResponse - 35, // 253: gctrpc.GoCryptoTraderService.GetAccountInfo:output_type -> gctrpc.GetAccountInfoResponse - 35, // 254: gctrpc.GoCryptoTraderService.UpdateAccountInfo:output_type -> gctrpc.GetAccountInfoResponse - 35, // 255: gctrpc.GoCryptoTraderService.GetAccountInfoStream:output_type -> gctrpc.GetAccountInfoResponse - 37, // 256: gctrpc.GoCryptoTraderService.GetConfig:output_type -> gctrpc.GetConfigResponse - 40, // 257: gctrpc.GoCryptoTraderService.GetPortfolio:output_type -> gctrpc.GetPortfolioResponse - 47, // 258: gctrpc.GoCryptoTraderService.GetPortfolioSummary:output_type -> gctrpc.GetPortfolioSummaryResponse - 132, // 259: gctrpc.GoCryptoTraderService.AddPortfolioAddress:output_type -> gctrpc.GenericResponse - 132, // 260: gctrpc.GoCryptoTraderService.RemovePortfolioAddress:output_type -> gctrpc.GenericResponse - 52, // 261: gctrpc.GoCryptoTraderService.GetForexProviders:output_type -> gctrpc.GetForexProvidersResponse - 55, // 262: gctrpc.GoCryptoTraderService.GetForexRates:output_type -> gctrpc.GetForexRatesResponse - 59, // 263: gctrpc.GoCryptoTraderService.GetOrders:output_type -> gctrpc.GetOrdersResponse - 56, // 264: gctrpc.GoCryptoTraderService.GetOrder:output_type -> gctrpc.OrderDetails - 63, // 265: gctrpc.GoCryptoTraderService.SubmitOrder:output_type -> gctrpc.SubmitOrderResponse - 65, // 266: gctrpc.GoCryptoTraderService.SimulateOrder:output_type -> gctrpc.SimulateOrderResponse - 65, // 267: gctrpc.GoCryptoTraderService.WhaleBomb:output_type -> gctrpc.SimulateOrderResponse - 132, // 268: gctrpc.GoCryptoTraderService.CancelOrder:output_type -> gctrpc.GenericResponse - 70, // 269: gctrpc.GoCryptoTraderService.CancelBatchOrders:output_type -> gctrpc.CancelBatchOrdersResponse - 72, // 270: gctrpc.GoCryptoTraderService.CancelAllOrders:output_type -> gctrpc.CancelAllOrdersResponse - 75, // 271: gctrpc.GoCryptoTraderService.GetEvents:output_type -> gctrpc.GetEventsResponse - 77, // 272: gctrpc.GoCryptoTraderService.AddEvent:output_type -> gctrpc.AddEventResponse - 132, // 273: gctrpc.GoCryptoTraderService.RemoveEvent:output_type -> gctrpc.GenericResponse - 82, // 274: gctrpc.GoCryptoTraderService.GetCryptocurrencyDepositAddresses:output_type -> gctrpc.GetCryptocurrencyDepositAddressesResponse - 84, // 275: gctrpc.GoCryptoTraderService.GetCryptocurrencyDepositAddress:output_type -> gctrpc.GetCryptocurrencyDepositAddressResponse - 86, // 276: gctrpc.GoCryptoTraderService.GetAvailableTransferChains:output_type -> gctrpc.GetAvailableTransferChainsResponse - 89, // 277: gctrpc.GoCryptoTraderService.WithdrawFiatFunds:output_type -> gctrpc.WithdrawResponse - 89, // 278: gctrpc.GoCryptoTraderService.WithdrawCryptocurrencyFunds:output_type -> gctrpc.WithdrawResponse - 91, // 279: gctrpc.GoCryptoTraderService.WithdrawalEventByID:output_type -> gctrpc.WithdrawalEventByIDResponse - 94, // 280: gctrpc.GoCryptoTraderService.WithdrawalEventsByExchange:output_type -> gctrpc.WithdrawalEventsByExchangeResponse - 94, // 281: gctrpc.GoCryptoTraderService.WithdrawalEventsByDate:output_type -> gctrpc.WithdrawalEventsByExchangeResponse - 101, // 282: gctrpc.GoCryptoTraderService.GetLoggerDetails:output_type -> gctrpc.GetLoggerDetailsResponse - 101, // 283: gctrpc.GoCryptoTraderService.SetLoggerDetails:output_type -> gctrpc.GetLoggerDetailsResponse - 104, // 284: gctrpc.GoCryptoTraderService.GetExchangePairs:output_type -> gctrpc.GetExchangePairsResponse - 132, // 285: gctrpc.GoCryptoTraderService.SetExchangePair:output_type -> gctrpc.GenericResponse - 28, // 286: gctrpc.GoCryptoTraderService.GetOrderbookStream:output_type -> gctrpc.OrderbookResponse - 28, // 287: gctrpc.GoCryptoTraderService.GetExchangeOrderbookStream:output_type -> gctrpc.OrderbookResponse - 22, // 288: gctrpc.GoCryptoTraderService.GetTickerStream:output_type -> gctrpc.TickerResponse - 22, // 289: gctrpc.GoCryptoTraderService.GetExchangeTickerStream:output_type -> gctrpc.TickerResponse - 111, // 290: gctrpc.GoCryptoTraderService.GetAuditEvent:output_type -> gctrpc.GetAuditEventResponse - 132, // 291: gctrpc.GoCryptoTraderService.GCTScriptExecute:output_type -> gctrpc.GenericResponse - 132, // 292: gctrpc.GoCryptoTraderService.GCTScriptUpload:output_type -> gctrpc.GenericResponse - 131, // 293: gctrpc.GoCryptoTraderService.GCTScriptReadScript:output_type -> gctrpc.GCTScriptQueryResponse - 130, // 294: gctrpc.GoCryptoTraderService.GCTScriptStatus:output_type -> gctrpc.GCTScriptStatusResponse - 131, // 295: gctrpc.GoCryptoTraderService.GCTScriptQuery:output_type -> gctrpc.GCTScriptQueryResponse - 132, // 296: gctrpc.GoCryptoTraderService.GCTScriptStop:output_type -> gctrpc.GenericResponse - 132, // 297: gctrpc.GoCryptoTraderService.GCTScriptStopAll:output_type -> gctrpc.GenericResponse - 130, // 298: gctrpc.GoCryptoTraderService.GCTScriptListAll:output_type -> gctrpc.GCTScriptStatusResponse - 132, // 299: gctrpc.GoCryptoTraderService.GCTScriptAutoLoadToggle:output_type -> gctrpc.GenericResponse - 117, // 300: gctrpc.GoCryptoTraderService.GetHistoricCandles:output_type -> gctrpc.GetHistoricCandlesResponse - 132, // 301: gctrpc.GoCryptoTraderService.SetExchangeAsset:output_type -> gctrpc.GenericResponse - 132, // 302: gctrpc.GoCryptoTraderService.SetAllExchangePairs:output_type -> gctrpc.GenericResponse - 132, // 303: gctrpc.GoCryptoTraderService.UpdateExchangeSupportedPairs:output_type -> gctrpc.GenericResponse - 137, // 304: gctrpc.GoCryptoTraderService.GetExchangeAssets:output_type -> gctrpc.GetExchangeAssetsResponse - 139, // 305: gctrpc.GoCryptoTraderService.WebsocketGetInfo:output_type -> gctrpc.WebsocketGetInfoResponse - 132, // 306: gctrpc.GoCryptoTraderService.WebsocketSetEnabled:output_type -> gctrpc.GenericResponse - 143, // 307: gctrpc.GoCryptoTraderService.WebsocketGetSubscriptions:output_type -> gctrpc.WebsocketGetSubscriptionsResponse - 132, // 308: gctrpc.GoCryptoTraderService.WebsocketSetProxy:output_type -> gctrpc.GenericResponse - 132, // 309: gctrpc.GoCryptoTraderService.WebsocketSetURL:output_type -> gctrpc.GenericResponse - 114, // 310: gctrpc.GoCryptoTraderService.GetRecentTrades:output_type -> gctrpc.SavedTradesResponse - 114, // 311: gctrpc.GoCryptoTraderService.GetHistoricTrades:output_type -> gctrpc.SavedTradesResponse - 114, // 312: gctrpc.GoCryptoTraderService.GetSavedTrades:output_type -> gctrpc.SavedTradesResponse - 117, // 313: gctrpc.GoCryptoTraderService.ConvertTradesToCandles:output_type -> gctrpc.GetHistoricCandlesResponse - 148, // 314: gctrpc.GoCryptoTraderService.FindMissingSavedCandleIntervals:output_type -> gctrpc.FindMissingIntervalsResponse - 148, // 315: gctrpc.GoCryptoTraderService.FindMissingSavedTradeIntervals:output_type -> gctrpc.FindMissingIntervalsResponse - 132, // 316: gctrpc.GoCryptoTraderService.SetExchangeTradeProcessing:output_type -> gctrpc.GenericResponse - 153, // 317: gctrpc.GoCryptoTraderService.UpsertDataHistoryJob:output_type -> gctrpc.UpsertDataHistoryJobResponse - 155, // 318: gctrpc.GoCryptoTraderService.GetDataHistoryJobDetails:output_type -> gctrpc.DataHistoryJob - 157, // 319: gctrpc.GoCryptoTraderService.GetActiveDataHistoryJobs:output_type -> gctrpc.DataHistoryJobs - 157, // 320: gctrpc.GoCryptoTraderService.GetDataHistoryJobsBetween:output_type -> gctrpc.DataHistoryJobs - 155, // 321: gctrpc.GoCryptoTraderService.GetDataHistoryJobSummary:output_type -> gctrpc.DataHistoryJob - 132, // 322: gctrpc.GoCryptoTraderService.SetDataHistoryJobStatus:output_type -> gctrpc.GenericResponse - 132, // 323: gctrpc.GoCryptoTraderService.UpdateDataHistoryJobPrerequisite:output_type -> gctrpc.GenericResponse - 59, // 324: gctrpc.GoCryptoTraderService.GetManagedOrders:output_type -> gctrpc.GetOrdersResponse - 162, // 325: gctrpc.GoCryptoTraderService.ModifyOrder:output_type -> gctrpc.ModifyOrderResponse - 168, // 326: gctrpc.GoCryptoTraderService.CurrencyStateGetAll:output_type -> gctrpc.CurrencyStateResponse - 132, // 327: gctrpc.GoCryptoTraderService.CurrencyStateTrading:output_type -> gctrpc.GenericResponse - 132, // 328: gctrpc.GoCryptoTraderService.CurrencyStateDeposit:output_type -> gctrpc.GenericResponse - 132, // 329: gctrpc.GoCryptoTraderService.CurrencyStateWithdraw:output_type -> gctrpc.GenericResponse - 132, // 330: gctrpc.GoCryptoTraderService.CurrencyStateTradingPair:output_type -> gctrpc.GenericResponse - 178, // 331: gctrpc.GoCryptoTraderService.GetFuturesPositions:output_type -> gctrpc.GetFuturesPositionsResponse - 180, // 332: gctrpc.GoCryptoTraderService.GetCollateral:output_type -> gctrpc.GetCollateralResponse - 189, // 333: gctrpc.GoCryptoTraderService.Shutdown:output_type -> gctrpc.ShutdownResponse - 192, // 334: gctrpc.GoCryptoTraderService.GetTechnicalAnalysis:output_type -> gctrpc.GetTechnicalAnalysisResponse - 197, // 335: gctrpc.GoCryptoTraderService.GetMarginRatesHistory:output_type -> gctrpc.GetMarginRatesHistoryResponse - 176, // 336: gctrpc.GoCryptoTraderService.GetManagedPosition:output_type -> gctrpc.GetManagedPositionsResponse - 176, // 337: gctrpc.GoCryptoTraderService.GetAllManagedPositions:output_type -> gctrpc.GetManagedPositionsResponse - 185, // 338: gctrpc.GoCryptoTraderService.GetFundingRates:output_type -> gctrpc.GetFundingRatesResponse - 187, // 339: gctrpc.GoCryptoTraderService.GetLatestFundingRate:output_type -> gctrpc.GetLatestFundingRateResponse - 199, // 340: gctrpc.GoCryptoTraderService.GetOrderbookMovement:output_type -> gctrpc.GetOrderbookMovementResponse - 201, // 341: gctrpc.GoCryptoTraderService.GetOrderbookAmountByNominal:output_type -> gctrpc.GetOrderbookAmountByNominalResponse - 203, // 342: gctrpc.GoCryptoTraderService.GetOrderbookAmountByImpact:output_type -> gctrpc.GetOrderbookAmountByImpactResponse - 237, // [237:343] is the sub-list for method output_type - 131, // [131:237] is the sub-list for method input_type - 131, // [131:131] is the sub-list for extension type_name - 131, // [131:131] is the sub-list for extension extendee - 0, // [0:131] is the sub-list for field type_name + 21, // 97: gctrpc.GetFuturesPositionsSummaryRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 98: gctrpc.GetFuturesPositionsSummaryRequest.underlying_pair:type_name -> gctrpc.CurrencyPair + 21, // 99: gctrpc.GetFuturesPositionsSummaryResponse.pair:type_name -> gctrpc.CurrencyPair + 172, // 100: gctrpc.GetFuturesPositionsSummaryResponse.position_stats:type_name -> gctrpc.FuturesPositionStats + 21, // 101: gctrpc.GetFuturesPositionsOrdersRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 102: gctrpc.GetFuturesPositionsOrdersRequest.underlying_pair:type_name -> gctrpc.CurrencyPair + 173, // 103: gctrpc.GetFuturesPositionsOrdersResponse.positions:type_name -> gctrpc.FuturePosition + 21, // 104: gctrpc.GetMarginTypeRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 105: gctrpc.GetMarginTypeResponse.pair:type_name -> gctrpc.CurrencyPair + 21, // 106: gctrpc.ChangePositionMarginRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 107: gctrpc.ChangePositionMarginResponse.pair:type_name -> gctrpc.CurrencyPair + 21, // 108: gctrpc.SetMarginTypeRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 109: gctrpc.SetMarginTypeResponse.pair:type_name -> gctrpc.CurrencyPair + 21, // 110: gctrpc.GetLeverageRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 111: gctrpc.GetLeverageRequest.underlying_pair:type_name -> gctrpc.CurrencyPair + 21, // 112: gctrpc.GetLeverageResponse.pair:type_name -> gctrpc.CurrencyPair + 21, // 113: gctrpc.GetLeverageResponse.underlying_pair:type_name -> gctrpc.CurrencyPair + 21, // 114: gctrpc.SetLeverageRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 115: gctrpc.SetLeverageRequest.underlying_pair:type_name -> gctrpc.CurrencyPair + 21, // 116: gctrpc.SetLeverageResponse.pair:type_name -> gctrpc.CurrencyPair + 21, // 117: gctrpc.SetLeverageResponse.underlying_pair:type_name -> gctrpc.CurrencyPair + 199, // 118: gctrpc.GetCollateralResponse.used_breakdown:type_name -> gctrpc.CollateralUsedBreakdown + 197, // 119: gctrpc.GetCollateralResponse.currency_breakdown:type_name -> gctrpc.CollateralForCurrency + 198, // 120: gctrpc.GetCollateralResponse.position_breakdown:type_name -> gctrpc.CollateralByPosition + 199, // 121: gctrpc.CollateralForCurrency.used_breakdown:type_name -> gctrpc.CollateralUsedBreakdown + 21, // 122: gctrpc.GetFundingRatesRequest.pair:type_name -> gctrpc.CurrencyPair + 171, // 123: gctrpc.GetFundingRatesResponse.rates:type_name -> gctrpc.FundingData + 21, // 124: gctrpc.GetLatestFundingRateRequest.pair:type_name -> gctrpc.CurrencyPair + 171, // 125: gctrpc.GetLatestFundingRateResponse.rate:type_name -> gctrpc.FundingData + 21, // 126: gctrpc.GetTechnicalAnalysisRequest.pair:type_name -> gctrpc.CurrencyPair + 234, // 127: gctrpc.GetTechnicalAnalysisRequest.start:type_name -> google.protobuf.Timestamp + 234, // 128: gctrpc.GetTechnicalAnalysisRequest.end:type_name -> google.protobuf.Timestamp + 21, // 129: gctrpc.GetTechnicalAnalysisRequest.other_pair:type_name -> gctrpc.CurrencyPair + 233, // 130: gctrpc.GetTechnicalAnalysisResponse.signals:type_name -> gctrpc.GetTechnicalAnalysisResponse.SignalsEntry + 212, // 131: gctrpc.GetMarginRatesHistoryRequest.rates:type_name -> gctrpc.MarginRate + 210, // 132: gctrpc.MarginRate.lending_payment:type_name -> gctrpc.LendingPayment + 211, // 133: gctrpc.MarginRate.borrow_cost:type_name -> gctrpc.BorrowCost + 212, // 134: gctrpc.GetMarginRatesHistoryResponse.rates:type_name -> gctrpc.MarginRate + 212, // 135: gctrpc.GetMarginRatesHistoryResponse.latest_rate:type_name -> gctrpc.MarginRate + 212, // 136: gctrpc.GetMarginRatesHistoryResponse.predicted_rate:type_name -> gctrpc.MarginRate + 21, // 137: gctrpc.GetOrderbookMovementRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 138: gctrpc.GetOrderbookAmountByNominalRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 139: gctrpc.GetOrderbookAmountByImpactRequest.pair:type_name -> gctrpc.CurrencyPair + 9, // 140: gctrpc.GetInfoResponse.RpcEndpointsEntry.value:type_name -> gctrpc.RPCEndpoint + 3, // 141: gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry.value:type_name -> gctrpc.CommunicationRelayer + 9, // 142: gctrpc.GetRPCEndpointsResponse.EndpointsEntry.value:type_name -> gctrpc.RPCEndpoint + 18, // 143: gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry.value:type_name -> gctrpc.PairsSupported + 44, // 144: gctrpc.OnlineCoins.CoinsEntry.value:type_name -> gctrpc.OnlineCoinSummary + 45, // 145: gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry.value:type_name -> gctrpc.OfflineCoins + 46, // 146: gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry.value:type_name -> gctrpc.OnlineCoins + 81, // 147: gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry.value:type_name -> gctrpc.DepositAddresses + 18, // 148: gctrpc.GetExchangePairsResponse.SupportedAssetsEntry.value:type_name -> gctrpc.PairsSupported + 207, // 149: gctrpc.GetTechnicalAnalysisResponse.SignalsEntry.value:type_name -> gctrpc.ListOfSignals + 0, // 150: gctrpc.GoCryptoTraderService.GetInfo:input_type -> gctrpc.GetInfoRequest + 6, // 151: gctrpc.GoCryptoTraderService.GetSubsystems:input_type -> gctrpc.GetSubsystemsRequest + 5, // 152: gctrpc.GoCryptoTraderService.EnableSubsystem:input_type -> gctrpc.GenericSubsystemRequest + 5, // 153: gctrpc.GoCryptoTraderService.DisableSubsystem:input_type -> gctrpc.GenericSubsystemRequest + 8, // 154: gctrpc.GoCryptoTraderService.GetRPCEndpoints:input_type -> gctrpc.GetRPCEndpointsRequest + 2, // 155: gctrpc.GoCryptoTraderService.GetCommunicationRelayers:input_type -> gctrpc.GetCommunicationRelayersRequest + 12, // 156: gctrpc.GoCryptoTraderService.GetExchanges:input_type -> gctrpc.GetExchangesRequest + 11, // 157: gctrpc.GoCryptoTraderService.DisableExchange:input_type -> gctrpc.GenericExchangeNameRequest + 11, // 158: gctrpc.GoCryptoTraderService.GetExchangeInfo:input_type -> gctrpc.GenericExchangeNameRequest + 11, // 159: gctrpc.GoCryptoTraderService.GetExchangeOTPCode:input_type -> gctrpc.GenericExchangeNameRequest + 15, // 160: gctrpc.GoCryptoTraderService.GetExchangeOTPCodes:input_type -> gctrpc.GetExchangeOTPsRequest + 11, // 161: gctrpc.GoCryptoTraderService.EnableExchange:input_type -> gctrpc.GenericExchangeNameRequest + 20, // 162: gctrpc.GoCryptoTraderService.GetTicker:input_type -> gctrpc.GetTickerRequest + 23, // 163: gctrpc.GoCryptoTraderService.GetTickers:input_type -> gctrpc.GetTickersRequest + 26, // 164: gctrpc.GoCryptoTraderService.GetOrderbook:input_type -> gctrpc.GetOrderbookRequest + 29, // 165: gctrpc.GoCryptoTraderService.GetOrderbooks:input_type -> gctrpc.GetOrderbooksRequest + 32, // 166: gctrpc.GoCryptoTraderService.GetAccountInfo:input_type -> gctrpc.GetAccountInfoRequest + 32, // 167: gctrpc.GoCryptoTraderService.UpdateAccountInfo:input_type -> gctrpc.GetAccountInfoRequest + 32, // 168: gctrpc.GoCryptoTraderService.GetAccountInfoStream:input_type -> gctrpc.GetAccountInfoRequest + 36, // 169: gctrpc.GoCryptoTraderService.GetConfig:input_type -> gctrpc.GetConfigRequest + 39, // 170: gctrpc.GoCryptoTraderService.GetPortfolio:input_type -> gctrpc.GetPortfolioRequest + 41, // 171: gctrpc.GoCryptoTraderService.GetPortfolioSummary:input_type -> gctrpc.GetPortfolioSummaryRequest + 48, // 172: gctrpc.GoCryptoTraderService.AddPortfolioAddress:input_type -> gctrpc.AddPortfolioAddressRequest + 49, // 173: gctrpc.GoCryptoTraderService.RemovePortfolioAddress:input_type -> gctrpc.RemovePortfolioAddressRequest + 50, // 174: gctrpc.GoCryptoTraderService.GetForexProviders:input_type -> gctrpc.GetForexProvidersRequest + 53, // 175: gctrpc.GoCryptoTraderService.GetForexRates:input_type -> gctrpc.GetForexRatesRequest + 58, // 176: gctrpc.GoCryptoTraderService.GetOrders:input_type -> gctrpc.GetOrdersRequest + 60, // 177: gctrpc.GoCryptoTraderService.GetOrder:input_type -> gctrpc.GetOrderRequest + 61, // 178: gctrpc.GoCryptoTraderService.SubmitOrder:input_type -> gctrpc.SubmitOrderRequest + 64, // 179: gctrpc.GoCryptoTraderService.SimulateOrder:input_type -> gctrpc.SimulateOrderRequest + 66, // 180: gctrpc.GoCryptoTraderService.WhaleBomb:input_type -> gctrpc.WhaleBombRequest + 67, // 181: gctrpc.GoCryptoTraderService.CancelOrder:input_type -> gctrpc.CancelOrderRequest + 68, // 182: gctrpc.GoCryptoTraderService.CancelBatchOrders:input_type -> gctrpc.CancelBatchOrdersRequest + 71, // 183: gctrpc.GoCryptoTraderService.CancelAllOrders:input_type -> gctrpc.CancelAllOrdersRequest + 73, // 184: gctrpc.GoCryptoTraderService.GetEvents:input_type -> gctrpc.GetEventsRequest + 76, // 185: gctrpc.GoCryptoTraderService.AddEvent:input_type -> gctrpc.AddEventRequest + 78, // 186: gctrpc.GoCryptoTraderService.RemoveEvent:input_type -> gctrpc.RemoveEventRequest + 79, // 187: gctrpc.GoCryptoTraderService.GetCryptocurrencyDepositAddresses:input_type -> gctrpc.GetCryptocurrencyDepositAddressesRequest + 83, // 188: gctrpc.GoCryptoTraderService.GetCryptocurrencyDepositAddress:input_type -> gctrpc.GetCryptocurrencyDepositAddressRequest + 85, // 189: gctrpc.GoCryptoTraderService.GetAvailableTransferChains:input_type -> gctrpc.GetAvailableTransferChainsRequest + 87, // 190: gctrpc.GoCryptoTraderService.WithdrawFiatFunds:input_type -> gctrpc.WithdrawFiatRequest + 88, // 191: gctrpc.GoCryptoTraderService.WithdrawCryptocurrencyFunds:input_type -> gctrpc.WithdrawCryptoRequest + 90, // 192: gctrpc.GoCryptoTraderService.WithdrawalEventByID:input_type -> gctrpc.WithdrawalEventByIDRequest + 92, // 193: gctrpc.GoCryptoTraderService.WithdrawalEventsByExchange:input_type -> gctrpc.WithdrawalEventsByExchangeRequest + 93, // 194: gctrpc.GoCryptoTraderService.WithdrawalEventsByDate:input_type -> gctrpc.WithdrawalEventsByDateRequest + 100, // 195: gctrpc.GoCryptoTraderService.GetLoggerDetails:input_type -> gctrpc.GetLoggerDetailsRequest + 102, // 196: gctrpc.GoCryptoTraderService.SetLoggerDetails:input_type -> gctrpc.SetLoggerDetailsRequest + 103, // 197: gctrpc.GoCryptoTraderService.GetExchangePairs:input_type -> gctrpc.GetExchangePairsRequest + 105, // 198: gctrpc.GoCryptoTraderService.SetExchangePair:input_type -> gctrpc.SetExchangePairRequest + 106, // 199: gctrpc.GoCryptoTraderService.GetOrderbookStream:input_type -> gctrpc.GetOrderbookStreamRequest + 107, // 200: gctrpc.GoCryptoTraderService.GetExchangeOrderbookStream:input_type -> gctrpc.GetExchangeOrderbookStreamRequest + 108, // 201: gctrpc.GoCryptoTraderService.GetTickerStream:input_type -> gctrpc.GetTickerStreamRequest + 109, // 202: gctrpc.GoCryptoTraderService.GetExchangeTickerStream:input_type -> gctrpc.GetExchangeTickerStreamRequest + 110, // 203: gctrpc.GoCryptoTraderService.GetAuditEvent:input_type -> gctrpc.GetAuditEventRequest + 121, // 204: gctrpc.GoCryptoTraderService.GCTScriptExecute:input_type -> gctrpc.GCTScriptExecuteRequest + 126, // 205: gctrpc.GoCryptoTraderService.GCTScriptUpload:input_type -> gctrpc.GCTScriptUploadRequest + 127, // 206: gctrpc.GoCryptoTraderService.GCTScriptReadScript:input_type -> gctrpc.GCTScriptReadScriptRequest + 124, // 207: gctrpc.GoCryptoTraderService.GCTScriptStatus:input_type -> gctrpc.GCTScriptStatusRequest + 128, // 208: gctrpc.GoCryptoTraderService.GCTScriptQuery:input_type -> gctrpc.GCTScriptQueryRequest + 122, // 209: gctrpc.GoCryptoTraderService.GCTScriptStop:input_type -> gctrpc.GCTScriptStopRequest + 123, // 210: gctrpc.GoCryptoTraderService.GCTScriptStopAll:input_type -> gctrpc.GCTScriptStopAllRequest + 125, // 211: gctrpc.GoCryptoTraderService.GCTScriptListAll:input_type -> gctrpc.GCTScriptListAllRequest + 129, // 212: gctrpc.GoCryptoTraderService.GCTScriptAutoLoadToggle:input_type -> gctrpc.GCTScriptAutoLoadRequest + 116, // 213: gctrpc.GoCryptoTraderService.GetHistoricCandles:input_type -> gctrpc.GetHistoricCandlesRequest + 133, // 214: gctrpc.GoCryptoTraderService.SetExchangeAsset:input_type -> gctrpc.SetExchangeAssetRequest + 134, // 215: gctrpc.GoCryptoTraderService.SetAllExchangePairs:input_type -> gctrpc.SetExchangeAllPairsRequest + 135, // 216: gctrpc.GoCryptoTraderService.UpdateExchangeSupportedPairs:input_type -> gctrpc.UpdateExchangeSupportedPairsRequest + 136, // 217: gctrpc.GoCryptoTraderService.GetExchangeAssets:input_type -> gctrpc.GetExchangeAssetsRequest + 138, // 218: gctrpc.GoCryptoTraderService.WebsocketGetInfo:input_type -> gctrpc.WebsocketGetInfoRequest + 140, // 219: gctrpc.GoCryptoTraderService.WebsocketSetEnabled:input_type -> gctrpc.WebsocketSetEnabledRequest + 141, // 220: gctrpc.GoCryptoTraderService.WebsocketGetSubscriptions:input_type -> gctrpc.WebsocketGetSubscriptionsRequest + 144, // 221: gctrpc.GoCryptoTraderService.WebsocketSetProxy:input_type -> gctrpc.WebsocketSetProxyRequest + 145, // 222: gctrpc.GoCryptoTraderService.WebsocketSetURL:input_type -> gctrpc.WebsocketSetURLRequest + 112, // 223: gctrpc.GoCryptoTraderService.GetRecentTrades:input_type -> gctrpc.GetSavedTradesRequest + 112, // 224: gctrpc.GoCryptoTraderService.GetHistoricTrades:input_type -> gctrpc.GetSavedTradesRequest + 112, // 225: gctrpc.GoCryptoTraderService.GetSavedTrades:input_type -> gctrpc.GetSavedTradesRequest + 115, // 226: gctrpc.GoCryptoTraderService.ConvertTradesToCandles:input_type -> gctrpc.ConvertTradesToCandlesRequest + 146, // 227: gctrpc.GoCryptoTraderService.FindMissingSavedCandleIntervals:input_type -> gctrpc.FindMissingCandlePeriodsRequest + 147, // 228: gctrpc.GoCryptoTraderService.FindMissingSavedTradeIntervals:input_type -> gctrpc.FindMissingTradePeriodsRequest + 149, // 229: gctrpc.GoCryptoTraderService.SetExchangeTradeProcessing:input_type -> gctrpc.SetExchangeTradeProcessingRequest + 150, // 230: gctrpc.GoCryptoTraderService.UpsertDataHistoryJob:input_type -> gctrpc.UpsertDataHistoryJobRequest + 154, // 231: gctrpc.GoCryptoTraderService.GetDataHistoryJobDetails:input_type -> gctrpc.GetDataHistoryJobDetailsRequest + 0, // 232: gctrpc.GoCryptoTraderService.GetActiveDataHistoryJobs:input_type -> gctrpc.GetInfoRequest + 158, // 233: gctrpc.GoCryptoTraderService.GetDataHistoryJobsBetween:input_type -> gctrpc.GetDataHistoryJobsBetweenRequest + 154, // 234: gctrpc.GoCryptoTraderService.GetDataHistoryJobSummary:input_type -> gctrpc.GetDataHistoryJobDetailsRequest + 159, // 235: gctrpc.GoCryptoTraderService.SetDataHistoryJobStatus:input_type -> gctrpc.SetDataHistoryJobStatusRequest + 160, // 236: gctrpc.GoCryptoTraderService.UpdateDataHistoryJobPrerequisite:input_type -> gctrpc.UpdateDataHistoryJobPrerequisiteRequest + 58, // 237: gctrpc.GoCryptoTraderService.GetManagedOrders:input_type -> gctrpc.GetOrdersRequest + 161, // 238: gctrpc.GoCryptoTraderService.ModifyOrder:input_type -> gctrpc.ModifyOrderRequest + 163, // 239: gctrpc.GoCryptoTraderService.CurrencyStateGetAll:input_type -> gctrpc.CurrencyStateGetAllRequest + 164, // 240: gctrpc.GoCryptoTraderService.CurrencyStateTrading:input_type -> gctrpc.CurrencyStateTradingRequest + 167, // 241: gctrpc.GoCryptoTraderService.CurrencyStateDeposit:input_type -> gctrpc.CurrencyStateDepositRequest + 166, // 242: gctrpc.GoCryptoTraderService.CurrencyStateWithdraw:input_type -> gctrpc.CurrencyStateWithdrawRequest + 165, // 243: gctrpc.GoCryptoTraderService.CurrencyStateTradingPair:input_type -> gctrpc.CurrencyStateTradingPairRequest + 177, // 244: gctrpc.GoCryptoTraderService.GetFuturesPositionsSummary:input_type -> gctrpc.GetFuturesPositionsSummaryRequest + 179, // 245: gctrpc.GoCryptoTraderService.GetFuturesPositionsOrders:input_type -> gctrpc.GetFuturesPositionsOrdersRequest + 195, // 246: gctrpc.GoCryptoTraderService.GetCollateral:input_type -> gctrpc.GetCollateralRequest + 204, // 247: gctrpc.GoCryptoTraderService.Shutdown:input_type -> gctrpc.ShutdownRequest + 206, // 248: gctrpc.GoCryptoTraderService.GetTechnicalAnalysis:input_type -> gctrpc.GetTechnicalAnalysisRequest + 209, // 249: gctrpc.GoCryptoTraderService.GetMarginRatesHistory:input_type -> gctrpc.GetMarginRatesHistoryRequest + 174, // 250: gctrpc.GoCryptoTraderService.GetManagedPosition:input_type -> gctrpc.GetManagedPositionRequest + 175, // 251: gctrpc.GoCryptoTraderService.GetAllManagedPositions:input_type -> gctrpc.GetAllManagedPositionsRequest + 200, // 252: gctrpc.GoCryptoTraderService.GetFundingRates:input_type -> gctrpc.GetFundingRatesRequest + 202, // 253: gctrpc.GoCryptoTraderService.GetLatestFundingRate:input_type -> gctrpc.GetLatestFundingRateRequest + 214, // 254: gctrpc.GoCryptoTraderService.GetOrderbookMovement:input_type -> gctrpc.GetOrderbookMovementRequest + 216, // 255: gctrpc.GoCryptoTraderService.GetOrderbookAmountByNominal:input_type -> gctrpc.GetOrderbookAmountByNominalRequest + 218, // 256: gctrpc.GoCryptoTraderService.GetOrderbookAmountByImpact:input_type -> gctrpc.GetOrderbookAmountByImpactRequest + 181, // 257: gctrpc.GoCryptoTraderService.GetCollateralMode:input_type -> gctrpc.GetCollateralModeRequest + 191, // 258: gctrpc.GoCryptoTraderService.GetLeverage:input_type -> gctrpc.GetLeverageRequest + 183, // 259: gctrpc.GoCryptoTraderService.SetCollateralMode:input_type -> gctrpc.SetCollateralModeRequest + 189, // 260: gctrpc.GoCryptoTraderService.SetMarginType:input_type -> gctrpc.SetMarginTypeRequest + 193, // 261: gctrpc.GoCryptoTraderService.SetLeverage:input_type -> gctrpc.SetLeverageRequest + 187, // 262: gctrpc.GoCryptoTraderService.ChangePositionMargin:input_type -> gctrpc.ChangePositionMarginRequest + 1, // 263: gctrpc.GoCryptoTraderService.GetInfo:output_type -> gctrpc.GetInfoResponse + 7, // 264: gctrpc.GoCryptoTraderService.GetSubsystems:output_type -> gctrpc.GetSusbsytemsResponse + 132, // 265: gctrpc.GoCryptoTraderService.EnableSubsystem:output_type -> gctrpc.GenericResponse + 132, // 266: gctrpc.GoCryptoTraderService.DisableSubsystem:output_type -> gctrpc.GenericResponse + 10, // 267: gctrpc.GoCryptoTraderService.GetRPCEndpoints:output_type -> gctrpc.GetRPCEndpointsResponse + 4, // 268: gctrpc.GoCryptoTraderService.GetCommunicationRelayers:output_type -> gctrpc.GetCommunicationRelayersResponse + 13, // 269: gctrpc.GoCryptoTraderService.GetExchanges:output_type -> gctrpc.GetExchangesResponse + 132, // 270: gctrpc.GoCryptoTraderService.DisableExchange:output_type -> gctrpc.GenericResponse + 19, // 271: gctrpc.GoCryptoTraderService.GetExchangeInfo:output_type -> gctrpc.GetExchangeInfoResponse + 14, // 272: gctrpc.GoCryptoTraderService.GetExchangeOTPCode:output_type -> gctrpc.GetExchangeOTPResponse + 16, // 273: gctrpc.GoCryptoTraderService.GetExchangeOTPCodes:output_type -> gctrpc.GetExchangeOTPsResponse + 132, // 274: gctrpc.GoCryptoTraderService.EnableExchange:output_type -> gctrpc.GenericResponse + 22, // 275: gctrpc.GoCryptoTraderService.GetTicker:output_type -> gctrpc.TickerResponse + 25, // 276: gctrpc.GoCryptoTraderService.GetTickers:output_type -> gctrpc.GetTickersResponse + 28, // 277: gctrpc.GoCryptoTraderService.GetOrderbook:output_type -> gctrpc.OrderbookResponse + 31, // 278: gctrpc.GoCryptoTraderService.GetOrderbooks:output_type -> gctrpc.GetOrderbooksResponse + 35, // 279: gctrpc.GoCryptoTraderService.GetAccountInfo:output_type -> gctrpc.GetAccountInfoResponse + 35, // 280: gctrpc.GoCryptoTraderService.UpdateAccountInfo:output_type -> gctrpc.GetAccountInfoResponse + 35, // 281: gctrpc.GoCryptoTraderService.GetAccountInfoStream:output_type -> gctrpc.GetAccountInfoResponse + 37, // 282: gctrpc.GoCryptoTraderService.GetConfig:output_type -> gctrpc.GetConfigResponse + 40, // 283: gctrpc.GoCryptoTraderService.GetPortfolio:output_type -> gctrpc.GetPortfolioResponse + 47, // 284: gctrpc.GoCryptoTraderService.GetPortfolioSummary:output_type -> gctrpc.GetPortfolioSummaryResponse + 132, // 285: gctrpc.GoCryptoTraderService.AddPortfolioAddress:output_type -> gctrpc.GenericResponse + 132, // 286: gctrpc.GoCryptoTraderService.RemovePortfolioAddress:output_type -> gctrpc.GenericResponse + 52, // 287: gctrpc.GoCryptoTraderService.GetForexProviders:output_type -> gctrpc.GetForexProvidersResponse + 55, // 288: gctrpc.GoCryptoTraderService.GetForexRates:output_type -> gctrpc.GetForexRatesResponse + 59, // 289: gctrpc.GoCryptoTraderService.GetOrders:output_type -> gctrpc.GetOrdersResponse + 56, // 290: gctrpc.GoCryptoTraderService.GetOrder:output_type -> gctrpc.OrderDetails + 63, // 291: gctrpc.GoCryptoTraderService.SubmitOrder:output_type -> gctrpc.SubmitOrderResponse + 65, // 292: gctrpc.GoCryptoTraderService.SimulateOrder:output_type -> gctrpc.SimulateOrderResponse + 65, // 293: gctrpc.GoCryptoTraderService.WhaleBomb:output_type -> gctrpc.SimulateOrderResponse + 132, // 294: gctrpc.GoCryptoTraderService.CancelOrder:output_type -> gctrpc.GenericResponse + 70, // 295: gctrpc.GoCryptoTraderService.CancelBatchOrders:output_type -> gctrpc.CancelBatchOrdersResponse + 72, // 296: gctrpc.GoCryptoTraderService.CancelAllOrders:output_type -> gctrpc.CancelAllOrdersResponse + 75, // 297: gctrpc.GoCryptoTraderService.GetEvents:output_type -> gctrpc.GetEventsResponse + 77, // 298: gctrpc.GoCryptoTraderService.AddEvent:output_type -> gctrpc.AddEventResponse + 132, // 299: gctrpc.GoCryptoTraderService.RemoveEvent:output_type -> gctrpc.GenericResponse + 82, // 300: gctrpc.GoCryptoTraderService.GetCryptocurrencyDepositAddresses:output_type -> gctrpc.GetCryptocurrencyDepositAddressesResponse + 84, // 301: gctrpc.GoCryptoTraderService.GetCryptocurrencyDepositAddress:output_type -> gctrpc.GetCryptocurrencyDepositAddressResponse + 86, // 302: gctrpc.GoCryptoTraderService.GetAvailableTransferChains:output_type -> gctrpc.GetAvailableTransferChainsResponse + 89, // 303: gctrpc.GoCryptoTraderService.WithdrawFiatFunds:output_type -> gctrpc.WithdrawResponse + 89, // 304: gctrpc.GoCryptoTraderService.WithdrawCryptocurrencyFunds:output_type -> gctrpc.WithdrawResponse + 91, // 305: gctrpc.GoCryptoTraderService.WithdrawalEventByID:output_type -> gctrpc.WithdrawalEventByIDResponse + 94, // 306: gctrpc.GoCryptoTraderService.WithdrawalEventsByExchange:output_type -> gctrpc.WithdrawalEventsByExchangeResponse + 94, // 307: gctrpc.GoCryptoTraderService.WithdrawalEventsByDate:output_type -> gctrpc.WithdrawalEventsByExchangeResponse + 101, // 308: gctrpc.GoCryptoTraderService.GetLoggerDetails:output_type -> gctrpc.GetLoggerDetailsResponse + 101, // 309: gctrpc.GoCryptoTraderService.SetLoggerDetails:output_type -> gctrpc.GetLoggerDetailsResponse + 104, // 310: gctrpc.GoCryptoTraderService.GetExchangePairs:output_type -> gctrpc.GetExchangePairsResponse + 132, // 311: gctrpc.GoCryptoTraderService.SetExchangePair:output_type -> gctrpc.GenericResponse + 28, // 312: gctrpc.GoCryptoTraderService.GetOrderbookStream:output_type -> gctrpc.OrderbookResponse + 28, // 313: gctrpc.GoCryptoTraderService.GetExchangeOrderbookStream:output_type -> gctrpc.OrderbookResponse + 22, // 314: gctrpc.GoCryptoTraderService.GetTickerStream:output_type -> gctrpc.TickerResponse + 22, // 315: gctrpc.GoCryptoTraderService.GetExchangeTickerStream:output_type -> gctrpc.TickerResponse + 111, // 316: gctrpc.GoCryptoTraderService.GetAuditEvent:output_type -> gctrpc.GetAuditEventResponse + 132, // 317: gctrpc.GoCryptoTraderService.GCTScriptExecute:output_type -> gctrpc.GenericResponse + 132, // 318: gctrpc.GoCryptoTraderService.GCTScriptUpload:output_type -> gctrpc.GenericResponse + 131, // 319: gctrpc.GoCryptoTraderService.GCTScriptReadScript:output_type -> gctrpc.GCTScriptQueryResponse + 130, // 320: gctrpc.GoCryptoTraderService.GCTScriptStatus:output_type -> gctrpc.GCTScriptStatusResponse + 131, // 321: gctrpc.GoCryptoTraderService.GCTScriptQuery:output_type -> gctrpc.GCTScriptQueryResponse + 132, // 322: gctrpc.GoCryptoTraderService.GCTScriptStop:output_type -> gctrpc.GenericResponse + 132, // 323: gctrpc.GoCryptoTraderService.GCTScriptStopAll:output_type -> gctrpc.GenericResponse + 130, // 324: gctrpc.GoCryptoTraderService.GCTScriptListAll:output_type -> gctrpc.GCTScriptStatusResponse + 132, // 325: gctrpc.GoCryptoTraderService.GCTScriptAutoLoadToggle:output_type -> gctrpc.GenericResponse + 117, // 326: gctrpc.GoCryptoTraderService.GetHistoricCandles:output_type -> gctrpc.GetHistoricCandlesResponse + 132, // 327: gctrpc.GoCryptoTraderService.SetExchangeAsset:output_type -> gctrpc.GenericResponse + 132, // 328: gctrpc.GoCryptoTraderService.SetAllExchangePairs:output_type -> gctrpc.GenericResponse + 132, // 329: gctrpc.GoCryptoTraderService.UpdateExchangeSupportedPairs:output_type -> gctrpc.GenericResponse + 137, // 330: gctrpc.GoCryptoTraderService.GetExchangeAssets:output_type -> gctrpc.GetExchangeAssetsResponse + 139, // 331: gctrpc.GoCryptoTraderService.WebsocketGetInfo:output_type -> gctrpc.WebsocketGetInfoResponse + 132, // 332: gctrpc.GoCryptoTraderService.WebsocketSetEnabled:output_type -> gctrpc.GenericResponse + 143, // 333: gctrpc.GoCryptoTraderService.WebsocketGetSubscriptions:output_type -> gctrpc.WebsocketGetSubscriptionsResponse + 132, // 334: gctrpc.GoCryptoTraderService.WebsocketSetProxy:output_type -> gctrpc.GenericResponse + 132, // 335: gctrpc.GoCryptoTraderService.WebsocketSetURL:output_type -> gctrpc.GenericResponse + 114, // 336: gctrpc.GoCryptoTraderService.GetRecentTrades:output_type -> gctrpc.SavedTradesResponse + 114, // 337: gctrpc.GoCryptoTraderService.GetHistoricTrades:output_type -> gctrpc.SavedTradesResponse + 114, // 338: gctrpc.GoCryptoTraderService.GetSavedTrades:output_type -> gctrpc.SavedTradesResponse + 117, // 339: gctrpc.GoCryptoTraderService.ConvertTradesToCandles:output_type -> gctrpc.GetHistoricCandlesResponse + 148, // 340: gctrpc.GoCryptoTraderService.FindMissingSavedCandleIntervals:output_type -> gctrpc.FindMissingIntervalsResponse + 148, // 341: gctrpc.GoCryptoTraderService.FindMissingSavedTradeIntervals:output_type -> gctrpc.FindMissingIntervalsResponse + 132, // 342: gctrpc.GoCryptoTraderService.SetExchangeTradeProcessing:output_type -> gctrpc.GenericResponse + 153, // 343: gctrpc.GoCryptoTraderService.UpsertDataHistoryJob:output_type -> gctrpc.UpsertDataHistoryJobResponse + 155, // 344: gctrpc.GoCryptoTraderService.GetDataHistoryJobDetails:output_type -> gctrpc.DataHistoryJob + 157, // 345: gctrpc.GoCryptoTraderService.GetActiveDataHistoryJobs:output_type -> gctrpc.DataHistoryJobs + 157, // 346: gctrpc.GoCryptoTraderService.GetDataHistoryJobsBetween:output_type -> gctrpc.DataHistoryJobs + 155, // 347: gctrpc.GoCryptoTraderService.GetDataHistoryJobSummary:output_type -> gctrpc.DataHistoryJob + 132, // 348: gctrpc.GoCryptoTraderService.SetDataHistoryJobStatus:output_type -> gctrpc.GenericResponse + 132, // 349: gctrpc.GoCryptoTraderService.UpdateDataHistoryJobPrerequisite:output_type -> gctrpc.GenericResponse + 59, // 350: gctrpc.GoCryptoTraderService.GetManagedOrders:output_type -> gctrpc.GetOrdersResponse + 162, // 351: gctrpc.GoCryptoTraderService.ModifyOrder:output_type -> gctrpc.ModifyOrderResponse + 168, // 352: gctrpc.GoCryptoTraderService.CurrencyStateGetAll:output_type -> gctrpc.CurrencyStateResponse + 132, // 353: gctrpc.GoCryptoTraderService.CurrencyStateTrading:output_type -> gctrpc.GenericResponse + 132, // 354: gctrpc.GoCryptoTraderService.CurrencyStateDeposit:output_type -> gctrpc.GenericResponse + 132, // 355: gctrpc.GoCryptoTraderService.CurrencyStateWithdraw:output_type -> gctrpc.GenericResponse + 132, // 356: gctrpc.GoCryptoTraderService.CurrencyStateTradingPair:output_type -> gctrpc.GenericResponse + 178, // 357: gctrpc.GoCryptoTraderService.GetFuturesPositionsSummary:output_type -> gctrpc.GetFuturesPositionsSummaryResponse + 180, // 358: gctrpc.GoCryptoTraderService.GetFuturesPositionsOrders:output_type -> gctrpc.GetFuturesPositionsOrdersResponse + 196, // 359: gctrpc.GoCryptoTraderService.GetCollateral:output_type -> gctrpc.GetCollateralResponse + 205, // 360: gctrpc.GoCryptoTraderService.Shutdown:output_type -> gctrpc.ShutdownResponse + 208, // 361: gctrpc.GoCryptoTraderService.GetTechnicalAnalysis:output_type -> gctrpc.GetTechnicalAnalysisResponse + 213, // 362: gctrpc.GoCryptoTraderService.GetMarginRatesHistory:output_type -> gctrpc.GetMarginRatesHistoryResponse + 176, // 363: gctrpc.GoCryptoTraderService.GetManagedPosition:output_type -> gctrpc.GetManagedPositionsResponse + 176, // 364: gctrpc.GoCryptoTraderService.GetAllManagedPositions:output_type -> gctrpc.GetManagedPositionsResponse + 201, // 365: gctrpc.GoCryptoTraderService.GetFundingRates:output_type -> gctrpc.GetFundingRatesResponse + 203, // 366: gctrpc.GoCryptoTraderService.GetLatestFundingRate:output_type -> gctrpc.GetLatestFundingRateResponse + 215, // 367: gctrpc.GoCryptoTraderService.GetOrderbookMovement:output_type -> gctrpc.GetOrderbookMovementResponse + 217, // 368: gctrpc.GoCryptoTraderService.GetOrderbookAmountByNominal:output_type -> gctrpc.GetOrderbookAmountByNominalResponse + 219, // 369: gctrpc.GoCryptoTraderService.GetOrderbookAmountByImpact:output_type -> gctrpc.GetOrderbookAmountByImpactResponse + 182, // 370: gctrpc.GoCryptoTraderService.GetCollateralMode:output_type -> gctrpc.GetCollateralModeResponse + 192, // 371: gctrpc.GoCryptoTraderService.GetLeverage:output_type -> gctrpc.GetLeverageResponse + 184, // 372: gctrpc.GoCryptoTraderService.SetCollateralMode:output_type -> gctrpc.SetCollateralModeResponse + 190, // 373: gctrpc.GoCryptoTraderService.SetMarginType:output_type -> gctrpc.SetMarginTypeResponse + 194, // 374: gctrpc.GoCryptoTraderService.SetLeverage:output_type -> gctrpc.SetLeverageResponse + 188, // 375: gctrpc.GoCryptoTraderService.ChangePositionMargin:output_type -> gctrpc.ChangePositionMarginResponse + 263, // [263:376] is the sub-list for method output_type + 150, // [150:263] is the sub-list for method input_type + 150, // [150:150] is the sub-list for extension type_name + 150, // [150:150] is the sub-list for extension extendee + 0, // [0:150] is the sub-list for field type_name } func init() { file_rpc_proto_init() } @@ -19784,7 +21333,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[177].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetFuturesPositionsRequest); i { + switch v := v.(*GetFuturesPositionsSummaryRequest); i { case 0: return &v.state case 1: @@ -19796,7 +21345,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[178].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetFuturesPositionsResponse); i { + switch v := v.(*GetFuturesPositionsSummaryResponse); i { case 0: return &v.state case 1: @@ -19808,7 +21357,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[179].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetCollateralRequest); i { + switch v := v.(*GetFuturesPositionsOrdersRequest); i { case 0: return &v.state case 1: @@ -19820,7 +21369,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[180].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetCollateralResponse); i { + switch v := v.(*GetFuturesPositionsOrdersResponse); i { case 0: return &v.state case 1: @@ -19832,7 +21381,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[181].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CollateralForCurrency); i { + switch v := v.(*GetCollateralModeRequest); i { case 0: return &v.state case 1: @@ -19844,7 +21393,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[182].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CollateralByPosition); i { + switch v := v.(*GetCollateralModeResponse); i { case 0: return &v.state case 1: @@ -19856,7 +21405,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[183].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CollateralUsedBreakdown); i { + switch v := v.(*SetCollateralModeRequest); i { case 0: return &v.state case 1: @@ -19868,7 +21417,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[184].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetFundingRatesRequest); i { + switch v := v.(*SetCollateralModeResponse); i { case 0: return &v.state case 1: @@ -19880,7 +21429,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[185].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetFundingRatesResponse); i { + switch v := v.(*GetMarginTypeRequest); i { case 0: return &v.state case 1: @@ -19892,7 +21441,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[186].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetLatestFundingRateRequest); i { + switch v := v.(*GetMarginTypeResponse); i { case 0: return &v.state case 1: @@ -19904,7 +21453,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[187].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetLatestFundingRateResponse); i { + switch v := v.(*ChangePositionMarginRequest); i { case 0: return &v.state case 1: @@ -19916,7 +21465,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[188].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ShutdownRequest); i { + switch v := v.(*ChangePositionMarginResponse); i { case 0: return &v.state case 1: @@ -19928,7 +21477,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[189].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ShutdownResponse); i { + switch v := v.(*SetMarginTypeRequest); i { case 0: return &v.state case 1: @@ -19940,7 +21489,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[190].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetTechnicalAnalysisRequest); i { + switch v := v.(*SetMarginTypeResponse); i { case 0: return &v.state case 1: @@ -19952,7 +21501,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[191].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListOfSignals); i { + switch v := v.(*GetLeverageRequest); i { case 0: return &v.state case 1: @@ -19964,7 +21513,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[192].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetTechnicalAnalysisResponse); i { + switch v := v.(*GetLeverageResponse); i { case 0: return &v.state case 1: @@ -19976,7 +21525,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[193].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetMarginRatesHistoryRequest); i { + switch v := v.(*SetLeverageRequest); i { case 0: return &v.state case 1: @@ -19988,7 +21537,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[194].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*LendingPayment); i { + switch v := v.(*SetLeverageResponse); i { case 0: return &v.state case 1: @@ -20000,7 +21549,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[195].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BorrowCost); i { + switch v := v.(*GetCollateralRequest); i { case 0: return &v.state case 1: @@ -20012,7 +21561,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[196].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*MarginRate); i { + switch v := v.(*GetCollateralResponse); i { case 0: return &v.state case 1: @@ -20024,7 +21573,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[197].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetMarginRatesHistoryResponse); i { + switch v := v.(*CollateralForCurrency); i { case 0: return &v.state case 1: @@ -20036,7 +21585,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[198].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetOrderbookMovementRequest); i { + switch v := v.(*CollateralByPosition); i { case 0: return &v.state case 1: @@ -20048,7 +21597,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[199].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetOrderbookMovementResponse); i { + switch v := v.(*CollateralUsedBreakdown); i { case 0: return &v.state case 1: @@ -20060,7 +21609,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[200].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetOrderbookAmountByNominalRequest); i { + switch v := v.(*GetFundingRatesRequest); i { case 0: return &v.state case 1: @@ -20072,7 +21621,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[201].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetOrderbookAmountByNominalResponse); i { + switch v := v.(*GetFundingRatesResponse); i { case 0: return &v.state case 1: @@ -20084,7 +21633,7 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[202].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetOrderbookAmountByImpactRequest); i { + switch v := v.(*GetLatestFundingRateRequest); i { case 0: return &v.state case 1: @@ -20096,6 +21645,198 @@ func file_rpc_proto_init() { } } file_rpc_proto_msgTypes[203].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetLatestFundingRateResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[204].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ShutdownRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[205].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ShutdownResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[206].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTechnicalAnalysisRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[207].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListOfSignals); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[208].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTechnicalAnalysisResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[209].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetMarginRatesHistoryRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[210].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LendingPayment); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[211].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BorrowCost); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[212].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MarginRate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[213].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetMarginRatesHistoryResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[214].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbookMovementRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[215].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbookMovementResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[216].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbookAmountByNominalRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[217].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbookAmountByNominalResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[218].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbookAmountByImpactRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[219].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetOrderbookAmountByImpactResponse); i { case 0: return &v.state @@ -20114,7 +21855,7 @@ func file_rpc_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_rpc_proto_rawDesc, NumEnums: 0, - NumMessages: 218, + NumMessages: 234, NumExtensions: 0, NumServices: 1, }, diff --git a/gctrpc/rpc.pb.gw.go b/gctrpc/rpc.pb.gw.go index 1fc7e6cf542..3913bf6b082 100644 --- a/gctrpc/rpc.pb.gw.go +++ b/gctrpc/rpc.pb.gw.go @@ -3024,37 +3024,73 @@ func local_request_GoCryptoTraderService_CurrencyStateTradingPair_0(ctx context. } var ( - filter_GoCryptoTraderService_GetFuturesPositions_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + filter_GoCryptoTraderService_GetFuturesPositionsSummary_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) -func request_GoCryptoTraderService_GetFuturesPositions_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq GetFuturesPositionsRequest +func request_GoCryptoTraderService_GetFuturesPositionsSummary_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GetFuturesPositionsSummaryRequest var metadata runtime.ServerMetadata if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetFuturesPositions_0); err != nil { + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetFuturesPositionsSummary_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.GetFuturesPositions(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.GetFuturesPositionsSummary(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_GoCryptoTraderService_GetFuturesPositions_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq GetFuturesPositionsRequest +func local_request_GoCryptoTraderService_GetFuturesPositionsSummary_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GetFuturesPositionsSummaryRequest var metadata runtime.ServerMetadata if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetFuturesPositions_0); err != nil { + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetFuturesPositionsSummary_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.GetFuturesPositions(ctx, &protoReq) + msg, err := server.GetFuturesPositionsSummary(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_GoCryptoTraderService_GetFuturesPositionsOrders_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_GoCryptoTraderService_GetFuturesPositionsOrders_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GetFuturesPositionsOrdersRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetFuturesPositionsOrders_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.GetFuturesPositionsOrders(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GoCryptoTraderService_GetFuturesPositionsOrders_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GetFuturesPositionsOrdersRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetFuturesPositionsOrders_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.GetFuturesPositionsOrders(ctx, &protoReq) return msg, metadata, err } @@ -3437,6 +3473,214 @@ func local_request_GoCryptoTraderService_GetOrderbookAmountByImpact_0(ctx contex } +var ( + filter_GoCryptoTraderService_GetCollateralMode_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_GoCryptoTraderService_GetCollateralMode_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GetCollateralModeRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetCollateralMode_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.GetCollateralMode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GoCryptoTraderService_GetCollateralMode_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GetCollateralModeRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetCollateralMode_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.GetCollateralMode(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_GoCryptoTraderService_GetLeverage_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_GoCryptoTraderService_GetLeverage_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GetLeverageRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetLeverage_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.GetLeverage(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GoCryptoTraderService_GetLeverage_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq GetLeverageRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTraderService_GetLeverage_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.GetLeverage(ctx, &protoReq) + return msg, metadata, err + +} + +func request_GoCryptoTraderService_SetCollateralMode_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SetCollateralModeRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.SetCollateralMode(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GoCryptoTraderService_SetCollateralMode_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SetCollateralModeRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.SetCollateralMode(ctx, &protoReq) + return msg, metadata, err + +} + +func request_GoCryptoTraderService_SetMarginType_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SetMarginTypeRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.SetMarginType(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GoCryptoTraderService_SetMarginType_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SetMarginTypeRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.SetMarginType(ctx, &protoReq) + return msg, metadata, err + +} + +func request_GoCryptoTraderService_SetLeverage_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SetLeverageRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.SetLeverage(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GoCryptoTraderService_SetLeverage_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SetLeverageRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.SetLeverage(ctx, &protoReq) + return msg, metadata, err + +} + +func request_GoCryptoTraderService_ChangePositionMargin_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ChangePositionMarginRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ChangePositionMargin(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GoCryptoTraderService_ChangePositionMargin_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ChangePositionMarginRequest + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ChangePositionMargin(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterGoCryptoTraderServiceHandlerServer registers the http handlers for service GoCryptoTraderService to "mux". // UnaryRPC :call GoCryptoTraderServiceServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -5685,7 +5929,32 @@ func RegisterGoCryptoTraderServiceHandlerServer(ctx context.Context, mux *runtim }) - mux.Handle("GET", pattern_GoCryptoTraderService_GetFuturesPositions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_GoCryptoTraderService_GetFuturesPositionsSummary_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetFuturesPositionsSummary", runtime.WithHTTPPathPattern("/v1/getfuturespositionssummary")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_GoCryptoTraderService_GetFuturesPositionsSummary_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_GetFuturesPositionsSummary_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_GoCryptoTraderService_GetFuturesPositionsOrders_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -5693,12 +5962,12 @@ func RegisterGoCryptoTraderServiceHandlerServer(ctx context.Context, mux *runtim inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) var err error var annotatedContext context.Context - annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetFuturesPositions", runtime.WithHTTPPathPattern("/v1/getfuturespositions")) + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetFuturesPositionsOrders", runtime.WithHTTPPathPattern("/v1/getfuturespositionsorders")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_GoCryptoTraderService_GetFuturesPositions_0(annotatedContext, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_GoCryptoTraderService_GetFuturesPositionsOrders_0(annotatedContext, inboundMarshaler, server, req, pathParams) md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) if err != nil { @@ -5706,7 +5975,7 @@ func RegisterGoCryptoTraderServiceHandlerServer(ctx context.Context, mux *runtim return } - forward_GoCryptoTraderService_GetFuturesPositions_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_GoCryptoTraderService_GetFuturesPositionsOrders_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -5985,6 +6254,156 @@ func RegisterGoCryptoTraderServiceHandlerServer(ctx context.Context, mux *runtim }) + mux.Handle("GET", pattern_GoCryptoTraderService_GetCollateralMode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetCollateralMode", runtime.WithHTTPPathPattern("/v1/getcollateralmode")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_GoCryptoTraderService_GetCollateralMode_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_GetCollateralMode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_GoCryptoTraderService_GetLeverage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetLeverage", runtime.WithHTTPPathPattern("/v1/getleverage")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_GoCryptoTraderService_GetLeverage_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_GetLeverage_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GoCryptoTraderService_SetCollateralMode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/SetCollateralMode", runtime.WithHTTPPathPattern("/v1/getcollateralmode")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_GoCryptoTraderService_SetCollateralMode_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_SetCollateralMode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GoCryptoTraderService_SetMarginType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/SetMarginType", runtime.WithHTTPPathPattern("/v1/getmargintype")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_GoCryptoTraderService_SetMarginType_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_SetMarginType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GoCryptoTraderService_SetLeverage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/SetLeverage", runtime.WithHTTPPathPattern("/v1/getleverage")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_GoCryptoTraderService_SetLeverage_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_SetLeverage_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GoCryptoTraderService_ChangePositionMargin_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/ChangePositionMargin", runtime.WithHTTPPathPattern("/v1/changepositionmargin")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_GoCryptoTraderService_ChangePositionMargin_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_ChangePositionMargin_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -8094,25 +8513,47 @@ func RegisterGoCryptoTraderServiceHandlerClient(ctx context.Context, mux *runtim }) - mux.Handle("GET", pattern_GoCryptoTraderService_GetFuturesPositions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_GoCryptoTraderService_GetFuturesPositionsSummary_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetFuturesPositionsSummary", runtime.WithHTTPPathPattern("/v1/getfuturespositionssummary")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_GoCryptoTraderService_GetFuturesPositionsSummary_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_GetFuturesPositionsSummary_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_GoCryptoTraderService_GetFuturesPositionsOrders_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) var err error var annotatedContext context.Context - annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetFuturesPositions", runtime.WithHTTPPathPattern("/v1/getfuturespositions")) + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetFuturesPositionsOrders", runtime.WithHTTPPathPattern("/v1/getfuturespositionsorders")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_GoCryptoTraderService_GetFuturesPositions_0(annotatedContext, inboundMarshaler, client, req, pathParams) + resp, md, err := request_GoCryptoTraderService_GetFuturesPositionsOrders_0(annotatedContext, inboundMarshaler, client, req, pathParams) annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) if err != nil { runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_GoCryptoTraderService_GetFuturesPositions_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_GoCryptoTraderService_GetFuturesPositionsOrders_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -8358,6 +8799,138 @@ func RegisterGoCryptoTraderServiceHandlerClient(ctx context.Context, mux *runtim }) + mux.Handle("GET", pattern_GoCryptoTraderService_GetCollateralMode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetCollateralMode", runtime.WithHTTPPathPattern("/v1/getcollateralmode")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_GoCryptoTraderService_GetCollateralMode_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_GetCollateralMode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_GoCryptoTraderService_GetLeverage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/GetLeverage", runtime.WithHTTPPathPattern("/v1/getleverage")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_GoCryptoTraderService_GetLeverage_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_GetLeverage_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GoCryptoTraderService_SetCollateralMode_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/SetCollateralMode", runtime.WithHTTPPathPattern("/v1/getcollateralmode")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_GoCryptoTraderService_SetCollateralMode_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_SetCollateralMode_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GoCryptoTraderService_SetMarginType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/SetMarginType", runtime.WithHTTPPathPattern("/v1/getmargintype")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_GoCryptoTraderService_SetMarginType_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_SetMarginType_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GoCryptoTraderService_SetLeverage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/SetLeverage", runtime.WithHTTPPathPattern("/v1/getleverage")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_GoCryptoTraderService_SetLeverage_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_SetLeverage_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GoCryptoTraderService_ChangePositionMargin_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/gctrpc.GoCryptoTraderService/ChangePositionMargin", runtime.WithHTTPPathPattern("/v1/changepositionmargin")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_GoCryptoTraderService_ChangePositionMargin_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GoCryptoTraderService_ChangePositionMargin_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -8550,7 +9123,9 @@ var ( pattern_GoCryptoTraderService_CurrencyStateTradingPair_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "currencystatetradingpair"}, "")) - pattern_GoCryptoTraderService_GetFuturesPositions_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getfuturespositions"}, "")) + pattern_GoCryptoTraderService_GetFuturesPositionsSummary_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getfuturespositionssummary"}, "")) + + pattern_GoCryptoTraderService_GetFuturesPositionsOrders_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getfuturespositionsorders"}, "")) pattern_GoCryptoTraderService_GetCollateral_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getcollateral"}, "")) @@ -8573,6 +9148,18 @@ var ( pattern_GoCryptoTraderService_GetOrderbookAmountByNominal_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getorderbookamountbynominal"}, "")) pattern_GoCryptoTraderService_GetOrderbookAmountByImpact_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getorderbookamountbyimpact"}, "")) + + pattern_GoCryptoTraderService_GetCollateralMode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getcollateralmode"}, "")) + + pattern_GoCryptoTraderService_GetLeverage_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getleverage"}, "")) + + pattern_GoCryptoTraderService_SetCollateralMode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getcollateralmode"}, "")) + + pattern_GoCryptoTraderService_SetMarginType_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getmargintype"}, "")) + + pattern_GoCryptoTraderService_SetLeverage_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getleverage"}, "")) + + pattern_GoCryptoTraderService_ChangePositionMargin_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "changepositionmargin"}, "")) ) var ( @@ -8764,7 +9351,9 @@ var ( forward_GoCryptoTraderService_CurrencyStateTradingPair_0 = runtime.ForwardResponseMessage - forward_GoCryptoTraderService_GetFuturesPositions_0 = runtime.ForwardResponseMessage + forward_GoCryptoTraderService_GetFuturesPositionsSummary_0 = runtime.ForwardResponseMessage + + forward_GoCryptoTraderService_GetFuturesPositionsOrders_0 = runtime.ForwardResponseMessage forward_GoCryptoTraderService_GetCollateral_0 = runtime.ForwardResponseMessage @@ -8787,4 +9376,16 @@ var ( forward_GoCryptoTraderService_GetOrderbookAmountByNominal_0 = runtime.ForwardResponseMessage forward_GoCryptoTraderService_GetOrderbookAmountByImpact_0 = runtime.ForwardResponseMessage + + forward_GoCryptoTraderService_GetCollateralMode_0 = runtime.ForwardResponseMessage + + forward_GoCryptoTraderService_GetLeverage_0 = runtime.ForwardResponseMessage + + forward_GoCryptoTraderService_SetCollateralMode_0 = runtime.ForwardResponseMessage + + forward_GoCryptoTraderService_SetMarginType_0 = runtime.ForwardResponseMessage + + forward_GoCryptoTraderService_SetLeverage_0 = runtime.ForwardResponseMessage + + forward_GoCryptoTraderService_ChangePositionMargin_0 = runtime.ForwardResponseMessage ) diff --git a/gctrpc/rpc.proto b/gctrpc/rpc.proto index 0fcc8b72f5b..18628850098 100644 --- a/gctrpc/rpc.proto +++ b/gctrpc/rpc.proto @@ -346,6 +346,7 @@ message SubmitOrderRequest { double price = 6; string client_id = 7; string asset_type = 8; + string margin_type = 9; } message Trades { @@ -366,6 +367,7 @@ message SimulateOrderRequest { CurrencyPair pair = 2; double amount = 3; string side = 4; + string margin_type = 5; } message SimulateOrderResponse { @@ -1062,6 +1064,18 @@ message FuturesPositionStats { string margin_fraction = 10; string free_collateral = 11; string total_collateral = 12; + string frozen_balance = 13; + string equity_of_currency = 14; + string available_equity = 15; + string cash_balance = 16; + string discount_equity = 17; + string equity_usd = 18; + string isolated_equity = 19; + string isolated_liabilities = 20; + string isolated_upl = 21; + string notional_leverage = 22; + string total_equity = 23; + string strategy_equity = 24; } message FuturePosition { @@ -1106,31 +1120,143 @@ message GetManagedPositionsResponse { repeated FuturePosition positions = 1; } -message GetFuturesPositionsRequest { +message GetFuturesPositionsSummaryRequest { string exchange = 1; string asset = 2; CurrencyPair pair = 3; - string start_date = 4; - string end_date = 5; - string status = 6; - int64 position_limit = 7; - bool overwrite = 8; - bool get_position_stats = 9; - bool include_full_order_data = 10; - bool get_funding_payments = 11; - bool include_full_funding_rates = 12; - bool include_predicted_rate = 13; -} - -message GetFuturesPositionsResponse { - int64 total_orders = 1; - string sub_account = 2; - string total_realised_pnl = 3; - string total_unrealised_pnl = 4; - string total_pnl = 5; + CurrencyPair underlying_pair = 4; +} + +message GetFuturesPositionsSummaryResponse { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + FuturesPositionStats position_stats = 4; +} + +message GetFuturesPositionsOrdersRequest { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + CurrencyPair underlying_pair = 4; + string start_date = 5; + string end_date = 6; + bool respect_order_history_limits = 7; + bool sync_with_order_manager = 8; +} + +message GetFuturesPositionsOrdersResponse { repeated FuturePosition positions = 6; } +message GetCollateralModeRequest { + string exchange = 1; + string asset = 2; +} + +message GetCollateralModeResponse { + string exchange = 1; + string asset = 2; + string collateral_mode = 3; +} + +message SetCollateralModeRequest { + string exchange = 1; + string asset = 2; + string collateral_mode = 3; +} + +message SetCollateralModeResponse { + string exchange = 1; + string asset = 2; + bool success = 3; +} + +message GetMarginTypeRequest { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; +} + +message GetMarginTypeResponse { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + string margin_type = 4; +} + +message ChangePositionMarginRequest { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + string margin_type = 4; + double original_allocated_margin = 5; + double new_allocated_margin = 6; + string margin_side = 7; +} + +message ChangePositionMarginResponse { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + string margin_type = 4; + double new_allocated_margin = 5; + string margin_side = 6; +} + +message SetMarginTypeRequest { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + string margin_type = 4; +} + +message SetMarginTypeResponse { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + bool success = 4; +} + +message GetLeverageRequest { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + CurrencyPair underlying_pair = 4; + string margin_type = 5; + string order_side = 6; +} + +message GetLeverageResponse { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + CurrencyPair underlying_pair = 4; + string margin_type = 5; + double leverage = 6; + string order_side = 7; +} + +message SetLeverageRequest { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + CurrencyPair underlying_pair = 4; + string margin_type = 5; + double leverage = 6; + string order_side = 7; +} + +message SetLeverageResponse { + string exchange = 1; + string asset = 2; + CurrencyPair pair = 3; + CurrencyPair underlying_pair = 4; + string margin_type = 5; + string order_side = 6; + bool success = 7; +} + message GetCollateralRequest { string exchange = 1; string asset = 2; @@ -1844,8 +1970,11 @@ service GoCryptoTraderService { rpc CurrencyStateTradingPair(CurrencyStateTradingPairRequest) returns (GenericResponse) { option (google.api.http) = {get: "/v1/currencystatetradingpair"}; } - rpc GetFuturesPositions(GetFuturesPositionsRequest) returns (GetFuturesPositionsResponse) { - option (google.api.http) = {get: "/v1/getfuturespositions"}; + rpc GetFuturesPositionsSummary(GetFuturesPositionsSummaryRequest) returns (GetFuturesPositionsSummaryResponse) { + option (google.api.http) = {get: "/v1/getfuturespositionssummary"}; + } + rpc GetFuturesPositionsOrders(GetFuturesPositionsOrdersRequest) returns (GetFuturesPositionsOrdersResponse) { + option (google.api.http) = {get: "/v1/getfuturespositionsorders"}; } rpc GetCollateral(GetCollateralRequest) returns (GetCollateralResponse) { option (google.api.http) = {get: "/v1/getcollateral"}; @@ -1880,4 +2009,34 @@ service GoCryptoTraderService { rpc GetOrderbookAmountByImpact(GetOrderbookAmountByImpactRequest) returns (GetOrderbookAmountByImpactResponse) { option (google.api.http) = {get: "/v1/getorderbookamountbyimpact"}; } + rpc GetCollateralMode(GetCollateralModeRequest) returns (GetCollateralModeResponse) { + option (google.api.http) = {get: "/v1/getcollateralmode"}; + } + rpc GetLeverage(GetLeverageRequest) returns (GetLeverageResponse) { + option (google.api.http) = {get: "/v1/getleverage"}; + } + rpc SetCollateralMode(SetCollateralModeRequest) returns (SetCollateralModeResponse) { + option (google.api.http) = { + post: "/v1/getcollateralmode" + body: "*" + }; + } + rpc SetMarginType(SetMarginTypeRequest) returns (SetMarginTypeResponse) { + option (google.api.http) = { + post: "/v1/getmargintype" + body: "*" + }; + } + rpc SetLeverage(SetLeverageRequest) returns (SetLeverageResponse) { + option (google.api.http) = { + post: "/v1/getleverage" + body: "*" + }; + } + rpc ChangePositionMargin(ChangePositionMarginRequest) returns (ChangePositionMarginResponse) { + option (google.api.http) = { + post: "/v1/changepositionmargin" + body: "*" + }; + } } diff --git a/gctrpc/rpc.swagger.json b/gctrpc/rpc.swagger.json index 54188b97c86..4a588d577d2 100644 --- a/gctrpc/rpc.swagger.json +++ b/gctrpc/rpc.swagger.json @@ -176,6 +176,38 @@ ] } }, + "/v1/changepositionmargin": { + "post": { + "operationId": "GoCryptoTraderService_ChangePositionMargin", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/gctrpcChangePositionMarginResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/gctrpcChangePositionMarginRequest" + } + } + ], + "tags": [ + "GoCryptoTraderService" + ] + } + }, "/v1/converttradestocandles": { "get": { "operationId": "GoCryptoTraderService_ConvertTradesToCandles", @@ -1325,6 +1357,72 @@ ] } }, + "/v1/getcollateralmode": { + "get": { + "operationId": "GoCryptoTraderService_GetCollateralMode", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/gctrpcGetCollateralModeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ + { + "name": "exchange", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "asset", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "GoCryptoTraderService" + ] + }, + "post": { + "operationId": "GoCryptoTraderService_SetCollateralMode", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/gctrpcSetCollateralModeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/gctrpcSetCollateralModeRequest" + } + } + ], + "tags": [ + "GoCryptoTraderService" + ] + } + }, "/v1/getcommunicationrelayers": { "get": { "operationId": "GoCryptoTraderService_GetCommunicationRelayers", @@ -1961,14 +2059,14 @@ ] } }, - "/v1/getfuturespositions": { + "/v1/getfuturespositionsorders": { "get": { - "operationId": "GoCryptoTraderService_GetFuturesPositions", + "operationId": "GoCryptoTraderService_GetFuturesPositionsOrders", "responses": { "200": { "description": "A successful response.", "schema": { - "$ref": "#/definitions/gctrpcGetFuturesPositionsResponse" + "$ref": "#/definitions/gctrpcGetFuturesPositionsOrdersResponse" } }, "default": { @@ -2010,65 +2108,118 @@ "type": "string" }, { - "name": "startDate", + "name": "underlyingPair.delimiter", "in": "query", "required": false, "type": "string" }, { - "name": "endDate", + "name": "underlyingPair.base", "in": "query", "required": false, "type": "string" }, { - "name": "status", + "name": "underlyingPair.quote", "in": "query", "required": false, "type": "string" }, { - "name": "positionLimit", + "name": "startDate", "in": "query", "required": false, - "type": "string", - "format": "int64" + "type": "string" }, { - "name": "overwrite", + "name": "endDate", "in": "query", "required": false, - "type": "boolean" + "type": "string" }, { - "name": "getPositionStats", + "name": "respectOrderHistoryLimits", "in": "query", "required": false, "type": "boolean" }, { - "name": "includeFullOrderData", + "name": "syncWithOrderManager", "in": "query", "required": false, "type": "boolean" + } + ], + "tags": [ + "GoCryptoTraderService" + ] + } + }, + "/v1/getfuturespositionssummary": { + "get": { + "operationId": "GoCryptoTraderService_GetFuturesPositionsSummary", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/gctrpcGetFuturesPositionsSummaryResponse" + } }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ { - "name": "getFundingPayments", + "name": "exchange", "in": "query", "required": false, - "type": "boolean" + "type": "string" }, { - "name": "includeFullFundingRates", + "name": "asset", "in": "query", "required": false, - "type": "boolean" + "type": "string" }, { - "name": "includePredictedRate", + "name": "pair.delimiter", "in": "query", "required": false, - "type": "boolean" + "type": "string" + }, + { + "name": "pair.base", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "pair.quote", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "underlyingPair.delimiter", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "underlyingPair.base", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "underlyingPair.quote", + "in": "query", + "required": false, + "type": "string" } ], "tags": [ @@ -2336,6 +2487,120 @@ ] } }, + "/v1/getleverage": { + "get": { + "operationId": "GoCryptoTraderService_GetLeverage", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/gctrpcGetLeverageResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ + { + "name": "exchange", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "asset", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "pair.delimiter", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "pair.base", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "pair.quote", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "underlyingPair.delimiter", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "underlyingPair.base", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "underlyingPair.quote", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "marginType", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "orderSide", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "GoCryptoTraderService" + ] + }, + "post": { + "operationId": "GoCryptoTraderService_SetLeverage", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/gctrpcSetLeverageResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/gctrpcSetLeverageRequest" + } + } + ], + "tags": [ + "GoCryptoTraderService" + ] + } + }, "/v1/getloggerdetails": { "get": { "operationId": "GoCryptoTraderService_GetLoggerDetails", @@ -2561,10 +2826,42 @@ "type": "boolean" }, { - "name": "takerFeeRate", - "in": "query", - "required": false, - "type": "string" + "name": "takerFeeRate", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "GoCryptoTraderService" + ] + } + }, + "/v1/getmargintype": { + "post": { + "operationId": "GoCryptoTraderService_SetMarginType", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/gctrpcSetMarginTypeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/rpcStatus" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/gctrpcSetMarginTypeRequest" + } } ], "tags": [ @@ -4640,6 +4937,58 @@ } } }, + "gctrpcChangePositionMarginRequest": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "pair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "marginType": { + "type": "string" + }, + "originalAllocatedMargin": { + "type": "number", + "format": "double" + }, + "newAllocatedMargin": { + "type": "number", + "format": "double" + }, + "marginSide": { + "type": "string" + } + } + }, + "gctrpcChangePositionMarginResponse": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "pair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "marginType": { + "type": "string" + }, + "newAllocatedMargin": { + "type": "number", + "format": "double" + }, + "marginSide": { + "type": "string" + } + } + }, "gctrpcCoin": { "type": "object", "properties": { @@ -5251,6 +5600,42 @@ }, "totalCollateral": { "type": "string" + }, + "frozenBalance": { + "type": "string" + }, + "equityOfCurrency": { + "type": "string" + }, + "availableEquity": { + "type": "string" + }, + "cashBalance": { + "type": "string" + }, + "discountEquity": { + "type": "string" + }, + "equityUsd": { + "type": "string" + }, + "isolatedEquity": { + "type": "string" + }, + "isolatedLiabilities": { + "type": "string" + }, + "isolatedUpl": { + "type": "string" + }, + "notionalLeverage": { + "type": "string" + }, + "totalEquity": { + "type": "string" + }, + "strategyEquity": { + "type": "string" } } }, @@ -5422,6 +5807,20 @@ } } }, + "gctrpcGetCollateralModeResponse": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "collateralMode": { + "type": "string" + } + } + }, "gctrpcGetCollateralResponse": { "type": "object", "properties": { @@ -5689,25 +6088,9 @@ } } }, - "gctrpcGetFuturesPositionsResponse": { + "gctrpcGetFuturesPositionsOrdersResponse": { "type": "object", "properties": { - "totalOrders": { - "type": "string", - "format": "int64" - }, - "subAccount": { - "type": "string" - }, - "totalRealisedPnl": { - "type": "string" - }, - "totalUnrealisedPnl": { - "type": "string" - }, - "totalPnl": { - "type": "string" - }, "positions": { "type": "array", "items": { @@ -5717,6 +6100,23 @@ } } }, + "gctrpcGetFuturesPositionsSummaryResponse": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "pair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "positionStats": { + "$ref": "#/definitions/gctrpcFuturesPositionStats" + } + } + }, "gctrpcGetHistoricCandlesResponse": { "type": "object", "properties": { @@ -5786,6 +6186,33 @@ } } }, + "gctrpcGetLeverageResponse": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "pair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "underlyingPair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "marginType": { + "type": "string" + }, + "leverage": { + "type": "number", + "format": "double" + }, + "orderSide": { + "type": "string" + } + } + }, "gctrpcGetLoggerDetailsResponse": { "type": "object", "properties": { @@ -6543,6 +6970,34 @@ } } }, + "gctrpcSetCollateralModeRequest": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "collateralMode": { + "type": "string" + } + } + }, + "gctrpcSetCollateralModeResponse": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "success": { + "type": "boolean" + } + } + }, "gctrpcSetDataHistoryJobStatusRequest": { "type": "object", "properties": { @@ -6579,6 +7034,59 @@ } } }, + "gctrpcSetLeverageRequest": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "pair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "underlyingPair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "marginType": { + "type": "string" + }, + "leverage": { + "type": "number", + "format": "double" + }, + "orderSide": { + "type": "string" + } + } + }, + "gctrpcSetLeverageResponse": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "pair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "underlyingPair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "marginType": { + "type": "string" + }, + "orderSide": { + "type": "string" + }, + "success": { + "type": "boolean" + } + } + }, "gctrpcSetLoggerDetailsRequest": { "type": "object", "properties": { @@ -6590,6 +7098,40 @@ } } }, + "gctrpcSetMarginTypeRequest": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "pair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "marginType": { + "type": "string" + } + } + }, + "gctrpcSetMarginTypeResponse": { + "type": "object", + "properties": { + "exchange": { + "type": "string" + }, + "asset": { + "type": "string" + }, + "pair": { + "$ref": "#/definitions/gctrpcCurrencyPair" + }, + "success": { + "type": "boolean" + } + } + }, "gctrpcShutdownResponse": { "type": "object" }, @@ -6608,6 +7150,9 @@ }, "side": { "type": "string" + }, + "marginType": { + "type": "string" } } }, @@ -6670,6 +7215,9 @@ }, "assetType": { "type": "string" + }, + "marginType": { + "type": "string" } } }, diff --git a/gctrpc/rpc_grpc.pb.go b/gctrpc/rpc_grpc.pb.go index 5e8f5d59f6e..0751aec9278 100644 --- a/gctrpc/rpc_grpc.pb.go +++ b/gctrpc/rpc_grpc.pb.go @@ -113,7 +113,8 @@ const ( GoCryptoTraderService_CurrencyStateDeposit_FullMethodName = "/gctrpc.GoCryptoTraderService/CurrencyStateDeposit" GoCryptoTraderService_CurrencyStateWithdraw_FullMethodName = "/gctrpc.GoCryptoTraderService/CurrencyStateWithdraw" GoCryptoTraderService_CurrencyStateTradingPair_FullMethodName = "/gctrpc.GoCryptoTraderService/CurrencyStateTradingPair" - GoCryptoTraderService_GetFuturesPositions_FullMethodName = "/gctrpc.GoCryptoTraderService/GetFuturesPositions" + GoCryptoTraderService_GetFuturesPositionsSummary_FullMethodName = "/gctrpc.GoCryptoTraderService/GetFuturesPositionsSummary" + GoCryptoTraderService_GetFuturesPositionsOrders_FullMethodName = "/gctrpc.GoCryptoTraderService/GetFuturesPositionsOrders" GoCryptoTraderService_GetCollateral_FullMethodName = "/gctrpc.GoCryptoTraderService/GetCollateral" GoCryptoTraderService_Shutdown_FullMethodName = "/gctrpc.GoCryptoTraderService/Shutdown" GoCryptoTraderService_GetTechnicalAnalysis_FullMethodName = "/gctrpc.GoCryptoTraderService/GetTechnicalAnalysis" @@ -125,6 +126,12 @@ const ( GoCryptoTraderService_GetOrderbookMovement_FullMethodName = "/gctrpc.GoCryptoTraderService/GetOrderbookMovement" GoCryptoTraderService_GetOrderbookAmountByNominal_FullMethodName = "/gctrpc.GoCryptoTraderService/GetOrderbookAmountByNominal" GoCryptoTraderService_GetOrderbookAmountByImpact_FullMethodName = "/gctrpc.GoCryptoTraderService/GetOrderbookAmountByImpact" + GoCryptoTraderService_GetCollateralMode_FullMethodName = "/gctrpc.GoCryptoTraderService/GetCollateralMode" + GoCryptoTraderService_GetLeverage_FullMethodName = "/gctrpc.GoCryptoTraderService/GetLeverage" + GoCryptoTraderService_SetCollateralMode_FullMethodName = "/gctrpc.GoCryptoTraderService/SetCollateralMode" + GoCryptoTraderService_SetMarginType_FullMethodName = "/gctrpc.GoCryptoTraderService/SetMarginType" + GoCryptoTraderService_SetLeverage_FullMethodName = "/gctrpc.GoCryptoTraderService/SetLeverage" + GoCryptoTraderService_ChangePositionMargin_FullMethodName = "/gctrpc.GoCryptoTraderService/ChangePositionMargin" ) // GoCryptoTraderServiceClient is the client API for GoCryptoTraderService service. @@ -225,7 +232,8 @@ type GoCryptoTraderServiceClient interface { CurrencyStateDeposit(ctx context.Context, in *CurrencyStateDepositRequest, opts ...grpc.CallOption) (*GenericResponse, error) CurrencyStateWithdraw(ctx context.Context, in *CurrencyStateWithdrawRequest, opts ...grpc.CallOption) (*GenericResponse, error) CurrencyStateTradingPair(ctx context.Context, in *CurrencyStateTradingPairRequest, opts ...grpc.CallOption) (*GenericResponse, error) - GetFuturesPositions(ctx context.Context, in *GetFuturesPositionsRequest, opts ...grpc.CallOption) (*GetFuturesPositionsResponse, error) + GetFuturesPositionsSummary(ctx context.Context, in *GetFuturesPositionsSummaryRequest, opts ...grpc.CallOption) (*GetFuturesPositionsSummaryResponse, error) + GetFuturesPositionsOrders(ctx context.Context, in *GetFuturesPositionsOrdersRequest, opts ...grpc.CallOption) (*GetFuturesPositionsOrdersResponse, error) GetCollateral(ctx context.Context, in *GetCollateralRequest, opts ...grpc.CallOption) (*GetCollateralResponse, error) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) GetTechnicalAnalysis(ctx context.Context, in *GetTechnicalAnalysisRequest, opts ...grpc.CallOption) (*GetTechnicalAnalysisResponse, error) @@ -237,6 +245,12 @@ type GoCryptoTraderServiceClient interface { GetOrderbookMovement(ctx context.Context, in *GetOrderbookMovementRequest, opts ...grpc.CallOption) (*GetOrderbookMovementResponse, error) GetOrderbookAmountByNominal(ctx context.Context, in *GetOrderbookAmountByNominalRequest, opts ...grpc.CallOption) (*GetOrderbookAmountByNominalResponse, error) GetOrderbookAmountByImpact(ctx context.Context, in *GetOrderbookAmountByImpactRequest, opts ...grpc.CallOption) (*GetOrderbookAmountByImpactResponse, error) + GetCollateralMode(ctx context.Context, in *GetCollateralModeRequest, opts ...grpc.CallOption) (*GetCollateralModeResponse, error) + GetLeverage(ctx context.Context, in *GetLeverageRequest, opts ...grpc.CallOption) (*GetLeverageResponse, error) + SetCollateralMode(ctx context.Context, in *SetCollateralModeRequest, opts ...grpc.CallOption) (*SetCollateralModeResponse, error) + SetMarginType(ctx context.Context, in *SetMarginTypeRequest, opts ...grpc.CallOption) (*SetMarginTypeResponse, error) + SetLeverage(ctx context.Context, in *SetLeverageRequest, opts ...grpc.CallOption) (*SetLeverageResponse, error) + ChangePositionMargin(ctx context.Context, in *ChangePositionMarginRequest, opts ...grpc.CallOption) (*ChangePositionMarginResponse, error) } type goCryptoTraderServiceClient struct { @@ -1231,9 +1245,18 @@ func (c *goCryptoTraderServiceClient) CurrencyStateTradingPair(ctx context.Conte return out, nil } -func (c *goCryptoTraderServiceClient) GetFuturesPositions(ctx context.Context, in *GetFuturesPositionsRequest, opts ...grpc.CallOption) (*GetFuturesPositionsResponse, error) { - out := new(GetFuturesPositionsResponse) - err := c.cc.Invoke(ctx, GoCryptoTraderService_GetFuturesPositions_FullMethodName, in, out, opts...) +func (c *goCryptoTraderServiceClient) GetFuturesPositionsSummary(ctx context.Context, in *GetFuturesPositionsSummaryRequest, opts ...grpc.CallOption) (*GetFuturesPositionsSummaryResponse, error) { + out := new(GetFuturesPositionsSummaryResponse) + err := c.cc.Invoke(ctx, GoCryptoTraderService_GetFuturesPositionsSummary_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *goCryptoTraderServiceClient) GetFuturesPositionsOrders(ctx context.Context, in *GetFuturesPositionsOrdersRequest, opts ...grpc.CallOption) (*GetFuturesPositionsOrdersResponse, error) { + out := new(GetFuturesPositionsOrdersResponse) + err := c.cc.Invoke(ctx, GoCryptoTraderService_GetFuturesPositionsOrders_FullMethodName, in, out, opts...) if err != nil { return nil, err } @@ -1339,6 +1362,60 @@ func (c *goCryptoTraderServiceClient) GetOrderbookAmountByImpact(ctx context.Con return out, nil } +func (c *goCryptoTraderServiceClient) GetCollateralMode(ctx context.Context, in *GetCollateralModeRequest, opts ...grpc.CallOption) (*GetCollateralModeResponse, error) { + out := new(GetCollateralModeResponse) + err := c.cc.Invoke(ctx, GoCryptoTraderService_GetCollateralMode_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *goCryptoTraderServiceClient) GetLeverage(ctx context.Context, in *GetLeverageRequest, opts ...grpc.CallOption) (*GetLeverageResponse, error) { + out := new(GetLeverageResponse) + err := c.cc.Invoke(ctx, GoCryptoTraderService_GetLeverage_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *goCryptoTraderServiceClient) SetCollateralMode(ctx context.Context, in *SetCollateralModeRequest, opts ...grpc.CallOption) (*SetCollateralModeResponse, error) { + out := new(SetCollateralModeResponse) + err := c.cc.Invoke(ctx, GoCryptoTraderService_SetCollateralMode_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *goCryptoTraderServiceClient) SetMarginType(ctx context.Context, in *SetMarginTypeRequest, opts ...grpc.CallOption) (*SetMarginTypeResponse, error) { + out := new(SetMarginTypeResponse) + err := c.cc.Invoke(ctx, GoCryptoTraderService_SetMarginType_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *goCryptoTraderServiceClient) SetLeverage(ctx context.Context, in *SetLeverageRequest, opts ...grpc.CallOption) (*SetLeverageResponse, error) { + out := new(SetLeverageResponse) + err := c.cc.Invoke(ctx, GoCryptoTraderService_SetLeverage_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *goCryptoTraderServiceClient) ChangePositionMargin(ctx context.Context, in *ChangePositionMarginRequest, opts ...grpc.CallOption) (*ChangePositionMarginResponse, error) { + out := new(ChangePositionMarginResponse) + err := c.cc.Invoke(ctx, GoCryptoTraderService_ChangePositionMargin_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // GoCryptoTraderServiceServer is the server API for GoCryptoTraderService service. // All implementations must embed UnimplementedGoCryptoTraderServiceServer // for forward compatibility @@ -1437,7 +1514,8 @@ type GoCryptoTraderServiceServer interface { CurrencyStateDeposit(context.Context, *CurrencyStateDepositRequest) (*GenericResponse, error) CurrencyStateWithdraw(context.Context, *CurrencyStateWithdrawRequest) (*GenericResponse, error) CurrencyStateTradingPair(context.Context, *CurrencyStateTradingPairRequest) (*GenericResponse, error) - GetFuturesPositions(context.Context, *GetFuturesPositionsRequest) (*GetFuturesPositionsResponse, error) + GetFuturesPositionsSummary(context.Context, *GetFuturesPositionsSummaryRequest) (*GetFuturesPositionsSummaryResponse, error) + GetFuturesPositionsOrders(context.Context, *GetFuturesPositionsOrdersRequest) (*GetFuturesPositionsOrdersResponse, error) GetCollateral(context.Context, *GetCollateralRequest) (*GetCollateralResponse, error) Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error) GetTechnicalAnalysis(context.Context, *GetTechnicalAnalysisRequest) (*GetTechnicalAnalysisResponse, error) @@ -1449,6 +1527,12 @@ type GoCryptoTraderServiceServer interface { GetOrderbookMovement(context.Context, *GetOrderbookMovementRequest) (*GetOrderbookMovementResponse, error) GetOrderbookAmountByNominal(context.Context, *GetOrderbookAmountByNominalRequest) (*GetOrderbookAmountByNominalResponse, error) GetOrderbookAmountByImpact(context.Context, *GetOrderbookAmountByImpactRequest) (*GetOrderbookAmountByImpactResponse, error) + GetCollateralMode(context.Context, *GetCollateralModeRequest) (*GetCollateralModeResponse, error) + GetLeverage(context.Context, *GetLeverageRequest) (*GetLeverageResponse, error) + SetCollateralMode(context.Context, *SetCollateralModeRequest) (*SetCollateralModeResponse, error) + SetMarginType(context.Context, *SetMarginTypeRequest) (*SetMarginTypeResponse, error) + SetLeverage(context.Context, *SetLeverageRequest) (*SetLeverageResponse, error) + ChangePositionMargin(context.Context, *ChangePositionMarginRequest) (*ChangePositionMarginResponse, error) mustEmbedUnimplementedGoCryptoTraderServiceServer() } @@ -1738,8 +1822,11 @@ func (UnimplementedGoCryptoTraderServiceServer) CurrencyStateWithdraw(context.Co func (UnimplementedGoCryptoTraderServiceServer) CurrencyStateTradingPair(context.Context, *CurrencyStateTradingPairRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateTradingPair not implemented") } -func (UnimplementedGoCryptoTraderServiceServer) GetFuturesPositions(context.Context, *GetFuturesPositionsRequest) (*GetFuturesPositionsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetFuturesPositions not implemented") +func (UnimplementedGoCryptoTraderServiceServer) GetFuturesPositionsSummary(context.Context, *GetFuturesPositionsSummaryRequest) (*GetFuturesPositionsSummaryResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetFuturesPositionsSummary not implemented") +} +func (UnimplementedGoCryptoTraderServiceServer) GetFuturesPositionsOrders(context.Context, *GetFuturesPositionsOrdersRequest) (*GetFuturesPositionsOrdersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetFuturesPositionsOrders not implemented") } func (UnimplementedGoCryptoTraderServiceServer) GetCollateral(context.Context, *GetCollateralRequest) (*GetCollateralResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetCollateral not implemented") @@ -1774,6 +1861,24 @@ func (UnimplementedGoCryptoTraderServiceServer) GetOrderbookAmountByNominal(cont func (UnimplementedGoCryptoTraderServiceServer) GetOrderbookAmountByImpact(context.Context, *GetOrderbookAmountByImpactRequest) (*GetOrderbookAmountByImpactResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetOrderbookAmountByImpact not implemented") } +func (UnimplementedGoCryptoTraderServiceServer) GetCollateralMode(context.Context, *GetCollateralModeRequest) (*GetCollateralModeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetCollateralMode not implemented") +} +func (UnimplementedGoCryptoTraderServiceServer) GetLeverage(context.Context, *GetLeverageRequest) (*GetLeverageResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLeverage not implemented") +} +func (UnimplementedGoCryptoTraderServiceServer) SetCollateralMode(context.Context, *SetCollateralModeRequest) (*SetCollateralModeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetCollateralMode not implemented") +} +func (UnimplementedGoCryptoTraderServiceServer) SetMarginType(context.Context, *SetMarginTypeRequest) (*SetMarginTypeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetMarginType not implemented") +} +func (UnimplementedGoCryptoTraderServiceServer) SetLeverage(context.Context, *SetLeverageRequest) (*SetLeverageResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetLeverage not implemented") +} +func (UnimplementedGoCryptoTraderServiceServer) ChangePositionMargin(context.Context, *ChangePositionMarginRequest) (*ChangePositionMarginResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ChangePositionMargin not implemented") +} func (UnimplementedGoCryptoTraderServiceServer) mustEmbedUnimplementedGoCryptoTraderServiceServer() {} // UnsafeGoCryptoTraderServiceServer may be embedded to opt out of forward compatibility for this service. @@ -3497,20 +3602,38 @@ func _GoCryptoTraderService_CurrencyStateTradingPair_Handler(srv interface{}, ct return interceptor(ctx, in, info, handler) } -func _GoCryptoTraderService_GetFuturesPositions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetFuturesPositionsRequest) +func _GoCryptoTraderService_GetFuturesPositionsSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetFuturesPositionsSummaryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GoCryptoTraderServiceServer).GetFuturesPositionsSummary(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GoCryptoTraderService_GetFuturesPositionsSummary_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GoCryptoTraderServiceServer).GetFuturesPositionsSummary(ctx, req.(*GetFuturesPositionsSummaryRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GoCryptoTraderService_GetFuturesPositionsOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetFuturesPositionsOrdersRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(GoCryptoTraderServiceServer).GetFuturesPositions(ctx, in) + return srv.(GoCryptoTraderServiceServer).GetFuturesPositionsOrders(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: GoCryptoTraderService_GetFuturesPositions_FullMethodName, + FullMethod: GoCryptoTraderService_GetFuturesPositionsOrders_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(GoCryptoTraderServiceServer).GetFuturesPositions(ctx, req.(*GetFuturesPositionsRequest)) + return srv.(GoCryptoTraderServiceServer).GetFuturesPositionsOrders(ctx, req.(*GetFuturesPositionsOrdersRequest)) } return interceptor(ctx, in, info, handler) } @@ -3713,6 +3836,114 @@ func _GoCryptoTraderService_GetOrderbookAmountByImpact_Handler(srv interface{}, return interceptor(ctx, in, info, handler) } +func _GoCryptoTraderService_GetCollateralMode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetCollateralModeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GoCryptoTraderServiceServer).GetCollateralMode(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GoCryptoTraderService_GetCollateralMode_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GoCryptoTraderServiceServer).GetCollateralMode(ctx, req.(*GetCollateralModeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GoCryptoTraderService_GetLeverage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetLeverageRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GoCryptoTraderServiceServer).GetLeverage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GoCryptoTraderService_GetLeverage_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GoCryptoTraderServiceServer).GetLeverage(ctx, req.(*GetLeverageRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GoCryptoTraderService_SetCollateralMode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetCollateralModeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GoCryptoTraderServiceServer).SetCollateralMode(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GoCryptoTraderService_SetCollateralMode_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GoCryptoTraderServiceServer).SetCollateralMode(ctx, req.(*SetCollateralModeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GoCryptoTraderService_SetMarginType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetMarginTypeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GoCryptoTraderServiceServer).SetMarginType(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GoCryptoTraderService_SetMarginType_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GoCryptoTraderServiceServer).SetMarginType(ctx, req.(*SetMarginTypeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GoCryptoTraderService_SetLeverage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetLeverageRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GoCryptoTraderServiceServer).SetLeverage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GoCryptoTraderService_SetLeverage_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GoCryptoTraderServiceServer).SetLeverage(ctx, req.(*SetLeverageRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GoCryptoTraderService_ChangePositionMargin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ChangePositionMarginRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GoCryptoTraderServiceServer).ChangePositionMargin(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GoCryptoTraderService_ChangePositionMargin_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GoCryptoTraderServiceServer).ChangePositionMargin(ctx, req.(*ChangePositionMarginRequest)) + } + return interceptor(ctx, in, info, handler) +} + // GoCryptoTraderService_ServiceDesc is the grpc.ServiceDesc for GoCryptoTraderService service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -4073,8 +4304,12 @@ var GoCryptoTraderService_ServiceDesc = grpc.ServiceDesc{ Handler: _GoCryptoTraderService_CurrencyStateTradingPair_Handler, }, { - MethodName: "GetFuturesPositions", - Handler: _GoCryptoTraderService_GetFuturesPositions_Handler, + MethodName: "GetFuturesPositionsSummary", + Handler: _GoCryptoTraderService_GetFuturesPositionsSummary_Handler, + }, + { + MethodName: "GetFuturesPositionsOrders", + Handler: _GoCryptoTraderService_GetFuturesPositionsOrders_Handler, }, { MethodName: "GetCollateral", @@ -4120,6 +4355,30 @@ var GoCryptoTraderService_ServiceDesc = grpc.ServiceDesc{ MethodName: "GetOrderbookAmountByImpact", Handler: _GoCryptoTraderService_GetOrderbookAmountByImpact_Handler, }, + { + MethodName: "GetCollateralMode", + Handler: _GoCryptoTraderService_GetCollateralMode_Handler, + }, + { + MethodName: "GetLeverage", + Handler: _GoCryptoTraderService_GetLeverage_Handler, + }, + { + MethodName: "SetCollateralMode", + Handler: _GoCryptoTraderService_SetCollateralMode_Handler, + }, + { + MethodName: "SetMarginType", + Handler: _GoCryptoTraderService_SetMarginType_Handler, + }, + { + MethodName: "SetLeverage", + Handler: _GoCryptoTraderService_SetLeverage_Handler, + }, + { + MethodName: "ChangePositionMargin", + Handler: _GoCryptoTraderService_ChangePositionMargin_Handler, + }, }, Streams: []grpc.StreamDesc{ { diff --git a/gctscript/wrappers/gct/gctwrapper_test.go b/gctscript/wrappers/gct/gctwrapper_test.go index 6dd87b733b6..93c643e708e 100644 --- a/gctscript/wrappers/gct/gctwrapper_test.go +++ b/gctscript/wrappers/gct/gctwrapper_test.go @@ -11,6 +11,7 @@ import ( objects "github.com/d5/tengo/v2" "github.com/thrasher-corp/gocryptotrader/common" + "github.com/thrasher-corp/gocryptotrader/config" "github.com/thrasher-corp/gocryptotrader/engine" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" "github.com/thrasher-corp/gocryptotrader/gctscript/modules" @@ -65,7 +66,7 @@ func TestMain(m *testing.M) { os.Exit(1) } - engine.Bot.OrderManager, err = engine.SetupOrderManager(em, &engine.CommunicationManager{}, &engine.Bot.ServicesWG, false, false, 0) + engine.Bot.OrderManager, err = engine.SetupOrderManager(em, &engine.CommunicationManager{}, &engine.Bot.ServicesWG, &config.OrderManager{}) if err != nil { log.Print(err) os.Exit(1) diff --git a/testdata/http_mock/binance/binance.json b/testdata/http_mock/binance/binance.json index 1e74af69f25..fd48e28f602 100644 --- a/testdata/http_mock/binance/binance.json +++ b/testdata/http_mock/binance/binance.json @@ -262369,6 +262369,38 @@ }, "/dapi/v1/fundingRate": { "GET": [ + { + "data": [ + { + "fundingRate": "0.00010000", + "fundingTime": 1605513600010, + "symbol": "BTCUSD_PERP" + }, + { + "fundingRate": "0.00025141", + "fundingTime": 1605542400000, + "symbol": "BTCUSD_PERP" + }, + { + "fundingRate": "0.00010000", + "fundingTime": 1605571200000, + "symbol": "BTCUSD_PERP" + }, + { + "fundingRate": "0.00010000", + "fundingTime": 1605600000000, + "symbol": "BTCUSD_PERP" + }, + { + "fundingRate": "0.00010000", + "fundingTime": 1605628800008, + "symbol": "BTCUSD_PERP" + } + ], + "queryString": "endTime=1580515200000&limit=1000&startTime=1577836800000&symbol=BTCUSD_PERP", + "bodyParams": "", + "headers": {} + }, { "data": [ { @@ -272474,7 +272506,7 @@ "time": 1679280568770 } ], - "queryString": "limit=1000\u0026symbol=BTCUSD_PERP", + "queryString": "limit=5\u0026symbol=BTCUSD_PERP", "bodyParams": "", "headers": {} }, @@ -272521,7 +272553,7 @@ "time": 1607294297101 } ], - "queryString": "limit=5\u0026symbol=BTCUSD_PERP", + "queryString": "limit=1000\u0026symbol=BTCUSD_PERP", "bodyParams": "", "headers": {} } @@ -331195,6 +331227,53 @@ "queryString": "limit=5\u0026symbol=BTCUSDT", "bodyParams": "", "headers": {} + }, + { + "data": [ + { + "id": 3947543021, + "isBuyerMaker": false, + "price": "30114.70", + "qty": "0.002", + "quoteQty": "60.22", + "time": 1689636431983 + }, + { + "id": 3947544017, + "isBuyerMaker": false, + "price": "30110.00", + "qty": "0.002", + "quoteQty": "60.22", + "time": 1689636508583 + }, + { + "id": 3947544018, + "isBuyerMaker": false, + "price": "30110.00", + "qty": "0.001", + "quoteQty": "30.11", + "time": 1689636508583 + }, + { + "id": 3947544019, + "isBuyerMaker": false, + "price": "30110.00", + "qty": "0.347", + "quoteQty": "10448.17", + "time": 1689636508583 + }, + { + "id": 3947544020, + "isBuyerMaker": false, + "price": "30110.00", + "qty": "0.090", + "quoteQty": "2709.90", + "time": 1689636508658 + } + ], + "queryString": "limit=1000\u0026symbol=BTCUSDT", + "bodyParams": "", + "headers": {} } ] },