From 39bbd8dfc9a92dabd81f00f773e0472c13bedb92 Mon Sep 17 00:00:00 2001 From: Andrew Date: Thu, 3 Sep 2020 17:13:53 +1000 Subject: [PATCH] (Feature) OHLCV data storage and retrieval (#522) * WIP * end of day WIP started migration of trade history * added kline support to hitbtc huobi lbank * added exchangehistory to all supported exchanges started work on coinbase 300 candles/request method * end of day WIP * removed unused ta and misc changes to flag ready for review * yobit cleanup * revert coinbase changES * general code clean up and added zb support * poloniex support added * renamed method to FormatExchangeKlineInterval other misc fixes * linter fixes * linter fixes * removed verbose * fixed poloniex test coverage * revert poloniex mock data * regenerated poloniex mock data * a very verbose clean up * binance mock clean up * removed unneeded t.Log() * setting verbose to true to debug CI issue * first pass changes addressed * common.ErrNotYetImplemented implemented :D * comments added * WIP-addressed exchange requests and reverted previous GetExchangeHistory changes * WIP-addressed exchange requests and reverted previous GetExchangeHistory changes * increased test coverage added kraken support * OKGroup support completed started work on address GetExchangeHistory feedback and migrating to own PR under https://github.com/xtda/gocryptotrader/tree/exchange_history * convert zb ratelimits * gofmt run on okcoin * increased delay on rate limit * gofmt package * fixed panic with coinbene and bithumb if conversion fails * very broken end of day WIP * added support for GetHistoricCandlesEx to coinbase and binance * gofmt package * coinbase, btcmarkets, zb ex wrapper function added * added all exchange support for ex regenerated mock data * update bithumb to return wrapper method * gofmt package * end of day started work on changes * models created for exchange/asset/currency/currencypair, new seed system created * reworked test coverage added okgroup support general fixes/change requests addressed * Added OneMonth * limit checks on supportedexchanges * reverted getexchangehistory * started work on currency seeding and insertion * reworked binance tesT * added workaround for kraken panic * :D extremely broken WIP * renamed command to extended removed interval check on non-implemented commands * added wrapperconfig back * increased test coverage for FormatExchangeKlineInterval * WIP * increased test coverage for FormatExchangeKlineInterval bitfinex/gateio/huobi * linter fixes * zb kraken lbank coinbene btcmarkets support added * removed verbose * OK group support for other asset types added * swapped margin to use spot endpoint * index support added test coverage added for asset types * added asset type to okcoin test * gofmt * add asset to extended method * removed verbose * Very broken WIP models need to be regenerated * add support for coinbene swap increase test coverage * removed verbose * small clean up of okgroup wrapper functions * verbose to troubleshoot CI issues * removed verbose * added error check reverted coinbasechanges * attempting to fix broken model generation * readme updated * :D i broke so much * model regeneration fixed & complete * candle model filled out * removed unused start/finish started work on decoupling api requests from kline package * restructured coinbene, bithumb methods, added bitstamp support * kraken time fix * BTCMarkets restructure * typo fix * removed test for futures due to contact changing * removed test for futures due to contact changing * added start/end date to extended method over range * WIP * added sync option to candles * converted to assettranslator * removed verbose * removed verbose * removed invalid char * reverted incorrectly removed return * added import * further template updates * macos hates my keyboard :D * misc canges * started work on creating kline from databases eed * x -> i * removed verbose * updated fixCasing to allocate var before checks * sqlite3 supported work started * removed time conversion * further work on tets * sort all outgoing kline candles * fixCasing fix * after/before checks added * added parallel to test * logic check on BTCmarkets * removed unused param, used correct iterator * converted HitBTC to use time.Time * test update * add iszero false check to candle times * Seed exchange & OHCLV data for test usage * updated resultlimit to 5000 * new line added * added comment to exported const * move date forward * use configured ratelimit * fixed pair for test * panic fixed WIP on fixCasing * fixCasing rework, started work on readme docs * enable rate limiter for wrapper issues tool * docs updated * removed unused vars from tests * removed err from return and formatted currency * updated Yobit supported status * Updated HitBTC to use onehour candles due to test exeuction times * added further details to gctcli output * added link to docs * added link to tempalte * disable FTX websocket in config_example * fix poloneix * regenerated poloniex mock data * removed recording flag * format on package * moved exchange var outside of method scope * reworked seeding into package * verbose output improved * removed verbose from candles * Added comments to exported functions * removed verbose output * Reworking of tests * end of day commit * added SQLite migration for asset, test updates for exchange, added support for withdrawal for new exchange_name_id relation * regenerated database models * WIP * test rework, sqlite migration updates for withdrawal * Reworked error returns to stop duplications, format all output to UTC, changed gctscript OHLCV output to be unix timestmap, started work on seeding tool * gofmt * dbseed command for seeding exchanges added, removed seed from dbmigrate, LoadCSV method added for exchange * go mod tidy * added import candle from csv command to dbseed * Removed reset & duplicate migrate command from helper, renamed struct to Item/Candle over Candle/Tick, added test coverage to dbseed, improved withdraw tests * remove broken tests due to ORM generation of Fk, removed go unneeded goroutine for inserting records * removed t.Cleanup usage because appveyor * added test coverage to StoreInDatabase() * removed unneeded data from config for test * added new line * Added down migration support to candle/asset removal, return original error and display rollback error * removed unneeded err assignment, break out of loop on error * add err check to method for test * first pass changes * WIP * Updated migrations for both sqlite3 & postgres to create exchanges if any withdrawal_history records are found, removed migrate command * removed argusage as usage information is provided by flags * added inserted records return count and test coverage * new line added * Database: comment config details out to disable local postgresl testing by default * added asset support * Database: added error return when no exchanges are found, title exchange name across queries * Fixed test data * Database: removed migration bool from ConnectToDatabase(), removed empty line, insert asset on test * Database: verbose linter :D * Database/OHLCV: removed go module from dbseed command and reverted back to main module, converted interval to int64 to match other parts of code base, provided migrations to update database, poloniex fix to skip first candle * dbseed: add completed message to output * Database: added migration to add asset to uniq index for candle table * Database: database -> exchange * Database: add asset to upsert conflict * Poloneix: fix for invalid interval * regenerated poloniex mock data * Database: added down migration for candle interval update * OHCLV/Database: WIP * OHLCV/Datastore: added new ValidateKline() method to check that asset, pair, interval are enabled/supported by exchange and updated tests * revert configtest changes * OHCLV/Kline: pointer assignment to ErrorKline & format pairs on check * goimports * migration updates * Database/Candle: updated tests * revert configtest changes * ZB: updaed defaults to use uppercase pairs * ZB: updaed defaults to use uppercase pairs * revert pair formatting * Switch over to .Cotains() method from pairManagement * Added comment & ftx back :laughing: * OHLCV/Datastore: (Candles): added not null to asset, (WithdrawalHistory): added not null to exchange_name_id), reworked KlineError return * set verbose to false * updated btc markets test * Updated readme * removed ability to have blank exchange name as indexing requires it * remove old usedb and empty exchange check, return error on no data instead * Updated kline test to match date range * Renamed candles.exchange_id column to candles.xchange_name_id to match withdrawal table, return err on unwrap, zb fix revert * regenerated sqlite3 models * force UTC for sqlite.... because sqlite * OHLCV/Datastore: upper case pairs on insert for consistency, remove unneeded rollback call on commit failure as it has no effect, move rollback outside of insertsqlite/insertpsql methods * add error check for no candles * nil length/cap is 0 in golang :D * OHLCV/Datastore: updated wording on examples, removed duplicate testfile * OHLCV/Datastore: updated README with links to dbseed * dbtool -> dbseed --- cmd/dbseed/README.md | 123 + cmd/dbseed/candle.go | 123 + cmd/dbseed/database.go | 64 + cmd/dbseed/dbseed_test.go | 47 + cmd/dbseed/exchange.go | 132 + cmd/dbseed/main.go | 67 + cmd/gctcli/commands.go | 20 + cmd/gen_sqlboiler_config/main.go | 2 +- config/config.go | 4 +- config/config_test.go | 2 +- config/config_types.go | 2 +- database/README.md | 8 +- database/database_types.go | 2 + .../20200518131133_exchange/postgres.sql | 12 + .../20200518131133_exchange/sqlite3.sql | 11 + .../20200520103816_candle/postgres.sql | 22 + .../20200520103816_candle/sqlite3.sql | 19 + .../20200715122118_asset/postgres.sql | 6 + .../20200715122118_asset/sqlite3.sql | 23 + .../postgres.sql | 14 + .../sqlite3.sql | 84 + .../postgres.sql | 35 + .../sqlite3.sql | 34 + .../postgres.sql | 6 + .../sqlite3.sql | 39 + .../postgres.sql | 7 + .../sqlite3.sql | 51 + .../postgres.sql | 7 + .../sqlite3.sql | 39 + .../postgres.sql | 10 + .../sqlite3.sql | 39 + database/models/postgres/boil_suites_test.go | 37 +- database/models/postgres/boil_table_names.go | 4 + database/models/postgres/candle.go | 1095 ++ database/models/postgres/candle_test.go | 841 + database/models/postgres/exchange.go | 1209 ++ database/models/postgres/exchange_test.go | 1039 ++ database/models/postgres/psql_suites_test.go | 2 +- database/models/postgres/withdrawal_crypto.go | 15 - database/models/postgres/withdrawal_fiat.go | 4 +- .../models/postgres/withdrawal_history.go | 269 +- .../postgres/withdrawal_history_test.go | 111 +- database/models/sqlite3/boil_suites_test.go | 50 +- database/models/sqlite3/boil_table_names.go | 4 + database/models/sqlite3/candle.go | 996 + database/models/sqlite3/candle_test.go | 793 + database/models/sqlite3/exchange.go | 1104 ++ database/models/sqlite3/exchange_test.go | 951 + database/models/sqlite3/withdrawal_crypto.go | 15 - database/models/sqlite3/withdrawal_fiat.go | 4 +- database/models/sqlite3/withdrawal_history.go | 269 +- .../models/sqlite3/withdrawal_history_test.go | 110 +- database/repository/audit/audit.go | 4 - database/repository/audit/audit_test.go | 10 - database/repository/candle/candle.go | 270 + database/repository/candle/candle_test.go | 306 + database/repository/candle/candle_types.go | 36 + database/repository/exchange/exchange.go | 229 + database/repository/exchange/exchange_test.go | 184 + .../repository/exchange/exchange_types.go | 19 + database/repository/repository_test.go | 44 + database/repository/script/script.go | 4 - database/repository/script/script_test.go | 21 +- database/repository/withdraw/withdraw.go | 87 +- database/repository/withdraw/withdraw_test.go | 110 +- database/testhelpers/test_helpers.go | 32 +- database/testhelpers/test_helpers_test.go | 6 +- docs/OHLCV.md | 4 + engine/rpcserver.go | 88 +- engine/withdraw.go | 2 +- exchanges/binance/binance_test.go | 4 +- exchanges/binance/binance_wrapper.go | 12 +- exchanges/bitfinex/bitfinex_test.go | 2 +- exchanges/bitfinex/bitfinex_wrapper.go | 12 +- exchanges/bithumb/bithumb_test.go | 4 +- exchanges/bithumb/bithumb_wrapper.go | 6 +- exchanges/bitstamp/bitstamp_test.go | 4 +- exchanges/bitstamp/bitstamp_wrapper.go | 12 +- exchanges/btcmarkets/btcmarkets_test.go | 3 +- exchanges/btcmarkets/btcmarkets_wrapper.go | 12 +- exchanges/coinbasepro/coinbasepro_test.go | 4 +- exchanges/coinbasepro/coinbasepro_wrapper.go | 12 +- exchanges/coinbene/coinbene_test.go | 2 +- exchanges/coinbene/coinbene_wrapper.go | 7 +- exchanges/exchange.go | 27 +- exchanges/exchange_test.go | 50 +- exchanges/ftx/ftx_test.go | 4 +- exchanges/ftx/ftx_wrapper.go | 12 +- exchanges/gateio/gateio_wrapper.go | 6 +- exchanges/hitbtc/hitbtc_test.go | 4 +- exchanges/hitbtc/hitbtc_wrapper.go | 13 +- exchanges/huobi/huobi_test.go | 4 +- exchanges/huobi/huobi_wrapper.go | 6 +- exchanges/kline/kline.go | 11 +- exchanges/kline/kline_datastorage.go | 155 + exchanges/kline/kline_test.go | 279 +- exchanges/kline/kline_types.go | 12 +- exchanges/kraken/kraken_test.go | 4 +- exchanges/kraken/kraken_wrapper.go | 13 +- exchanges/lbank/lbank_test.go | 4 +- exchanges/lbank/lbank_wrapper.go | 13 +- exchanges/okcoin/okcoin_test.go | 4 +- exchanges/okcoin/okcoin_wrapper.go | 12 +- exchanges/okex/okex_test.go | 6 +- exchanges/okex/okex_wrapper.go | 12 +- exchanges/poloniex/poloniex_test.go | 4 +- exchanges/poloniex/poloniex_wrapper.go | 11 +- exchanges/zb/zb_test.go | 1 - exchanges/zb/zb_wrapper.go | 6 +- gctrpc/rpc.pb.go | 14966 ++++++++++------ gctrpc/rpc.pb.gw.go | 100 +- gctrpc/rpc.proto | 2 + gctrpc/rpc.swagger.json | 148 +- gctscript/modules/gct/exchange.go | 2 +- gctscript/wrappers/gct/exchange/exchange.go | 4 +- go.mod | 2 + go.sum | 5 +- portfolio/withdraw/withdraw_types.go | 1 + ...ance_BTCUSDT_24h_2019_01_01_2020_01_01.csv | 365 + testdata/configtest.json | 2 +- testdata/exchangelist.csv | 28 + testdata/http_mock/poloniex/poloniex.json | 179 +- 122 files changed, 21985 insertions(+), 6020 deletions(-) create mode 100644 cmd/dbseed/README.md create mode 100644 cmd/dbseed/candle.go create mode 100644 cmd/dbseed/database.go create mode 100644 cmd/dbseed/dbseed_test.go create mode 100644 cmd/dbseed/exchange.go create mode 100644 cmd/dbseed/main.go create mode 100644 database/migrations/20200518131133_exchange/postgres.sql create mode 100644 database/migrations/20200518131133_exchange/sqlite3.sql create mode 100644 database/migrations/20200520103816_candle/postgres.sql create mode 100644 database/migrations/20200520103816_candle/sqlite3.sql create mode 100644 database/migrations/20200715122118_asset/postgres.sql create mode 100644 database/migrations/20200715122118_asset/sqlite3.sql create mode 100644 database/migrations/20200715123925_update_withdrawal_history_exchange/postgres.sql create mode 100644 database/migrations/20200715123925_update_withdrawal_history_exchange/sqlite3.sql create mode 100644 database/migrations/20200805131503_update_candle_interval_type/postgres.sql create mode 100644 database/migrations/20200805131503_update_candle_interval_type/sqlite3.sql create mode 100644 database/migrations/20200805151208_update_candle_add_asset_to_uniq_index/postgres.sql create mode 100644 database/migrations/20200805151208_update_candle_add_asset_to_uniq_index/sqlite3.sql create mode 100644 database/migrations/20200814113829_update_withdrawal_history_add_not_null_to_exchange_name_id/postgres.sql create mode 100644 database/migrations/20200814113829_update_withdrawal_history_add_not_null_to_exchange_name_id/sqlite3.sql create mode 100644 database/migrations/20200814121412_update_candle_add_not_null_to_asset/postgres.sql create mode 100644 database/migrations/20200814121412_update_candle_add_not_null_to_asset/sqlite3.sql create mode 100644 database/migrations/20200819150038_update_candle_exchange_id_to_exchange_name_id/postgres.sql create mode 100644 database/migrations/20200819150038_update_candle_exchange_id_to_exchange_name_id/sqlite3.sql create mode 100644 database/models/postgres/candle.go create mode 100644 database/models/postgres/candle_test.go create mode 100644 database/models/postgres/exchange.go create mode 100644 database/models/postgres/exchange_test.go create mode 100644 database/models/sqlite3/candle.go create mode 100644 database/models/sqlite3/candle_test.go create mode 100644 database/models/sqlite3/exchange.go create mode 100644 database/models/sqlite3/exchange_test.go create mode 100644 database/repository/candle/candle.go create mode 100644 database/repository/candle/candle_test.go create mode 100644 database/repository/candle/candle_types.go create mode 100644 database/repository/exchange/exchange.go create mode 100644 database/repository/exchange/exchange_test.go create mode 100644 database/repository/exchange/exchange_types.go create mode 100644 database/repository/repository_test.go create mode 100644 exchanges/kline/kline_datastorage.go create mode 100644 testdata/binance_BTCUSDT_24h_2019_01_01_2020_01_01.csv create mode 100644 testdata/exchangelist.csv diff --git a/cmd/dbseed/README.md b/cmd/dbseed/README.md new file mode 100644 index 00000000..f95b001b --- /dev/null +++ b/cmd/dbseed/README.md @@ -0,0 +1,123 @@ +# GoCryptoTrader dbseed tool + + + + +[![Build Status](https://travis-ci.org/thrasher-corp/gocryptotrader.svg?branch=master)](https://travis-ci.org/thrasher-corp/gocryptotrader) +[![Software License](https://img.shields.io/badge/License-MIT-orange.svg?style=flat-square)](https://github.com/thrasher-corp/gocryptotrader/blob/master/LICENSE) +[![GoDoc](https://godoc.org/github.com/thrasher-corp/gocryptotrader?status.svg)](https://godoc.org/github.com/thrasher-corp/gocryptotrader/portfolio) +[![Coverage Status](http://codecov.io/github/thrasher-corp/gocryptotrader/coverage.svg?branch=master)](http://codecov.io/github/thrasher-corp/gocryptotrader?branch=master) +[![Go Report Card](https://goreportcard.com/badge/github.com/thrasher-corp/gocryptotrader)](https://goreportcard.com/report/github.com/thrasher-corp/gocryptotrader) + + +This dbseed tool is part of the GoCryptoTrader codebase. + +## This is still in active development + +You can track ideas, planned features and what's in progress on this Trello board: [https://trello.com/b/ZAhMhpOy/gocryptotrader](https://trello.com/b/ZAhMhpOy/gocryptotrader). + +Join our slack to discuss all things related to GoCryptoTrader! [GoCryptoTrader Slack](https://join.slack.com/t/gocryptotrader/shared_invite/enQtNTQ5NDAxMjA2Mjc5LTc5ZDE1ZTNiOGM3ZGMyMmY1NTAxYWZhODE0MWM5N2JlZDk1NDU0YTViYzk4NTk3OTRiMDQzNGQ1YTc4YmRlMTk) + +## How to use + +#### Prerequisites +##### Configuration + +dbseed requires a valid database configuration in your gocryptotrader config + +```sh + "database": { + "enabled": true, + "verbose": true, + "driver": "postgres", + "connectionDetails": { + "host": "localhost", + "port": 5432, + "username": "gct-dev", + "password": "gct-dev", + "database": "gct-dev", + "sslmode": "disable" + } + }, +``` + +By default this will load from the default GoCryptoTrader path + +For Windows users this is: +```%APPDATA%\GoCryptoTrader``` + +For Linux/macOS users this is: +```$HOME\.gocryptotrader``` + +and can be overridden with the ```-config``` flag + +``` --config value config file to load (default: "~/.gocryptotrader/config.json")``` + +#### Usage + +#### Sub Commands +##### candle +``` + file seed candle data from a file + help, h Shows a list of commands or help for one command +``` +##### command examples +``` +dbseed candle file --exchange=binance --base=BTC --quote=USDT --interval=86400 --asset=spot --filename=../../testdata/binance_BTCUSDT_24h_2019_01_01_2020_01_01.csv +``` +File structure for import contains the following rows with no headers: + +``` +timestamp, volume, open, high, low, close +``` +An example of this is: +``` +1546300800,23741.687033,3701.23,3797.14,3642,3797.14 +1546387200,35156.463369,3796.45,3858.56,3750.45,3858.56 +1546473600,29406.948359,3857.57,3766.78,3730,3766.78 +1546560000,29519.554671,3767.2,3792.01,3703.57,3792.01 +1546646400,30490.667751,3790.09,3770.96,3751,3770.96 +``` +##### exchange +``` + file seed exchange data from a file + add add a single exchange + default seed exchange from default list +``` +##### command examples +``` +dbseed exchange add --name=newexchange +dbseed exchange file --filename=../../testdata/exchangelist.csv +dbseed exchange default +``` + +File structure for importing contains the following rows with no headers: +``` +exchange +``` +An example of this is: +``` +binance, +ftx, +btc markets, +``` + +## Contribution + +Please feel free to submit any pull requests or suggest any desired features to be added. + +When submitting a PR, please abide by our coding guidelines: + ++ Code must adhere to the official Go [formatting](https://golang.org/doc/effective_go.html#formatting) guidelines (i.e. uses [gofmt](https://golang.org/cmd/gofmt/)). ++ Code must be documented adhering to the official Go [commentary](https://golang.org/doc/effective_go.html#commentary) guidelines. ++ Code must adhere to our [coding style](https://github.com/thrasher-corp/gocryptotrader/blob/master/doc/coding_style.md). ++ Pull requests need to be based on and opened against the `master` branch. + +## Donations + + + +If this framework helped you in any way, or you would like to support the developers working on it, please donate Bitcoin to: + +***bc1qk0jareu4jytc0cfrhr5wgshsq8282awpavfahc*** + diff --git a/cmd/dbseed/candle.go b/cmd/dbseed/candle.go new file mode 100644 index 00000000..55a2578a --- /dev/null +++ b/cmd/dbseed/candle.go @@ -0,0 +1,123 @@ +package main + +import ( + "errors" + "log" + "os" + "strconv" + + "github.com/thrasher-corp/gocryptotrader/database/repository/candle" + "github.com/urfave/cli/v2" +) + +var seedCandleCommand = &cli.Command{ + Name: "candle", + Usage: "seed candle data", + Subcommands: []*cli.Command{ + { + Name: "file", + Usage: "seed candle data from a file", + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "exchange", + Usage: "exchange name of supplied candle data", + }, + &cli.StringFlag{ + Name: "base", + Usage: "base currency of supplied candle data", + }, + &cli.StringFlag{ + Name: "quote", + Usage: "quote currency of supplied candle data", + }, + &cli.Int64Flag{ + Name: "interval", + Usage: "interval of supplied candle data", + }, + &cli.StringFlag{ + Name: "asset", + Usage: "asset type of supplied data (spot/margin/futures for example)", + }, + &cli.StringFlag{ + Name: "filename", + Usage: "csv file to load candle data from (see readme for formatting details)", + TakesFile: true, + FilePath: workingDir, + }, + }, + Action: seedCandleFromFile, + }, + }, +} + +func seedCandleFromFile(c *cli.Context) error { + if c.NumFlags() == 0 && c.NArg() == 0 { + return cli.ShowSubcommandHelp(c) + } + + var exchangeName string + if c.IsSet("exchange") { + exchangeName = c.String("exchange") + } else if c.Args().Get(0) != "" { + exchangeName = c.Args().Get(0) + } + + var base string + if c.IsSet("base") { + base = c.String("base") + } else if c.Args().Get(1) != "" { + base = c.Args().Get(1) + } + + var quote string + if c.IsSet("quote") { + quote = c.String("quote") + } else if c.Args().Get(2) != "" { + quote = c.Args().Get(2) + } + + var interval int64 + if c.IsSet("interval") { + interval = c.Int64("interval") + } else if c.Args().Get(3) != "" { + var err error + interval, err = strconv.ParseInt(c.Args().Get(3), 10, 64) + if err != nil { + return errors.New("failed to convert interval") + } + } + + var asset string + if c.IsSet("asset") { + asset = c.String("asset") + } else if c.Args().Get(4) != "" { + asset = c.Args().Get(4) + } + + var fileName string + if c.IsSet("filename") { + fileName = c.String("filename") + } else if c.Args().Get(5) != "" { + fileName = c.Args().Get(5) + } + + _, err := os.Stat(fileName) + if err != nil { + return err + } + + err = load(c) + if err != nil { + return err + } + + totalInserted, err := candle.InsertFromCSV(exchangeName, + base, quote, interval, asset, + fileName) + if err != nil { + return err + } + + log.Printf("Inserted: %v records", totalInserted) + return nil +} diff --git a/cmd/dbseed/database.go b/cmd/dbseed/database.go new file mode 100644 index 00000000..01c17bf5 --- /dev/null +++ b/cmd/dbseed/database.go @@ -0,0 +1,64 @@ +package main + +import ( + "errors" + "fmt" + + "github.com/thrasher-corp/gocryptotrader/config" + "github.com/thrasher-corp/gocryptotrader/database" + dbPSQL "github.com/thrasher-corp/gocryptotrader/database/drivers/postgres" + dbsqlite3 "github.com/thrasher-corp/gocryptotrader/database/drivers/sqlite3" + "github.com/thrasher-corp/gocryptotrader/database/repository" + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/urfave/cli/v2" +) + +var ( + dbConn *database.Instance +) + +func load(c *cli.Context) error { + var conf config.Config + err := conf.LoadConfig(c.String("config"), true) + if err != nil { + return err + } + + if !conf.Database.Enabled { + return database.ErrDatabaseSupportDisabled + } + + err = openDBConnection(c, conf.Database.Driver) + if err != nil { + return err + } + + drv := repository.GetSQLDialect() + if drv == database.DBSQLite || drv == database.DBSQLite3 { + fmt.Printf("Database file: %s\n", conf.Database.Database) + } else { + fmt.Printf("Connected to: %s\n", conf.Database.Host) + } + + return nil +} + +func openDBConnection(c *cli.Context, driver string) (err error) { + if c.IsSet("verbose") { + boil.DebugMode = true + } + if driver == database.DBPostgreSQL { + dbConn, err = dbPSQL.Connect() + if err != nil { + return fmt.Errorf("database failed to connect: %v, some features that utilise a database will be unavailable", err) + } + return nil + } else if driver == database.DBSQLite || driver == database.DBSQLite3 { + dbConn, err = dbsqlite3.Connect() + if err != nil { + return fmt.Errorf("database failed to connect: %v, some features that utilise a database will be unavailable", err) + } + return nil + } + return errors.New("no connection established") +} diff --git a/cmd/dbseed/dbseed_test.go b/cmd/dbseed/dbseed_test.go new file mode 100644 index 00000000..253a9ded --- /dev/null +++ b/cmd/dbseed/dbseed_test.go @@ -0,0 +1,47 @@ +package main + +import ( + "flag" + "path/filepath" + "testing" + + "github.com/thrasher-corp/gocryptotrader/config" + "github.com/thrasher-corp/gocryptotrader/core" + "github.com/urfave/cli/v2" +) + +var ( + testConfig = filepath.Join("..", "..", "testdata", "configtest.json") + testApp = &cli.App{ + Name: "dbseed", + Version: core.Version(false), + EnableBashCompletion: true, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "config", + Value: testConfig, + Usage: "config file to load", + }, + &cli.BoolFlag{ + Name: "verbose", + Usage: "toggle verbose output", + Value: true, + }, + }, + Commands: []*cli.Command{ + seedExchangeCommand, + seedCandleCommand, + }, + } +) + +func TestLoad(t *testing.T) { + config.TestBypass = true + fs := &flag.FlagSet{} + fs.String("config", testConfig, "") + newCtx := cli.NewContext(testApp, fs, &cli.Context{}) + err := load(newCtx) + if err != nil { + t.Fatal(err) + } +} diff --git a/cmd/dbseed/exchange.go b/cmd/dbseed/exchange.go new file mode 100644 index 00000000..aa94cccf --- /dev/null +++ b/cmd/dbseed/exchange.go @@ -0,0 +1,132 @@ +package main + +import ( + "fmt" + "log" + "os" + + exchangeDB "github.com/thrasher-corp/gocryptotrader/database/repository/exchange" + exchange "github.com/thrasher-corp/gocryptotrader/exchanges" + "github.com/urfave/cli/v2" +) + +var seedExchangeCommand = &cli.Command{ + Name: "exchange", + Usage: "seed exchange data", + Subcommands: []*cli.Command{ + { + Name: "file", + Usage: "seed exchange data from a file", + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "filename", + Usage: "CSV file to load exchanges from", + TakesFile: true, + FilePath: workingDir, + }, + }, + Action: seedExchangeFromFile, + }, + { + Name: "add", + Usage: "add a single exchange", + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "name", + Usage: "name", + }, + }, + Action: addSingleExchange, + }, + { + Name: "default", + Usage: "seed exchange from default list", + Action: seedExchangeFromDefaultList, + }, + }, +} + +func seedExchangeFromDefaultList(c *cli.Context) error { + err := load(c) + if err != nil { + return err + } + var allExchanges []exchangeDB.Details + for x := range exchange.Exchanges { + allExchanges = append(allExchanges, exchangeDB.Details{ + Name: exchange.Exchanges[x], + }) + } + err = exchangeDB.InsertMany(allExchanges) + if err != nil { + return err + } + fmt.Println("command completed successfully") + return nil +} + +func seedExchangeFromFile(c *cli.Context) error { + if c.NumFlags() == 0 && c.NArg() == 0 { + return cli.ShowSubcommandHelp(c) + } + + var fileName string + if c.IsSet("filename") { + fileName = c.String("filename") + } else if c.Args().Get(0) != "" { + fileName = c.Args().Get(0) + } + + _, err := os.Stat(fileName) + if err != nil { + return err + } + + err = load(c) + if err != nil { + return err + } + + exchangeList, err := exchangeDB.LoadCSV(fileName) + if err != nil { + return err + } + err = exchangeDB.InsertMany(exchangeList) + if err != nil { + return err + } + for x := range exchangeList { + fmt.Printf("Added exchange: %v\n", exchangeList[x].Name) + } + + return nil +} + +func addSingleExchange(c *cli.Context) error { + if c.NumFlags() == 0 && c.NArg() == 0 { + return cli.ShowSubcommandHelp(c) + } + + var exchangeName string + if c.IsSet("name") { + exchangeName = c.String("name") + } else if c.Args().Get(0) != "" { + exchangeName = c.Args().Get(0) + } + + err := load(c) + if err != nil { + return err + } + + err = exchangeDB.Insert(exchangeDB.Details{ + Name: exchangeName, + }) + + if err != nil { + return err + } + + log.Printf("Added new exchange: %v", exchangeName) + return nil +} diff --git a/cmd/dbseed/main.go b/cmd/dbseed/main.go new file mode 100644 index 00000000..c232ba08 --- /dev/null +++ b/cmd/dbseed/main.go @@ -0,0 +1,67 @@ +package main + +import ( + "fmt" + "log" + "os" + "path/filepath" + + "github.com/thrasher-corp/gocryptotrader/config" + "github.com/thrasher-corp/gocryptotrader/core" + "github.com/urfave/cli/v2" +) + +var ( + app = &cli.App{ + Name: "dbseed", + Version: core.Version(false), + EnableBashCompletion: true, + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "config", + Value: config.DefaultFilePath(), + Usage: "config file to load", + Destination: &configFile, + }, + &cli.BoolFlag{ + Name: "verbose", + Usage: "toggle verbose output", + Destination: &verbose, + }, + }, + Commands: []*cli.Command{ + seedExchangeCommand, + seedCandleCommand, + }, + } + workingDir string + configFile string + verbose bool +) + +func main() { + var err error + workingDir, err = os.Getwd() + if err != nil { + log.Println("error getting current working path") + workingDir = filepath.Join(".") + } + + fmt.Println("GoCryptoTrader database seeding tool") + fmt.Println(core.Copyright) + fmt.Println() + + err = app.Run(os.Args) + if err != nil { + log.Fatal(err) + } + + if dbConn != nil { + if dbConn.SQL != nil { + err = dbConn.SQL.Close() + if err != nil { + log.Println(err) + } + } + } +} diff --git a/cmd/gctcli/commands.go b/cmd/gctcli/commands.go index f9374ca9..359ccda5 100644 --- a/cmd/gctcli/commands.go +++ b/cmd/gctcli/commands.go @@ -3905,6 +3905,14 @@ var getHistoricCandlesExtendedCommand = cli.Command{ Value: time.Now().Format(common.SimpleTimeFormat), Destination: &endTime, }, + cli.BoolFlag{ + Name: "sync", + Usage: "", + }, + cli.BoolFlag{ + Name: "db", + Usage: "source data from database ", + }, }, } @@ -3970,6 +3978,16 @@ func getHistoricCandlesExtended(c *cli.Context) error { } } + var sync bool + if c.IsSet("sync") { + sync = c.Bool("sync") + } + + var db bool + if c.IsSet("db") { + db = c.Bool("db") + } + conn, err := setupClient() if err != nil { return err @@ -4006,6 +4024,8 @@ func getHistoricCandlesExtended(c *cli.Context) error { End: e.Unix(), TimeInterval: int64(candleInterval), ExRequest: true, + Sync: sync, + UseDb: db, }) if err != nil { return err diff --git a/cmd/gen_sqlboiler_config/main.go b/cmd/gen_sqlboiler_config/main.go index 37567780..2f1aa76e 100644 --- a/cmd/gen_sqlboiler_config/main.go +++ b/cmd/gen_sqlboiler_config/main.go @@ -96,5 +96,5 @@ func convertGCTtoSQLBoilerConfig(c *database.Config) { } func convertDBName(in string) string { - return filepath.Join(common.GetDefaultDataDir(runtime.GOOS), "/database", in) + return filepath.Join(common.GetDefaultDataDir(runtime.GOOS), "database", in) } diff --git a/config/config.go b/config/config.go index 4f3bb2af..656aafd5 100644 --- a/config/config.go +++ b/config/config.go @@ -1362,7 +1362,7 @@ func (c *Config) checkDatabaseConfig() error { } if c.Database.Driver == database.DBSQLite || c.Database.Driver == database.DBSQLite3 { - databaseDir := filepath.Join(common.GetDefaultDataDir(runtime.GOOS), "/database") + databaseDir := filepath.Join(common.GetDefaultDataDir(runtime.GOOS), "database") err := common.CreateDir(databaseDir) if err != nil { return err @@ -1484,7 +1484,7 @@ func GetFilePath(configfile string) (string, error) { return configfile, nil } - if flag.Lookup("test.v") != nil && !testBypass { + if flag.Lookup("test.v") != nil && !TestBypass { return TestFile, nil } diff --git a/config/config_test.go b/config/config_test.go index 82a814c4..39985340 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -1717,7 +1717,7 @@ func TestGetFilePath(t *testing.T) { if result != expected { t.Errorf("TestGetFilePath: expected %s got %s", expected, result) } - testBypass = true + TestBypass = true } func TestCheckRemoteControlConfig(t *testing.T) { diff --git a/config/config_types.go b/config/config_types.go index 1548bd03..57e08dcf 100644 --- a/config/config_types.go +++ b/config/config_types.go @@ -69,7 +69,7 @@ const ( var ( Cfg Config IsInitialSetup bool - testBypass bool + TestBypass bool m sync.Mutex ) diff --git a/database/README.md b/database/README.md index d5f04ac1..f637f33b 100644 --- a/database/README.md +++ b/database/README.md @@ -106,6 +106,9 @@ dbmigrate -command "up" dbmigrate provides a -migrationdir flag override to tell it what path to look in for migrations +###### Note: its highly recommended to backup any data before running migrations against a production database especially if you are running SQLite due to alter table limitations + + ##### Adding a new model Model's are generated using [SQLBoiler](https://github.com/thrasher-corp/sqlboiler) A helper tool has been made located in gen_sqlboiler_config that will parse your GoCryptoTrader config and output a SQLBoiler config @@ -123,7 +126,6 @@ along with the location of the sqlboiler generated config -outdir "~/.gocryptotrader/" ``` - Generate a new model that gets placed in ./database/models/ folder Linux: @@ -144,6 +146,10 @@ And in the contrib/sqlboiler.cmd for windows users ##### Adding a Repository + Create Repository directory in github.com/thrasher-corp/gocryptotrader/database/repository/ + +##### DBSeed helper +A helper tool [cmd/dbseed](../cmd/dbseed/README.md) has been created for assisting with data migration + ## Contribution Please feel free to submit any pull requests or suggest any desired features to be added. diff --git a/database/database_types.go b/database/database_types.go index 566103b1..432f1d0c 100644 --- a/database/database_types.go +++ b/database/database_types.go @@ -53,4 +53,6 @@ const ( DBSQLite3 = "sqlite3" // DBPostgreSQL const string for PostgreSQL across code base DBPostgreSQL = "postgres" + // DBInvalidDriver const string for invalid driver + DBInvalidDriver = "invalid driver" ) diff --git a/database/migrations/20200518131133_exchange/postgres.sql b/database/migrations/20200518131133_exchange/postgres.sql new file mode 100644 index 00000000..05aa3810 --- /dev/null +++ b/database/migrations/20200518131133_exchange/postgres.sql @@ -0,0 +1,12 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +CREATE TABLE IF NOT EXISTS exchange +( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + name varchar(255) NOT NULL +); +CREATE UNIQUE INDEX IF NOT EXISTS "index_name_on_exchange" ON exchange using btree(name); + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +DROP TABLE exchange; \ No newline at end of file diff --git a/database/migrations/20200518131133_exchange/sqlite3.sql b/database/migrations/20200518131133_exchange/sqlite3.sql new file mode 100644 index 00000000..90c2a6d1 --- /dev/null +++ b/database/migrations/20200518131133_exchange/sqlite3.sql @@ -0,0 +1,11 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +CREATE TABLE "exchange" ( + id text not null primary key, + name text not null, + unique(name) ON CONFLICT IGNORE +); + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +DROP TABLE "exchange"; \ No newline at end of file diff --git a/database/migrations/20200520103816_candle/postgres.sql b/database/migrations/20200520103816_candle/postgres.sql new file mode 100644 index 00000000..3eb9a989 --- /dev/null +++ b/database/migrations/20200520103816_candle/postgres.sql @@ -0,0 +1,22 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +CREATE TABLE IF NOT EXISTS candle +( + ID uuid PRIMARY KEY DEFAULT gen_random_uuid(), + exchange_id uuid REFERENCES exchange(id) NOT NULL, + Base varchar(30) NOT NULL, + Quote varchar(30) NOT NULL, + Interval varchar(30) NOT NULL, + Timestamp TIMESTAMPTZ NOT NULL, + Open DOUBLE PRECISION NOT NULL, + High DOUBLE PRECISION NOT NULL, + Low DOUBLE PRECISION NOT NULL, + Close DOUBLE PRECISION NOT NULL, + Volume DOUBLE PRECISION NOT NULL, + unique(Timestamp, exchange_id, Base, Quote, Interval) +); + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +DROP TABLE candle; + diff --git a/database/migrations/20200520103816_candle/sqlite3.sql b/database/migrations/20200520103816_candle/sqlite3.sql new file mode 100644 index 00000000..ad14cd87 --- /dev/null +++ b/database/migrations/20200520103816_candle/sqlite3.sql @@ -0,0 +1,19 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +CREATE TABLE "candle" ( + id text not null primary key, + exchange_id uuid REFERENCES exchange(id), + Base text NOT NULL, + Quote text NOT NULL, + Interval text NOT NULL, + Timestamp TIMESTAMP NOT NULL, + Open REAL NOT NULL, + High REAL NOT NULL, + Low REAL NOT NULL, + Close REAL NOT NULL, + Volume REAL NOT NULL, + unique(Timestamp, exchange_id, Base, Quote, Interval) ON CONFLICT IGNORE +); +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +DROP TABLE "candle"; \ No newline at end of file diff --git a/database/migrations/20200715122118_asset/postgres.sql b/database/migrations/20200715122118_asset/postgres.sql new file mode 100644 index 00000000..bb90e845 --- /dev/null +++ b/database/migrations/20200715122118_asset/postgres.sql @@ -0,0 +1,6 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +ALTER TABLE candle ADD COLUMN asset VARCHAR(255) NOT NULL; +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +ALTER TABLE candle DROP COLUMN asset; diff --git a/database/migrations/20200715122118_asset/sqlite3.sql b/database/migrations/20200715122118_asset/sqlite3.sql new file mode 100644 index 00000000..25b903d4 --- /dev/null +++ b/database/migrations/20200715122118_asset/sqlite3.sql @@ -0,0 +1,23 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +ALTER TABLE candle ADD COLUMN asset text; +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +CREATE TABLE "candle_new" ( + id text not null primary key, + exchange_id uuid REFERENCES exchange(id), + Base text NOT NULL, + Quote text NOT NULL, + Interval text NOT NULL, + Timestamp TIMESTAMP NOT NULL, + Open REAL NOT NULL, + High REAL NOT NULL, + Low REAL NOT NULL, + Close REAL NOT NULL, + Volume REAL NOT NULL, + unique(Timestamp, exchange_id, Base, Quote, Interval) ON CONFLICT IGNORE +); + +INSERT INTO candle_new SELECT id, exchange_id, Base, Quote, Interval, Timestamp, Open, High, Low, Close, Volume FROM candle; +DROP TABLE candle; +ALTER TABLE candle_new RENAME TO candle; \ No newline at end of file diff --git a/database/migrations/20200715123925_update_withdrawal_history_exchange/postgres.sql b/database/migrations/20200715123925_update_withdrawal_history_exchange/postgres.sql new file mode 100644 index 00000000..4e107393 --- /dev/null +++ b/database/migrations/20200715123925_update_withdrawal_history_exchange/postgres.sql @@ -0,0 +1,14 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +INSERT INTO exchange(name) SELECT exchange from withdrawal_history; +ALTER TABLE withdrawal_history ADD COLUMN exchange_name_id UUID REFERENCES exchange(id); +UPDATE withdrawal_history SET exchange_name_id = r.ID FROM (SELECT * from exchange) as r WHERE exchange = r.name; +ALTER TABLE withdrawal_history DROP COLUMN exchange; + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +ALTER TABLE withdrawal_history ADD COLUMN exchange TEXT; +UPDATE withdrawal_history SET exchange = r.name FROM (SELECT * from exchange) as r WHERE exchange_name_id = r.id; +ALTER TABLE withdrawal_history ALTER COLUMN exchange SET NOT NULL; +ALTER TABLE withdrawal_history DROP CONSTRAINT withdrawal_history_exchange_name_id_fkey; +ALTER TABLE withdrawal_history DROP COLUMN exchange_name_id; diff --git a/database/migrations/20200715123925_update_withdrawal_history_exchange/sqlite3.sql b/database/migrations/20200715123925_update_withdrawal_history_exchange/sqlite3.sql new file mode 100644 index 00000000..eea0142b --- /dev/null +++ b/database/migrations/20200715123925_update_withdrawal_history_exchange/sqlite3.sql @@ -0,0 +1,84 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +INSERT INTO exchange(id, name) +SELECT + lower(hex( randomblob(4)) || '-' || hex( randomblob(2)) || '-' || '4' || substr( hex( randomblob(2)), 2) || '-' + || substr('AB89', 1 + (abs(random()) % 4) , 1) || + substr(hex(randomblob(2)), 2) || '-' || hex(randomblob(6))), exchange + from withdrawal_history; + +ALTER TABLE withdrawal_history ADD COLUMN exchange_name_id; + +UPDATE withdrawal_history +SET + exchange_name_id = (SELECT id FROM exchange WHERE withdrawal_history.exchange = lower(name)) +WHERE + EXISTS( + SELECT * + FROM exchange + WHERE lower("exchange".name) = withdrawal_history.exchange + ); + +CREATE TABLE IF NOT EXISTS withdrawal_history_new +( + id text PRIMARY KEY NOT NULL, + exchange_name_id text, + exchange_id text NOT NULL, + status text NOT NULL, + currency text NOT NULL, + amount real NOT NULL, + description text, + withdraw_type integer NOT NULL, + created_at timestamp NOT NULL default CURRENT_TIMESTAMP, + updated_at timestamp NOT NULL default CURRENT_TIMESTAMP, + FOREIGN KEY(exchange_name_id) REFERENCES exchange(id) ON DELETE RESTRICT +); +INSERT INTO + withdrawal_history_new (id, exchange_name_id, exchange_id, status, currency, amount, description, withdraw_type, created_at, updated_at) +SELECT + id, exchange_name_id, exchange_id, status, currency, amount, description, withdraw_type, created_at, updated_at +FROM + withdrawal_history; + +DROP TABLE withdrawal_history; + +ALTER TABLE withdrawal_history_new RENAME TO withdrawal_history; + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +ALTER TABLE withdrawal_history ADD COLUMN exchange; + +UPDATE withdrawal_history +SET + exchange = (SELECT name FROM exchange WHERE withdrawal_history.exchange_name_id = id) +WHERE + EXISTS( + SELECT * + FROM exchange + WHERE exchange.id = withdrawal_history.exchange_name_id + ); + +CREATE TABLE IF NOT EXISTS withdrawal_history_new +( + id text PRIMARY KEY NOT NULL, + exchange text NOT NULL, + exchange_id text NOT NULL, + status text NOT NULL, + currency text NOT NULL, + amount real NOT NULL, + description text, + withdraw_type integer NOT NULL, + created_at timestamp NOT NULL default CURRENT_TIMESTAMP, + updated_at timestamp NOT NULL default CURRENT_TIMESTAMP +); + +INSERT INTO + withdrawal_history_new (id, exchange, exchange_id, status, currency, amount, description, withdraw_type, created_at, updated_at) +SELECT + id, exchange, exchange_id, status, currency, amount, description, withdraw_type, created_at, updated_at +FROM + withdrawal_history; + +DROP TABLE withdrawal_history; + +ALTER TABLE withdrawal_history_new RENAME TO withdrawal_history; diff --git a/database/migrations/20200805131503_update_candle_interval_type/postgres.sql b/database/migrations/20200805131503_update_candle_interval_type/postgres.sql new file mode 100644 index 00000000..436c889b --- /dev/null +++ b/database/migrations/20200805131503_update_candle_interval_type/postgres.sql @@ -0,0 +1,35 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +UPDATE candle SET interval = replace (candle.interval, '15s', '15'); +UPDATE candle SET interval = replace (candle.interval, '1m', '60'); +UPDATE candle SET interval = replace (candle.interval, '3m', '180'); +UPDATE candle SET interval = replace (candle.interval, '5m', '300'); +UPDATE candle SET interval = replace (candle.interval, '10m', '600'); +UPDATE candle SET interval = replace (candle.interval, '15m', '900'); +UPDATE candle SET interval = replace (candle.interval, '30m', '1800'); +UPDATE candle SET interval = replace (candle.interval, '1h', '3600'); +UPDATE candle SET interval = replace (candle.interval, '6h', '21600'); +UPDATE candle SET interval = replace (candle.interval, '8h', '28800'); +UPDATE candle SET interval = replace (candle.interval, '12h', '43200'); +UPDATE candle SET interval = replace (candle.interval, '24h', '86400'); +UPDATE candle SET interval = replace (candle.interval, '3d', '259200'); +UPDATE candle SET interval = replace (candle.interval, '7w', '604800'); +UPDATE candle SET interval = replace (candle.interval, '15d', '1296000'); +UPDATE candle SET interval = replace (candle.interval, '1w', '604800'); +UPDATE candle SET interval = replace (candle.interval, '2W', '1209600'); +UPDATE candle SET interval = replace (candle.interval, '1M', '2678400'); +UPDATE candle SET interval = replace (candle.interval, '1Y', '31536000'); +UPDATE candle SET interval = replace (candle.interval, '1d', '86400'); +UPDATE candle SET interval = replace (candle.interval, '72h', '259200'); +UPDATE candle SET interval = replace (candle.interval, '168h', '604800'); +UPDATE candle SET interval = replace (candle.interval, '360h', '1296000'); +UPDATE candle SET interval = replace (candle.interval, '336h', '1209600'); +UPDATE candle SET interval = replace (candle.interval, '744h', '2678400'); +UPDATE candle SET interval = replace (candle.interval, '8760h', '31536000'); +UPDATE candle SET interval = replace (candle.interval, '4h', '14400'); +UPDATE candle SET interval = replace (candle.interval, '2h', '7200'); +alter table candle alter column interval type bigint using interval::bigint; + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +alter table candle alter column interval type varchar(30) using interval::varchar(30); \ No newline at end of file diff --git a/database/migrations/20200805131503_update_candle_interval_type/sqlite3.sql b/database/migrations/20200805131503_update_candle_interval_type/sqlite3.sql new file mode 100644 index 00000000..4fdd3b1e --- /dev/null +++ b/database/migrations/20200805131503_update_candle_interval_type/sqlite3.sql @@ -0,0 +1,34 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +UPDATE candle SET interval = replace (candle.interval, '15s', '15'); +UPDATE candle SET interval = replace (candle.interval, '1m', '60'); +UPDATE candle SET interval = replace (candle.interval, '3m', '180'); +UPDATE candle SET interval = replace (candle.interval, '5m', '300'); +UPDATE candle SET interval = replace (candle.interval, '10m', '600'); +UPDATE candle SET interval = replace (candle.interval, '15m', '900'); +UPDATE candle SET interval = replace (candle.interval, '30m', '1800'); +UPDATE candle SET interval = replace (candle.interval, '1h', '3600'); +UPDATE candle SET interval = replace (candle.interval, '6h', '21600'); +UPDATE candle SET interval = replace (candle.interval, '8h', '28800'); +UPDATE candle SET interval = replace (candle.interval, '12h', '43200'); +UPDATE candle SET interval = replace (candle.interval, '24h', '86400'); +UPDATE candle SET interval = replace (candle.interval, '3d', '259200'); +UPDATE candle SET interval = replace (candle.interval, '7w', '604800'); +UPDATE candle SET interval = replace (candle.interval, '15d', '1296000'); +UPDATE candle SET interval = replace (candle.interval, '1w', '604800'); +UPDATE candle SET interval = replace (candle.interval, '2W', '1209600'); +UPDATE candle SET interval = replace (candle.interval, '1M', '2678400'); +UPDATE candle SET interval = replace (candle.interval, '1Y', '31536000'); +UPDATE candle SET interval = replace (candle.interval, '1d', '86400'); +UPDATE candle SET interval = replace (candle.interval, '72h', '259200'); +UPDATE candle SET interval = replace (candle.interval, '168h', '604800'); +UPDATE candle SET interval = replace (candle.interval, '360h', '1296000'); +UPDATE candle SET interval = replace (candle.interval, '336h', '1209600'); +UPDATE candle SET interval = replace (candle.interval, '744h', '2678400'); +UPDATE candle SET interval = replace (candle.interval, '8760h', '31536000'); +UPDATE candle SET interval = replace (candle.interval, '4h', '14400'); +UPDATE candle SET interval = replace (candle.interval, '2h', '7200'); + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +-- Nothing to run for sqlite as we leave the type as text \ No newline at end of file diff --git a/database/migrations/20200805151208_update_candle_add_asset_to_uniq_index/postgres.sql b/database/migrations/20200805151208_update_candle_add_asset_to_uniq_index/postgres.sql new file mode 100644 index 00000000..004733a5 --- /dev/null +++ b/database/migrations/20200805151208_update_candle_add_asset_to_uniq_index/postgres.sql @@ -0,0 +1,6 @@ +-- +goose Up +ALTER TABLE candle DROP CONSTRAINT candle_timestamp_exchange_id_base_quote_interval_key; +ALTER TABLE candle ADD CONSTRAINT candle_timestamp_exchange_id_base_quote_interval_asset_key UNIQUE(Timestamp, exchange_id, Base, Quote, Interval, asset); +-- +goose Down +ALTER TABLE candle DROP CONSTRAINT candle_timestamp_exchange_id_base_quote_interval_asset_key; +ALTER TABLE candle ADD CONSTRAINT candle_timestamp_exchange_id_base_quote_interval_key UNIQUE(Timestamp, exchange_id, Base, Quote, Interval); \ No newline at end of file diff --git a/database/migrations/20200805151208_update_candle_add_asset_to_uniq_index/sqlite3.sql b/database/migrations/20200805151208_update_candle_add_asset_to_uniq_index/sqlite3.sql new file mode 100644 index 00000000..dad08350 --- /dev/null +++ b/database/migrations/20200805151208_update_candle_add_asset_to_uniq_index/sqlite3.sql @@ -0,0 +1,39 @@ +-- +goose Up +CREATE TABLE "candle_new" ( + id text not null primary key, + exchange_id uuid REFERENCES exchange(id), + Base text NOT NULL, + Quote text NOT NULL, + Interval text NOT NULL, + Timestamp TIMESTAMP NOT NULL, + Open REAL NOT NULL, + High REAL NOT NULL, + Low REAL NOT NULL, + Close REAL NOT NULL, + Volume REAL NOT NULL, + Asset text, + unique(Timestamp, exchange_id, Base, Quote, Interval, asset) ON CONFLICT IGNORE +); +INSERT INTO candle_new SELECT id, exchange_id, Base, Quote, Interval, Timestamp, Open, High, Low, Close, Volume, Asset FROM candle; +DROP TABLE candle; +ALTER TABLE candle_new RENAME TO candle; +-- +goose Down +CREATE TABLE "candle_new" ( + id text not null primary key, + exchange_id uuid REFERENCES exchange(id), + Base text NOT NULL, + Quote text NOT NULL, + Interval text NOT NULL, + Timestamp TIMESTAMP NOT NULL, + Open REAL NOT NULL, + High REAL NOT NULL, + Low REAL NOT NULL, + Close REAL NOT NULL, + Volume REAL NOT NULL, + Asset TEXT, + unique(Timestamp, exchange_id, Base, Quote, Interval) ON CONFLICT IGNORE +); + +INSERT INTO candle_new SELECT id, exchange_id, Base, Quote, Interval, Timestamp, Open, High, Low, Close, Volume, Asset FROM candle; +DROP TABLE candle; +ALTER TABLE candle_new RENAME TO candle; diff --git a/database/migrations/20200814113829_update_withdrawal_history_add_not_null_to_exchange_name_id/postgres.sql b/database/migrations/20200814113829_update_withdrawal_history_add_not_null_to_exchange_name_id/postgres.sql new file mode 100644 index 00000000..7c406c39 --- /dev/null +++ b/database/migrations/20200814113829_update_withdrawal_history_add_not_null_to_exchange_name_id/postgres.sql @@ -0,0 +1,7 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +ALTER TABLE withdrawal_history ALTER COLUMN exchange_name_id SET NOT NULL; + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +ALTER TABLE withdrawal_history ALTER COLUMN exchange_name_id SET NULL; diff --git a/database/migrations/20200814113829_update_withdrawal_history_add_not_null_to_exchange_name_id/sqlite3.sql b/database/migrations/20200814113829_update_withdrawal_history_add_not_null_to_exchange_name_id/sqlite3.sql new file mode 100644 index 00000000..f54c076f --- /dev/null +++ b/database/migrations/20200814113829_update_withdrawal_history_add_not_null_to_exchange_name_id/sqlite3.sql @@ -0,0 +1,51 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +CREATE TABLE IF NOT EXISTS withdrawal_history_new +( + id text PRIMARY KEY NOT NULL, + exchange_name_id text NOT NULL, + exchange_id text NOT NULL, + status text NOT NULL, + currency text NOT NULL, + amount real NOT NULL, + description text, + withdraw_type integer NOT NULL, + created_at timestamp NOT NULL default CURRENT_TIMESTAMP, + updated_at timestamp NOT NULL default CURRENT_TIMESTAMP, + FOREIGN KEY(exchange_name_id) REFERENCES exchange(id) ON DELETE RESTRICT +); +INSERT INTO + withdrawal_history_new (id, exchange_name_id, exchange_id, status, currency, amount, description, withdraw_type, created_at, updated_at) +SELECT + id, exchange_name_id, exchange_id, status, currency, amount, description, withdraw_type, created_at, updated_at +FROM + withdrawal_history; + +DROP TABLE withdrawal_history; +ALTER TABLE withdrawal_history_new RENAME TO withdrawal_history; + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +CREATE TABLE IF NOT EXISTS withdrawal_history_new +( + id text PRIMARY KEY NOT NULL, + exchange_name_id text, + exchange_id text NOT NULL, + status text NOT NULL, + currency text NOT NULL, + amount real NOT NULL, + description text, + withdraw_type integer NOT NULL, + created_at timestamp NOT NULL default CURRENT_TIMESTAMP, + updated_at timestamp NOT NULL default CURRENT_TIMESTAMP +); + +INSERT INTO + withdrawal_history_new (id, exchange_name_id, exchange_id, status, currency, amount, description, withdraw_type, created_at, updated_at) +SELECT + id, exchange_name_id, exchange_id, status, currency, amount, description, withdraw_type, created_at, updated_at +FROM + withdrawal_history; + +DROP TABLE withdrawal_history; +ALTER TABLE withdrawal_history_new RENAME TO withdrawal_history; diff --git a/database/migrations/20200814121412_update_candle_add_not_null_to_asset/postgres.sql b/database/migrations/20200814121412_update_candle_add_not_null_to_asset/postgres.sql new file mode 100644 index 00000000..19e08f3d --- /dev/null +++ b/database/migrations/20200814121412_update_candle_add_not_null_to_asset/postgres.sql @@ -0,0 +1,7 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. +ALTER TABLE candle ALTER COLUMN asset SET NOT NULL; + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. +ALTER TABLE candle ALTER COLUMN aseet SET NULL; diff --git a/database/migrations/20200814121412_update_candle_add_not_null_to_asset/sqlite3.sql b/database/migrations/20200814121412_update_candle_add_not_null_to_asset/sqlite3.sql new file mode 100644 index 00000000..d31e9510 --- /dev/null +++ b/database/migrations/20200814121412_update_candle_add_not_null_to_asset/sqlite3.sql @@ -0,0 +1,39 @@ +-- +goose Up +CREATE TABLE "candle_new" ( + id text not null primary key, + exchange_id uuid REFERENCES exchange(id), + Base text NOT NULL, + Quote text NOT NULL, + Interval text NOT NULL, + Timestamp TIMESTAMP NOT NULL, + Open REAL NOT NULL, + High REAL NOT NULL, + Low REAL NOT NULL, + Close REAL NOT NULL, + Volume REAL NOT NULL, + Asset text NOT NULL, + unique(Timestamp, exchange_id, Base, Quote, Interval, Asset) ON CONFLICT IGNORE +); +INSERT INTO candle_new SELECT id, exchange_id, Base, Quote, Interval, Timestamp, Open, High, Low, Close, Volume, Asset FROM candle; +DROP TABLE candle; +ALTER TABLE candle_new RENAME TO candle; +-- +goose Down +CREATE TABLE "candle_new" ( + id text not null primary key, + exchange_id uuid REFERENCES exchange(id), + Base text NOT NULL, + Quote text NOT NULL, + Interval text NOT NULL, + Timestamp TIMESTAMP NOT NULL, + Open REAL NOT NULL, + High REAL NOT NULL, + Low REAL NOT NULL, + Close REAL NOT NULL, + Volume REAL NOT NULL, + Asset TEXT, + unique(Timestamp, exchange_id, Base, Quote, Interval, Asset) ON CONFLICT IGNORE +); + +INSERT INTO candle_new SELECT id, exchange_id, Base, Quote, Interval, Timestamp, Open, High, Low, Close, Volume, Asset FROM candle; +DROP TABLE candle; +ALTER TABLE candle_new RENAME TO candle; diff --git a/database/migrations/20200819150038_update_candle_exchange_id_to_exchange_name_id/postgres.sql b/database/migrations/20200819150038_update_candle_exchange_id_to_exchange_name_id/postgres.sql new file mode 100644 index 00000000..c01a1c49 --- /dev/null +++ b/database/migrations/20200819150038_update_candle_exchange_id_to_exchange_name_id/postgres.sql @@ -0,0 +1,10 @@ +-- +goose Up +ALTER TABLE candle DROP CONSTRAINT candle_timestamp_exchange_id_base_quote_interval_asset_key; +ALTER TABLE candle RENAME COLUMN exchange_id TO exchange_name_id; +ALTER TABLE candle ALTER COLUMN exchange_name_id SET NOT NULL; +ALTER TABLE candle ADD CONSTRAINT candle_timestamp_exchange_id_base_quote_interval_asset_key UNIQUE(Timestamp, exchange_name_id, Base, Quote, Interval, asset); +-- +goose Down +ALTER TABLE candle DROP CONSTRAINT candle_timestamp_exchange_id_base_quote_interval_asset_key; +ALTER TABLE candle RENAME COLUMN exchange_name_id TO exchange_id; +ALTER TABLE candle ALTER COLUMN exchange_id SET NOT NULL; +ALTER TABLE candle ADD CONSTRAINT candle_timestamp_exchange_id_base_quote_interval_asset_key UNIQUE(Timestamp, exchange_id, Base, Quote, Interval); \ No newline at end of file diff --git a/database/migrations/20200819150038_update_candle_exchange_id_to_exchange_name_id/sqlite3.sql b/database/migrations/20200819150038_update_candle_exchange_id_to_exchange_name_id/sqlite3.sql new file mode 100644 index 00000000..9dd7668f --- /dev/null +++ b/database/migrations/20200819150038_update_candle_exchange_id_to_exchange_name_id/sqlite3.sql @@ -0,0 +1,39 @@ +-- +goose Up +CREATE TABLE "candle_new" ( + id text not null primary key, + exchange_name_id uuid REFERENCES exchange(id) NOT NULL, + Base text NOT NULL, + Quote text NOT NULL, + Interval text NOT NULL, + Timestamp TIMESTAMP NOT NULL, + Open REAL NOT NULL, + High REAL NOT NULL, + Low REAL NOT NULL, + Close REAL NOT NULL, + Volume REAL NOT NULL, + Asset text NOT NULL, + unique(Timestamp, exchange_name_id, Base, Quote, Interval, Asset) ON CONFLICT IGNORE +); +INSERT INTO candle_new SELECT id, exchange_id, Base, Quote, Interval, Timestamp, Open, High, Low, Close, Volume, Asset FROM candle; +DROP TABLE candle; +ALTER TABLE candle_new RENAME TO candle; +-- +goose Down +CREATE TABLE "candle_new" ( + id text not null primary key, + exchange_id uuid REFERENCES exchange(id), + Base text NOT NULL, + Quote text NOT NULL, + Interval text NOT NULL, + Timestamp TIMESTAMP NOT NULL, + Open REAL NOT NULL, + High REAL NOT NULL, + Low REAL NOT NULL, + Close REAL NOT NULL, + Volume REAL NOT NULL, + Asset TEXT, + unique(Timestamp, exchange_id, Base, Quote, Interval, Asset) ON CONFLICT IGNORE +); + +INSERT INTO candle_new SELECT id, exchange_name_id, Base, Quote, Interval, Timestamp, Open, High, Low, Close, Volume, Asset FROM candle; +DROP TABLE candle; +ALTER TABLE candle_new RENAME TO candle; diff --git a/database/models/postgres/boil_suites_test.go b/database/models/postgres/boil_suites_test.go index b801080a..912e3d39 100644 --- a/database/models/postgres/boil_suites_test.go +++ b/database/models/postgres/boil_suites_test.go @@ -13,77 +13,77 @@ import "testing" // Separating the tests thusly grants avoidance of Postgres deadlocks. func TestParent(t *testing.T) { t.Run("AuditEvents", testAuditEvents) + t.Run("Exchanges", testExchanges) t.Run("Scripts", testScripts) - t.Run("WithdrawalHistories", testWithdrawalHistories) } func TestDelete(t *testing.T) { t.Run("AuditEvents", testAuditEventsDelete) + t.Run("Exchanges", testExchangesDelete) t.Run("Scripts", testScriptsDelete) - t.Run("WithdrawalHistories", testWithdrawalHistoriesDelete) } func TestQueryDeleteAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsQueryDeleteAll) + t.Run("Exchanges", testExchangesQueryDeleteAll) t.Run("Scripts", testScriptsQueryDeleteAll) - t.Run("WithdrawalHistories", testWithdrawalHistoriesQueryDeleteAll) } func TestSliceDeleteAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsSliceDeleteAll) + t.Run("Exchanges", testExchangesSliceDeleteAll) t.Run("Scripts", testScriptsSliceDeleteAll) - t.Run("WithdrawalHistories", testWithdrawalHistoriesSliceDeleteAll) } func TestExists(t *testing.T) { t.Run("AuditEvents", testAuditEventsExists) + t.Run("Exchanges", testExchangesExists) t.Run("Scripts", testScriptsExists) - t.Run("WithdrawalHistories", testWithdrawalHistoriesExists) } func TestFind(t *testing.T) { t.Run("AuditEvents", testAuditEventsFind) + t.Run("Exchanges", testExchangesFind) t.Run("Scripts", testScriptsFind) - t.Run("WithdrawalHistories", testWithdrawalHistoriesFind) } func TestBind(t *testing.T) { t.Run("AuditEvents", testAuditEventsBind) + t.Run("Exchanges", testExchangesBind) t.Run("Scripts", testScriptsBind) - t.Run("WithdrawalHistories", testWithdrawalHistoriesBind) } func TestOne(t *testing.T) { t.Run("AuditEvents", testAuditEventsOne) + t.Run("Exchanges", testExchangesOne) t.Run("Scripts", testScriptsOne) - t.Run("WithdrawalHistories", testWithdrawalHistoriesOne) } func TestAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsAll) + t.Run("Exchanges", testExchangesAll) t.Run("Scripts", testScriptsAll) - t.Run("WithdrawalHistories", testWithdrawalHistoriesAll) } func TestCount(t *testing.T) { t.Run("AuditEvents", testAuditEventsCount) + t.Run("Exchanges", testExchangesCount) t.Run("Scripts", testScriptsCount) - t.Run("WithdrawalHistories", testWithdrawalHistoriesCount) } func TestHooks(t *testing.T) { t.Run("AuditEvents", testAuditEventsHooks) + t.Run("Exchanges", testExchangesHooks) t.Run("Scripts", testScriptsHooks) - t.Run("WithdrawalHistories", testWithdrawalHistoriesHooks) } func TestInsert(t *testing.T) { t.Run("AuditEvents", testAuditEventsInsert) t.Run("AuditEvents", testAuditEventsInsertWhitelist) + t.Run("Exchanges", testExchangesInsert) + t.Run("Exchanges", testExchangesInsertWhitelist) t.Run("Scripts", testScriptsInsert) t.Run("Scripts", testScriptsInsertWhitelist) - t.Run("WithdrawalHistories", testWithdrawalHistoriesInsert) - t.Run("WithdrawalHistories", testWithdrawalHistoriesInsertWhitelist) } // TestToOne tests cannot be run in parallel @@ -128,30 +128,29 @@ func TestToManyRemove(t *testing.T) {} func TestReload(t *testing.T) { t.Run("AuditEvents", testAuditEventsReload) - t.Run("Scripts", testScriptsReload) - t.Run("WithdrawalHistories", testWithdrawalHistoriesReload) + t.Run("Exchanges", testExchangesReload) } func TestReloadAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsReloadAll) + t.Run("Exchanges", testExchangesReloadAll) t.Run("Scripts", testScriptsReloadAll) - t.Run("WithdrawalHistories", testWithdrawalHistoriesReloadAll) } func TestSelect(t *testing.T) { t.Run("AuditEvents", testAuditEventsSelect) + t.Run("Exchanges", testExchangesSelect) t.Run("Scripts", testScriptsSelect) - t.Run("WithdrawalHistories", testWithdrawalHistoriesSelect) } func TestUpdate(t *testing.T) { t.Run("AuditEvents", testAuditEventsUpdate) + t.Run("Exchanges", testExchangesUpdate) t.Run("Scripts", testScriptsUpdate) - t.Run("WithdrawalHistories", testWithdrawalHistoriesUpdate) } func TestSliceUpdateAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsSliceUpdateAll) + t.Run("Exchanges", testExchangesSliceUpdateAll) t.Run("Scripts", testScriptsSliceUpdateAll) - t.Run("WithdrawalHistories", testWithdrawalHistoriesSliceUpdateAll) } diff --git a/database/models/postgres/boil_table_names.go b/database/models/postgres/boil_table_names.go index ad21f7ab..bad4329f 100644 --- a/database/models/postgres/boil_table_names.go +++ b/database/models/postgres/boil_table_names.go @@ -5,6 +5,8 @@ package postgres var TableNames = struct { AuditEvent string + Candle string + Exchange string Script string ScriptExecution string WithdrawalCrypto string @@ -12,6 +14,8 @@ var TableNames = struct { WithdrawalHistory string }{ AuditEvent: "audit_event", + Candle: "candle", + Exchange: "exchange", Script: "script", ScriptExecution: "script_execution", WithdrawalCrypto: "withdrawal_crypto", diff --git a/database/models/postgres/candle.go b/database/models/postgres/candle.go new file mode 100644 index 00000000..8690c1ea --- /dev/null +++ b/database/models/postgres/candle.go @@ -0,0 +1,1095 @@ +// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package postgres + +import ( + "context" + "database/sql" + "fmt" + "reflect" + "strconv" + "strings" + "sync" + "time" + + "github.com/pkg/errors" + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries" + "github.com/thrasher-corp/sqlboiler/queries/qm" + "github.com/thrasher-corp/sqlboiler/queries/qmhelper" + "github.com/thrasher-corp/sqlboiler/strmangle" +) + +// Candle is an object representing the database table. +type Candle struct { + ID string `boil:"id" json:"id" toml:"id" yaml:"id"` + ExchangeNameID string `boil:"exchange_name_id" json:"exchange_name_id" toml:"exchange_name_id" yaml:"exchange_name_id"` + Base string `boil:"base" json:"base" toml:"base" yaml:"base"` + Quote string `boil:"quote" json:"quote" toml:"quote" yaml:"quote"` + Interval int64 `boil:"interval" json:"interval" toml:"interval" yaml:"interval"` + Timestamp time.Time `boil:"timestamp" json:"timestamp" toml:"timestamp" yaml:"timestamp"` + Open float64 `boil:"open" json:"open" toml:"open" yaml:"open"` + High float64 `boil:"high" json:"high" toml:"high" yaml:"high"` + Low float64 `boil:"low" json:"low" toml:"low" yaml:"low"` + Close float64 `boil:"close" json:"close" toml:"close" yaml:"close"` + Volume float64 `boil:"volume" json:"volume" toml:"volume" yaml:"volume"` + Asset string `boil:"asset" json:"asset" toml:"asset" yaml:"asset"` + + R *candleR `boil:"-" json:"-" toml:"-" yaml:"-"` + L candleL `boil:"-" json:"-" toml:"-" yaml:"-"` +} + +var CandleColumns = struct { + ID string + ExchangeNameID string + Base string + Quote string + Interval string + Timestamp string + Open string + High string + Low string + Close string + Volume string + Asset string +}{ + ID: "id", + ExchangeNameID: "exchange_name_id", + Base: "base", + Quote: "quote", + Interval: "interval", + Timestamp: "timestamp", + Open: "open", + High: "high", + Low: "low", + Close: "close", + Volume: "volume", + Asset: "asset", +} + +// Generated where + +type whereHelperfloat64 struct{ field string } + +func (w whereHelperfloat64) EQ(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) } +func (w whereHelperfloat64) NEQ(x float64) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.NEQ, x) +} +func (w whereHelperfloat64) LT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) } +func (w whereHelperfloat64) LTE(x float64) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.LTE, x) +} +func (w whereHelperfloat64) GT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) } +func (w whereHelperfloat64) GTE(x float64) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.GTE, x) +} + +var CandleWhere = struct { + ID whereHelperstring + ExchangeNameID whereHelperstring + Base whereHelperstring + Quote whereHelperstring + Interval whereHelperint64 + Timestamp whereHelpertime_Time + Open whereHelperfloat64 + High whereHelperfloat64 + Low whereHelperfloat64 + Close whereHelperfloat64 + Volume whereHelperfloat64 + Asset whereHelperstring +}{ + ID: whereHelperstring{field: "\"candle\".\"id\""}, + ExchangeNameID: whereHelperstring{field: "\"candle\".\"exchange_name_id\""}, + Base: whereHelperstring{field: "\"candle\".\"base\""}, + Quote: whereHelperstring{field: "\"candle\".\"quote\""}, + Interval: whereHelperint64{field: "\"candle\".\"interval\""}, + Timestamp: whereHelpertime_Time{field: "\"candle\".\"timestamp\""}, + Open: whereHelperfloat64{field: "\"candle\".\"open\""}, + High: whereHelperfloat64{field: "\"candle\".\"high\""}, + Low: whereHelperfloat64{field: "\"candle\".\"low\""}, + Close: whereHelperfloat64{field: "\"candle\".\"close\""}, + Volume: whereHelperfloat64{field: "\"candle\".\"volume\""}, + Asset: whereHelperstring{field: "\"candle\".\"asset\""}, +} + +// CandleRels is where relationship names are stored. +var CandleRels = struct { + ExchangeName string +}{ + ExchangeName: "ExchangeName", +} + +// candleR is where relationships are stored. +type candleR struct { + ExchangeName *Exchange +} + +// NewStruct creates a new relationship struct +func (*candleR) NewStruct() *candleR { + return &candleR{} +} + +// candleL is where Load methods for each relationship are stored. +type candleL struct{} + +var ( + candleAllColumns = []string{"id", "exchange_name_id", "base", "quote", "interval", "timestamp", "open", "high", "low", "close", "volume", "asset"} + candleColumnsWithoutDefault = []string{"exchange_name_id", "base", "quote", "interval", "timestamp", "open", "high", "low", "close", "volume", "asset"} + candleColumnsWithDefault = []string{"id"} + candlePrimaryKeyColumns = []string{"id"} +) + +type ( + // CandleSlice is an alias for a slice of pointers to Candle. + // This should generally be used opposed to []Candle. + CandleSlice []*Candle + // CandleHook is the signature for custom Candle hook methods + CandleHook func(context.Context, boil.ContextExecutor, *Candle) error + + candleQuery struct { + *queries.Query + } +) + +// Cache for insert, update and upsert +var ( + candleType = reflect.TypeOf(&Candle{}) + candleMapping = queries.MakeStructMapping(candleType) + candlePrimaryKeyMapping, _ = queries.BindMapping(candleType, candleMapping, candlePrimaryKeyColumns) + candleInsertCacheMut sync.RWMutex + candleInsertCache = make(map[string]insertCache) + candleUpdateCacheMut sync.RWMutex + candleUpdateCache = make(map[string]updateCache) + candleUpsertCacheMut sync.RWMutex + candleUpsertCache = make(map[string]insertCache) +) + +var ( + // Force time package dependency for automated UpdatedAt/CreatedAt. + _ = time.Second + // Force qmhelper dependency for where clause generation (which doesn't + // always happen) + _ = qmhelper.Where +) + +var candleBeforeInsertHooks []CandleHook +var candleBeforeUpdateHooks []CandleHook +var candleBeforeDeleteHooks []CandleHook +var candleBeforeUpsertHooks []CandleHook + +var candleAfterInsertHooks []CandleHook +var candleAfterSelectHooks []CandleHook +var candleAfterUpdateHooks []CandleHook +var candleAfterDeleteHooks []CandleHook +var candleAfterUpsertHooks []CandleHook + +// doBeforeInsertHooks executes all "before insert" hooks. +func (o *Candle) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleBeforeInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpdateHooks executes all "before Update" hooks. +func (o *Candle) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleBeforeUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeDeleteHooks executes all "before Delete" hooks. +func (o *Candle) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleBeforeDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpsertHooks executes all "before Upsert" hooks. +func (o *Candle) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleBeforeUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterInsertHooks executes all "after Insert" hooks. +func (o *Candle) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterSelectHooks executes all "after Select" hooks. +func (o *Candle) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterSelectHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpdateHooks executes all "after Update" hooks. +func (o *Candle) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterDeleteHooks executes all "after Delete" hooks. +func (o *Candle) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpsertHooks executes all "after Upsert" hooks. +func (o *Candle) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// AddCandleHook registers your hook function for all future operations. +func AddCandleHook(hookPoint boil.HookPoint, candleHook CandleHook) { + switch hookPoint { + case boil.BeforeInsertHook: + candleBeforeInsertHooks = append(candleBeforeInsertHooks, candleHook) + case boil.BeforeUpdateHook: + candleBeforeUpdateHooks = append(candleBeforeUpdateHooks, candleHook) + case boil.BeforeDeleteHook: + candleBeforeDeleteHooks = append(candleBeforeDeleteHooks, candleHook) + case boil.BeforeUpsertHook: + candleBeforeUpsertHooks = append(candleBeforeUpsertHooks, candleHook) + case boil.AfterInsertHook: + candleAfterInsertHooks = append(candleAfterInsertHooks, candleHook) + case boil.AfterSelectHook: + candleAfterSelectHooks = append(candleAfterSelectHooks, candleHook) + case boil.AfterUpdateHook: + candleAfterUpdateHooks = append(candleAfterUpdateHooks, candleHook) + case boil.AfterDeleteHook: + candleAfterDeleteHooks = append(candleAfterDeleteHooks, candleHook) + case boil.AfterUpsertHook: + candleAfterUpsertHooks = append(candleAfterUpsertHooks, candleHook) + } +} + +// One returns a single candle record from the query. +func (q candleQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Candle, error) { + o := &Candle{} + + queries.SetLimit(q.Query, 1) + + err := q.Bind(ctx, exec, o) + if err != nil { + if errors.Cause(err) == sql.ErrNoRows { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "postgres: failed to execute a one query for candle") + } + + if err := o.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + + return o, nil +} + +// All returns all Candle records from the query. +func (q candleQuery) All(ctx context.Context, exec boil.ContextExecutor) (CandleSlice, error) { + var o []*Candle + + err := q.Bind(ctx, exec, &o) + if err != nil { + return nil, errors.Wrap(err, "postgres: failed to assign all query results to Candle slice") + } + + if len(candleAfterSelectHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + } + } + + return o, nil +} + +// Count returns the count of all Candle records in the query. +func (q candleQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to count candle rows") + } + + return count, nil +} + +// Exists checks if the row exists in the table. +func (q candleQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + queries.SetLimit(q.Query, 1) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return false, errors.Wrap(err, "postgres: failed to check if candle exists") + } + + return count > 0, nil +} + +// ExchangeName pointed to by the foreign key. +func (o *Candle) ExchangeName(mods ...qm.QueryMod) exchangeQuery { + queryMods := []qm.QueryMod{ + qm.Where("\"id\" = ?", o.ExchangeNameID), + } + + queryMods = append(queryMods, mods...) + + query := Exchanges(queryMods...) + queries.SetFrom(query.Query, "\"exchange\"") + + return query +} + +// LoadExchangeName allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for an N-1 relationship. +func (candleL) LoadExchangeName(ctx context.Context, e boil.ContextExecutor, singular bool, maybeCandle interface{}, mods queries.Applicator) error { + var slice []*Candle + var object *Candle + + if singular { + object = maybeCandle.(*Candle) + } else { + slice = *maybeCandle.(*[]*Candle) + } + + args := make([]interface{}, 0, 1) + if singular { + if object.R == nil { + object.R = &candleR{} + } + args = append(args, object.ExchangeNameID) + + } else { + Outer: + for _, obj := range slice { + if obj.R == nil { + obj.R = &candleR{} + } + + for _, a := range args { + if a == obj.ExchangeNameID { + continue Outer + } + } + + args = append(args, obj.ExchangeNameID) + + } + } + + if len(args) == 0 { + return nil + } + + query := NewQuery(qm.From(`exchange`), qm.WhereIn(`exchange.id in ?`, args...)) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load Exchange") + } + + var resultSlice []*Exchange + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice Exchange") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results of eager load for exchange") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for exchange") + } + + if len(candleAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + + if len(resultSlice) == 0 { + return nil + } + + if singular { + foreign := resultSlice[0] + object.R.ExchangeName = foreign + if foreign.R == nil { + foreign.R = &exchangeR{} + } + foreign.R.ExchangeNameCandles = append(foreign.R.ExchangeNameCandles, object) + return nil + } + + for _, local := range slice { + for _, foreign := range resultSlice { + if local.ExchangeNameID == foreign.ID { + local.R.ExchangeName = foreign + if foreign.R == nil { + foreign.R = &exchangeR{} + } + foreign.R.ExchangeNameCandles = append(foreign.R.ExchangeNameCandles, local) + break + } + } + } + + return nil +} + +// SetExchangeName of the candle to the related item. +// Sets o.R.ExchangeName to related. +// Adds o to related.R.ExchangeNameCandles. +func (o *Candle) SetExchangeName(ctx context.Context, exec boil.ContextExecutor, insert bool, related *Exchange) error { + var err error + if insert { + if err = related.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } + + updateQuery := fmt.Sprintf( + "UPDATE \"candle\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, []string{"exchange_name_id"}), + strmangle.WhereClause("\"", "\"", 2, candlePrimaryKeyColumns), + ) + values := []interface{}{related.ID, o.ID} + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, updateQuery) + fmt.Fprintln(boil.DebugWriter, values) + } + + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update local table") + } + + o.ExchangeNameID = related.ID + if o.R == nil { + o.R = &candleR{ + ExchangeName: related, + } + } else { + o.R.ExchangeName = related + } + + if related.R == nil { + related.R = &exchangeR{ + ExchangeNameCandles: CandleSlice{o}, + } + } else { + related.R.ExchangeNameCandles = append(related.R.ExchangeNameCandles, o) + } + + return nil +} + +// Candles retrieves all the records using an executor. +func Candles(mods ...qm.QueryMod) candleQuery { + mods = append(mods, qm.From("\"candle\"")) + return candleQuery{NewQuery(mods...)} +} + +// FindCandle retrieves a single record by ID with an executor. +// If selectCols is empty Find will return all columns. +func FindCandle(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*Candle, error) { + candleObj := &Candle{} + + sel := "*" + if len(selectCols) > 0 { + sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") + } + query := fmt.Sprintf( + "select %s from \"candle\" where \"id\"=$1", sel, + ) + + q := queries.Raw(query, iD) + + err := q.Bind(ctx, exec, candleObj) + if err != nil { + if errors.Cause(err) == sql.ErrNoRows { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "postgres: unable to select from candle") + } + + return candleObj, nil +} + +// Insert a single record using an executor. +// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. +func (o *Candle) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { + if o == nil { + return errors.New("postgres: no candle provided for insertion") + } + + var err error + + if err := o.doBeforeInsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(candleColumnsWithDefault, o) + + key := makeCacheKey(columns, nzDefaults) + candleInsertCacheMut.RLock() + cache, cached := candleInsertCache[key] + candleInsertCacheMut.RUnlock() + + if !cached { + wl, returnColumns := columns.InsertColumnSet( + candleAllColumns, + candleColumnsWithDefault, + candleColumnsWithoutDefault, + nzDefaults, + ) + + cache.valueMapping, err = queries.BindMapping(candleType, candleMapping, wl) + if err != nil { + return err + } + cache.retMapping, err = queries.BindMapping(candleType, candleMapping, returnColumns) + if err != nil { + return err + } + if len(wl) != 0 { + cache.query = fmt.Sprintf("INSERT INTO \"candle\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) + } else { + cache.query = "INSERT INTO \"candle\" %sDEFAULT VALUES%s" + } + + var queryOutput, queryReturning string + + if len(cache.retMapping) != 0 { + queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) + } + + cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, vals) + } + + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + + if err != nil { + return errors.Wrap(err, "postgres: unable to insert into candle") + } + + if !cached { + candleInsertCacheMut.Lock() + candleInsertCache[key] = cache + candleInsertCacheMut.Unlock() + } + + return o.doAfterInsertHooks(ctx, exec) +} + +// Update uses an executor to update the Candle. +// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. +// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. +func (o *Candle) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { + var err error + if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { + return 0, err + } + key := makeCacheKey(columns, nil) + candleUpdateCacheMut.RLock() + cache, cached := candleUpdateCache[key] + candleUpdateCacheMut.RUnlock() + + if !cached { + wl := columns.UpdateColumnSet( + candleAllColumns, + candlePrimaryKeyColumns, + ) + + if len(wl) == 0 { + return 0, errors.New("postgres: unable to update candle, could not build whitelist") + } + + cache.query = fmt.Sprintf("UPDATE \"candle\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, wl), + strmangle.WhereClause("\"", "\"", len(wl)+1, candlePrimaryKeyColumns), + ) + cache.valueMapping, err = queries.BindMapping(candleType, candleMapping, append(wl, candlePrimaryKeyColumns...)) + if err != nil { + return 0, err + } + } + + values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, values) + } + + var result sql.Result + result, err = exec.ExecContext(ctx, cache.query, values...) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to update candle row") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to get rows affected by update for candle") + } + + if !cached { + candleUpdateCacheMut.Lock() + candleUpdateCache[key] = cache + candleUpdateCacheMut.Unlock() + } + + return rowsAff, o.doAfterUpdateHooks(ctx, exec) +} + +// UpdateAll updates all rows with the specified column values. +func (q candleQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + queries.SetUpdate(q.Query, cols) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to update all for candle") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to retrieve rows affected for candle") + } + + return rowsAff, nil +} + +// UpdateAll updates all rows with the specified column values, using an executor. +func (o CandleSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + ln := int64(len(o)) + if ln == 0 { + return 0, nil + } + + if len(cols) == 0 { + return 0, errors.New("postgres: update all requires at least one column argument") + } + + colNames := make([]string, len(cols)) + args := make([]interface{}, len(cols)) + + i := 0 + for name, value := range cols { + colNames[i] = name + args[i] = value + i++ + } + + // Append all of the primary key values for each column + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), candlePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := fmt.Sprintf("UPDATE \"candle\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, colNames), + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, candlePrimaryKeyColumns, len(o))) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args...) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to update all in candle slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to retrieve rows affected all in update all candle") + } + return rowsAff, nil +} + +// Upsert attempts an insert using an executor, and does an update or ignore on conflict. +// See boil.Columns documentation for how to properly use updateColumns and insertColumns. +func (o *Candle) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error { + if o == nil { + return errors.New("postgres: no candle provided for upsert") + } + + if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(candleColumnsWithDefault, o) + + // Build cache key in-line uglily - mysql vs psql problems + buf := strmangle.GetBuffer() + if updateOnConflict { + buf.WriteByte('t') + } else { + buf.WriteByte('f') + } + buf.WriteByte('.') + for _, c := range conflictColumns { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(updateColumns.Kind)) + for _, c := range updateColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(insertColumns.Kind)) + for _, c := range insertColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + for _, c := range nzDefaults { + buf.WriteString(c) + } + key := buf.String() + strmangle.PutBuffer(buf) + + candleUpsertCacheMut.RLock() + cache, cached := candleUpsertCache[key] + candleUpsertCacheMut.RUnlock() + + var err error + + if !cached { + insert, ret := insertColumns.InsertColumnSet( + candleAllColumns, + candleColumnsWithDefault, + candleColumnsWithoutDefault, + nzDefaults, + ) + update := updateColumns.UpdateColumnSet( + candleAllColumns, + candlePrimaryKeyColumns, + ) + + if updateOnConflict && len(update) == 0 { + return errors.New("postgres: unable to upsert candle, could not build update column list") + } + + conflict := conflictColumns + if len(conflict) == 0 { + conflict = make([]string, len(candlePrimaryKeyColumns)) + copy(conflict, candlePrimaryKeyColumns) + } + cache.query = buildUpsertQueryPostgres(dialect, "\"candle\"", updateOnConflict, ret, update, conflict, insert) + + cache.valueMapping, err = queries.BindMapping(candleType, candleMapping, insert) + if err != nil { + return err + } + if len(ret) != 0 { + cache.retMapping, err = queries.BindMapping(candleType, candleMapping, ret) + if err != nil { + return err + } + } + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + var returns []interface{} + if len(cache.retMapping) != 0 { + returns = queries.PtrsFromMapping(value, cache.retMapping) + } + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, vals) + } + + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) + if err == sql.ErrNoRows { + err = nil // Postgres doesn't return anything when there's no update + } + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + if err != nil { + return errors.Wrap(err, "postgres: unable to upsert candle") + } + + if !cached { + candleUpsertCacheMut.Lock() + candleUpsertCache[key] = cache + candleUpsertCacheMut.Unlock() + } + + return o.doAfterUpsertHooks(ctx, exec) +} + +// Delete deletes a single Candle record with an executor. +// Delete will match against the primary key column to find the record to delete. +func (o *Candle) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if o == nil { + return 0, errors.New("postgres: no Candle provided for delete") + } + + if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), candlePrimaryKeyMapping) + sql := "DELETE FROM \"candle\" WHERE \"id\"=$1" + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args...) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to delete from candle") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to get rows affected by delete for candle") + } + + if err := o.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + return rowsAff, nil +} + +// DeleteAll deletes all matching rows. +func (q candleQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if q.Query == nil { + return 0, errors.New("postgres: no candleQuery provided for delete all") + } + + queries.SetDelete(q.Query) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to delete all from candle") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to get rows affected by deleteall for candle") + } + + return rowsAff, nil +} + +// DeleteAll deletes all rows in the slice, using an executor. +func (o CandleSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if len(o) == 0 { + return 0, nil + } + + if len(candleBeforeDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + var args []interface{} + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), candlePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "DELETE FROM \"candle\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, candlePrimaryKeyColumns, len(o)) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to delete all from candle slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to get rows affected by deleteall for candle") + } + + if len(candleAfterDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + return rowsAff, nil +} + +// Reload refetches the object from the database +// using the primary keys with an executor. +func (o *Candle) Reload(ctx context.Context, exec boil.ContextExecutor) error { + ret, err := FindCandle(ctx, exec, o.ID) + if err != nil { + return err + } + + *o = *ret + return nil +} + +// ReloadAll refetches every row with matching primary key column values +// and overwrites the original object slice with the newly updated slice. +func (o *CandleSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { + if o == nil || len(*o) == 0 { + return nil + } + + slice := CandleSlice{} + var args []interface{} + for _, obj := range *o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), candlePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "SELECT \"candle\".* FROM \"candle\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, candlePrimaryKeyColumns, len(*o)) + + q := queries.Raw(sql, args...) + + err := q.Bind(ctx, exec, &slice) + if err != nil { + return errors.Wrap(err, "postgres: unable to reload all in CandleSlice") + } + + *o = slice + + return nil +} + +// CandleExists checks if the Candle row exists. +func CandleExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { + var exists bool + sql := "select exists(select 1 from \"candle\" where \"id\"=$1 limit 1)" + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, iD) + } + + row := exec.QueryRowContext(ctx, sql, iD) + + err := row.Scan(&exists) + if err != nil { + return false, errors.Wrap(err, "postgres: unable to check if candle exists") + } + + return exists, nil +} diff --git a/database/models/postgres/candle_test.go b/database/models/postgres/candle_test.go new file mode 100644 index 00000000..03f44535 --- /dev/null +++ b/database/models/postgres/candle_test.go @@ -0,0 +1,841 @@ +// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package postgres + +import ( + "bytes" + "context" + "reflect" + "testing" + + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries" + "github.com/thrasher-corp/sqlboiler/randomize" + "github.com/thrasher-corp/sqlboiler/strmangle" +) + +var ( + // Relationships sometimes use the reflection helper queries.Equal/queries.Assign + // so force a package dependency in case they don't. + _ = queries.Equal +) + +func testCandles(t *testing.T) { + t.Parallel() + + query := Candles() + + if query.Query == nil { + t.Error("expected a query, got nothing") + } +} + +func testCandlesDelete(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if rowsAff, err := o.Delete(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testCandlesQueryDeleteAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if rowsAff, err := Candles().DeleteAll(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testCandlesSliceDeleteAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice := CandleSlice{o} + + if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testCandlesExists(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + e, err := CandleExists(ctx, tx, o.ID) + if err != nil { + t.Errorf("Unable to check if Candle exists: %s", err) + } + if !e { + t.Errorf("Expected CandleExists to return true, but got false.") + } +} + +func testCandlesFind(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + candleFound, err := FindCandle(ctx, tx, o.ID) + if err != nil { + t.Error(err) + } + + if candleFound == nil { + t.Error("want a record, got nil") + } +} + +func testCandlesBind(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if err = Candles().Bind(ctx, tx, o); err != nil { + t.Error(err) + } +} + +func testCandlesOne(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if x, err := Candles().One(ctx, tx); err != nil { + t.Error(err) + } else if x == nil { + t.Error("expected to get a non nil record") + } +} + +func testCandlesAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + candleOne := &Candle{} + candleTwo := &Candle{} + if err = randomize.Struct(seed, candleOne, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + if err = randomize.Struct(seed, candleTwo, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = candleOne.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + if err = candleTwo.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice, err := Candles().All(ctx, tx) + if err != nil { + t.Error(err) + } + + if len(slice) != 2 { + t.Error("want 2 records, got:", len(slice)) + } +} + +func testCandlesCount(t *testing.T) { + t.Parallel() + + var err error + seed := randomize.NewSeed() + candleOne := &Candle{} + candleTwo := &Candle{} + if err = randomize.Struct(seed, candleOne, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + if err = randomize.Struct(seed, candleTwo, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = candleOne.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + if err = candleTwo.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 2 { + t.Error("want 2 records, got:", count) + } +} + +func candleBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func testCandlesHooks(t *testing.T) { + t.Parallel() + + var err error + + ctx := context.Background() + empty := &Candle{} + o := &Candle{} + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, o, candleDBTypes, false); err != nil { + t.Errorf("Unable to randomize Candle object: %s", err) + } + + AddCandleHook(boil.BeforeInsertHook, candleBeforeInsertHook) + if err = o.doBeforeInsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) + } + candleBeforeInsertHooks = []CandleHook{} + + AddCandleHook(boil.AfterInsertHook, candleAfterInsertHook) + if err = o.doAfterInsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterInsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) + } + candleAfterInsertHooks = []CandleHook{} + + AddCandleHook(boil.AfterSelectHook, candleAfterSelectHook) + if err = o.doAfterSelectHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterSelectHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) + } + candleAfterSelectHooks = []CandleHook{} + + AddCandleHook(boil.BeforeUpdateHook, candleBeforeUpdateHook) + if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) + } + candleBeforeUpdateHooks = []CandleHook{} + + AddCandleHook(boil.AfterUpdateHook, candleAfterUpdateHook) + if err = o.doAfterUpdateHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) + } + candleAfterUpdateHooks = []CandleHook{} + + AddCandleHook(boil.BeforeDeleteHook, candleBeforeDeleteHook) + if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) + } + candleBeforeDeleteHooks = []CandleHook{} + + AddCandleHook(boil.AfterDeleteHook, candleAfterDeleteHook) + if err = o.doAfterDeleteHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) + } + candleAfterDeleteHooks = []CandleHook{} + + AddCandleHook(boil.BeforeUpsertHook, candleBeforeUpsertHook) + if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) + } + candleBeforeUpsertHooks = []CandleHook{} + + AddCandleHook(boil.AfterUpsertHook, candleAfterUpsertHook) + if err = o.doAfterUpsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) + } + candleAfterUpsertHooks = []CandleHook{} +} + +func testCandlesInsert(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } +} + +func testCandlesInsertWhitelist(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Whitelist(candleColumnsWithoutDefault...)); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } +} + +func testCandleToOneExchangeUsingExchangeName(t *testing.T) { + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var local Candle + var foreign Exchange + + seed := randomize.NewSeed() + if err := randomize.Struct(seed, &local, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + if err := randomize.Struct(seed, &foreign, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + local.ExchangeNameID = foreign.ID + if err := local.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + check, err := local.ExchangeName().One(ctx, tx) + if err != nil { + t.Fatal(err) + } + + if check.ID != foreign.ID { + t.Errorf("want: %v, got %v", foreign.ID, check.ID) + } + + slice := CandleSlice{&local} + if err = local.L.LoadExchangeName(ctx, tx, false, (*[]*Candle)(&slice), nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeName == nil { + t.Error("struct should have been eager loaded") + } + + local.R.ExchangeName = nil + if err = local.L.LoadExchangeName(ctx, tx, true, &local, nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeName == nil { + t.Error("struct should have been eager loaded") + } +} + +func testCandleToOneSetOpExchangeUsingExchangeName(t *testing.T) { + var err error + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Candle + var b, c Exchange + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, candleDBTypes, false, strmangle.SetComplement(candlePrimaryKeyColumns, candleColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &b, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &c, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + for i, x := range []*Exchange{&b, &c} { + err = a.SetExchangeName(ctx, tx, i != 0, x) + if err != nil { + t.Fatal(err) + } + + if a.R.ExchangeName != x { + t.Error("relationship struct not set to correct value") + } + + if x.R.ExchangeNameCandles[0] != &a { + t.Error("failed to append to foreign relationship struct") + } + if a.ExchangeNameID != x.ID { + t.Error("foreign key was wrong value", a.ExchangeNameID) + } + + zero := reflect.Zero(reflect.TypeOf(a.ExchangeNameID)) + reflect.Indirect(reflect.ValueOf(&a.ExchangeNameID)).Set(zero) + + if err = a.Reload(ctx, tx); err != nil { + t.Fatal("failed to reload", err) + } + + if a.ExchangeNameID != x.ID { + t.Error("foreign key was wrong value", a.ExchangeNameID, x.ID) + } + } +} + +func testCandlesReload(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if err = o.Reload(ctx, tx); err != nil { + t.Error(err) + } +} + +func testCandlesReloadAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice := CandleSlice{o} + + if err = slice.ReloadAll(ctx, tx); err != nil { + t.Error(err) + } +} + +func testCandlesSelect(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice, err := Candles().All(ctx, tx) + if err != nil { + t.Error(err) + } + + if len(slice) != 1 { + t.Error("want one record, got:", len(slice)) + } +} + +var ( + candleDBTypes = map[string]string{`ID`: `uuid`, `ExchangeNameID`: `uuid`, `Base`: `character varying`, `Quote`: `character varying`, `Interval`: `bigint`, `Timestamp`: `timestamp with time zone`, `Open`: `double precision`, `High`: `double precision`, `Low`: `double precision`, `Close`: `double precision`, `Volume`: `double precision`, `Asset`: `character varying`} + _ = bytes.MinRead +) + +func testCandlesUpdate(t *testing.T) { + t.Parallel() + + if 0 == len(candlePrimaryKeyColumns) { + t.Skip("Skipping table with no primary key columns") + } + if len(candleAllColumns) == len(candlePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } + + if err = randomize.Struct(seed, o, candleDBTypes, true, candlePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only affect one row but affected", rowsAff) + } +} + +func testCandlesSliceUpdateAll(t *testing.T) { + t.Parallel() + + if len(candleAllColumns) == len(candlePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } + + if err = randomize.Struct(seed, o, candleDBTypes, true, candlePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + // Remove Primary keys and unique columns from what we plan to update + var fields []string + if strmangle.StringSliceMatch(candleAllColumns, candlePrimaryKeyColumns) { + fields = candleAllColumns + } else { + fields = strmangle.SetComplement( + candleAllColumns, + candlePrimaryKeyColumns, + ) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + typ := reflect.TypeOf(o).Elem() + n := typ.NumField() + + updateMap := M{} + for _, col := range fields { + for i := 0; i < n; i++ { + f := typ.Field(i) + if f.Tag.Get("boil") == col { + updateMap[col] = value.Field(i).Interface() + } + } + } + + slice := CandleSlice{o} + if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("wanted one record updated but got", rowsAff) + } +} + +func testCandlesUpsert(t *testing.T) { + t.Parallel() + + if len(candleAllColumns) == len(candlePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + // Attempt the INSERT side of an UPSERT + o := Candle{} + if err = randomize.Struct(seed, &o, candleDBTypes, true); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Upsert(ctx, tx, false, nil, boil.Infer(), boil.Infer()); err != nil { + t.Errorf("Unable to upsert Candle: %s", err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + if count != 1 { + t.Error("want one record, got:", count) + } + + // Attempt the UPDATE side of an UPSERT + if err = randomize.Struct(seed, &o, candleDBTypes, false, candlePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + if err = o.Upsert(ctx, tx, true, nil, boil.Infer(), boil.Infer()); err != nil { + t.Errorf("Unable to upsert Candle: %s", err) + } + + count, err = Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + if count != 1 { + t.Error("want one record, got:", count) + } +} diff --git a/database/models/postgres/exchange.go b/database/models/postgres/exchange.go new file mode 100644 index 00000000..36a7dcbc --- /dev/null +++ b/database/models/postgres/exchange.go @@ -0,0 +1,1209 @@ +// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package postgres + +import ( + "context" + "database/sql" + "fmt" + "reflect" + "strconv" + "strings" + "sync" + "time" + + "github.com/pkg/errors" + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries" + "github.com/thrasher-corp/sqlboiler/queries/qm" + "github.com/thrasher-corp/sqlboiler/queries/qmhelper" + "github.com/thrasher-corp/sqlboiler/strmangle" +) + +// Exchange is an object representing the database table. +type Exchange struct { + ID string `boil:"id" json:"id" toml:"id" yaml:"id"` + Name string `boil:"name" json:"name" toml:"name" yaml:"name"` + + R *exchangeR `boil:"-" json:"-" toml:"-" yaml:"-"` + L exchangeL `boil:"-" json:"-" toml:"-" yaml:"-"` +} + +var ExchangeColumns = struct { + ID string + Name string +}{ + ID: "id", + Name: "name", +} + +// Generated where + +var ExchangeWhere = struct { + ID whereHelperstring + Name whereHelperstring +}{ + ID: whereHelperstring{field: "\"exchange\".\"id\""}, + Name: whereHelperstring{field: "\"exchange\".\"name\""}, +} + +// ExchangeRels is where relationship names are stored. +var ExchangeRels = struct { + ExchangeNameCandles string + ExchangeNameWithdrawalHistories string +}{ + ExchangeNameCandles: "ExchangeNameCandles", + ExchangeNameWithdrawalHistories: "ExchangeNameWithdrawalHistories", +} + +// exchangeR is where relationships are stored. +type exchangeR struct { + ExchangeNameCandles CandleSlice + ExchangeNameWithdrawalHistories WithdrawalHistorySlice +} + +// NewStruct creates a new relationship struct +func (*exchangeR) NewStruct() *exchangeR { + return &exchangeR{} +} + +// exchangeL is where Load methods for each relationship are stored. +type exchangeL struct{} + +var ( + exchangeAllColumns = []string{"id", "name"} + exchangeColumnsWithoutDefault = []string{"name"} + exchangeColumnsWithDefault = []string{"id"} + exchangePrimaryKeyColumns = []string{"id"} +) + +type ( + // ExchangeSlice is an alias for a slice of pointers to Exchange. + // This should generally be used opposed to []Exchange. + ExchangeSlice []*Exchange + // ExchangeHook is the signature for custom Exchange hook methods + ExchangeHook func(context.Context, boil.ContextExecutor, *Exchange) error + + exchangeQuery struct { + *queries.Query + } +) + +// Cache for insert, update and upsert +var ( + exchangeType = reflect.TypeOf(&Exchange{}) + exchangeMapping = queries.MakeStructMapping(exchangeType) + exchangePrimaryKeyMapping, _ = queries.BindMapping(exchangeType, exchangeMapping, exchangePrimaryKeyColumns) + exchangeInsertCacheMut sync.RWMutex + exchangeInsertCache = make(map[string]insertCache) + exchangeUpdateCacheMut sync.RWMutex + exchangeUpdateCache = make(map[string]updateCache) + exchangeUpsertCacheMut sync.RWMutex + exchangeUpsertCache = make(map[string]insertCache) +) + +var ( + // Force time package dependency for automated UpdatedAt/CreatedAt. + _ = time.Second + // Force qmhelper dependency for where clause generation (which doesn't + // always happen) + _ = qmhelper.Where +) + +var exchangeBeforeInsertHooks []ExchangeHook +var exchangeBeforeUpdateHooks []ExchangeHook +var exchangeBeforeDeleteHooks []ExchangeHook +var exchangeBeforeUpsertHooks []ExchangeHook + +var exchangeAfterInsertHooks []ExchangeHook +var exchangeAfterSelectHooks []ExchangeHook +var exchangeAfterUpdateHooks []ExchangeHook +var exchangeAfterDeleteHooks []ExchangeHook +var exchangeAfterUpsertHooks []ExchangeHook + +// doBeforeInsertHooks executes all "before insert" hooks. +func (o *Exchange) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeBeforeInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpdateHooks executes all "before Update" hooks. +func (o *Exchange) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeBeforeUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeDeleteHooks executes all "before Delete" hooks. +func (o *Exchange) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeBeforeDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpsertHooks executes all "before Upsert" hooks. +func (o *Exchange) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeBeforeUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterInsertHooks executes all "after Insert" hooks. +func (o *Exchange) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterSelectHooks executes all "after Select" hooks. +func (o *Exchange) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterSelectHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpdateHooks executes all "after Update" hooks. +func (o *Exchange) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterDeleteHooks executes all "after Delete" hooks. +func (o *Exchange) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpsertHooks executes all "after Upsert" hooks. +func (o *Exchange) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// AddExchangeHook registers your hook function for all future operations. +func AddExchangeHook(hookPoint boil.HookPoint, exchangeHook ExchangeHook) { + switch hookPoint { + case boil.BeforeInsertHook: + exchangeBeforeInsertHooks = append(exchangeBeforeInsertHooks, exchangeHook) + case boil.BeforeUpdateHook: + exchangeBeforeUpdateHooks = append(exchangeBeforeUpdateHooks, exchangeHook) + case boil.BeforeDeleteHook: + exchangeBeforeDeleteHooks = append(exchangeBeforeDeleteHooks, exchangeHook) + case boil.BeforeUpsertHook: + exchangeBeforeUpsertHooks = append(exchangeBeforeUpsertHooks, exchangeHook) + case boil.AfterInsertHook: + exchangeAfterInsertHooks = append(exchangeAfterInsertHooks, exchangeHook) + case boil.AfterSelectHook: + exchangeAfterSelectHooks = append(exchangeAfterSelectHooks, exchangeHook) + case boil.AfterUpdateHook: + exchangeAfterUpdateHooks = append(exchangeAfterUpdateHooks, exchangeHook) + case boil.AfterDeleteHook: + exchangeAfterDeleteHooks = append(exchangeAfterDeleteHooks, exchangeHook) + case boil.AfterUpsertHook: + exchangeAfterUpsertHooks = append(exchangeAfterUpsertHooks, exchangeHook) + } +} + +// One returns a single exchange record from the query. +func (q exchangeQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Exchange, error) { + o := &Exchange{} + + queries.SetLimit(q.Query, 1) + + err := q.Bind(ctx, exec, o) + if err != nil { + if errors.Cause(err) == sql.ErrNoRows { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "postgres: failed to execute a one query for exchange") + } + + if err := o.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + + return o, nil +} + +// All returns all Exchange records from the query. +func (q exchangeQuery) All(ctx context.Context, exec boil.ContextExecutor) (ExchangeSlice, error) { + var o []*Exchange + + err := q.Bind(ctx, exec, &o) + if err != nil { + return nil, errors.Wrap(err, "postgres: failed to assign all query results to Exchange slice") + } + + if len(exchangeAfterSelectHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + } + } + + return o, nil +} + +// Count returns the count of all Exchange records in the query. +func (q exchangeQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to count exchange rows") + } + + return count, nil +} + +// Exists checks if the row exists in the table. +func (q exchangeQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + queries.SetLimit(q.Query, 1) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return false, errors.Wrap(err, "postgres: failed to check if exchange exists") + } + + return count > 0, nil +} + +// ExchangeNameCandles retrieves all the candle's Candles with an executor via exchange_name_id column. +func (o *Exchange) ExchangeNameCandles(mods ...qm.QueryMod) candleQuery { + var queryMods []qm.QueryMod + if len(mods) != 0 { + queryMods = append(queryMods, mods...) + } + + queryMods = append(queryMods, + qm.Where("\"candle\".\"exchange_name_id\"=?", o.ID), + ) + + query := Candles(queryMods...) + queries.SetFrom(query.Query, "\"candle\"") + + if len(queries.GetSelect(query.Query)) == 0 { + queries.SetSelect(query.Query, []string{"\"candle\".*"}) + } + + return query +} + +// ExchangeNameWithdrawalHistories retrieves all the withdrawal_history's WithdrawalHistories with an executor via exchange_name_id column. +func (o *Exchange) ExchangeNameWithdrawalHistories(mods ...qm.QueryMod) withdrawalHistoryQuery { + var queryMods []qm.QueryMod + if len(mods) != 0 { + queryMods = append(queryMods, mods...) + } + + queryMods = append(queryMods, + qm.Where("\"withdrawal_history\".\"exchange_name_id\"=?", o.ID), + ) + + query := WithdrawalHistories(queryMods...) + queries.SetFrom(query.Query, "\"withdrawal_history\"") + + if len(queries.GetSelect(query.Query)) == 0 { + queries.SetSelect(query.Query, []string{"\"withdrawal_history\".*"}) + } + + return query +} + +// LoadExchangeNameCandles allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for a 1-M or N-M relationship. +func (exchangeL) LoadExchangeNameCandles(ctx context.Context, e boil.ContextExecutor, singular bool, maybeExchange interface{}, mods queries.Applicator) error { + var slice []*Exchange + var object *Exchange + + if singular { + object = maybeExchange.(*Exchange) + } else { + slice = *maybeExchange.(*[]*Exchange) + } + + args := make([]interface{}, 0, 1) + if singular { + if object.R == nil { + object.R = &exchangeR{} + } + args = append(args, object.ID) + } else { + Outer: + for _, obj := range slice { + if obj.R == nil { + obj.R = &exchangeR{} + } + + for _, a := range args { + if a == obj.ID { + continue Outer + } + } + + args = append(args, obj.ID) + } + } + + if len(args) == 0 { + return nil + } + + query := NewQuery(qm.From(`candle`), qm.WhereIn(`candle.exchange_name_id in ?`, args...)) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load candle") + } + + var resultSlice []*Candle + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice candle") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results in eager load on candle") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for candle") + } + + if len(candleAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + if singular { + object.R.ExchangeNameCandles = resultSlice + for _, foreign := range resultSlice { + if foreign.R == nil { + foreign.R = &candleR{} + } + foreign.R.ExchangeName = object + } + return nil + } + + for _, foreign := range resultSlice { + for _, local := range slice { + if local.ID == foreign.ExchangeNameID { + local.R.ExchangeNameCandles = append(local.R.ExchangeNameCandles, foreign) + if foreign.R == nil { + foreign.R = &candleR{} + } + foreign.R.ExchangeName = local + break + } + } + } + + return nil +} + +// LoadExchangeNameWithdrawalHistories allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for a 1-M or N-M relationship. +func (exchangeL) LoadExchangeNameWithdrawalHistories(ctx context.Context, e boil.ContextExecutor, singular bool, maybeExchange interface{}, mods queries.Applicator) error { + var slice []*Exchange + var object *Exchange + + if singular { + object = maybeExchange.(*Exchange) + } else { + slice = *maybeExchange.(*[]*Exchange) + } + + args := make([]interface{}, 0, 1) + if singular { + if object.R == nil { + object.R = &exchangeR{} + } + args = append(args, object.ID) + } else { + Outer: + for _, obj := range slice { + if obj.R == nil { + obj.R = &exchangeR{} + } + + for _, a := range args { + if a == obj.ID { + continue Outer + } + } + + args = append(args, obj.ID) + } + } + + if len(args) == 0 { + return nil + } + + query := NewQuery(qm.From(`withdrawal_history`), qm.WhereIn(`withdrawal_history.exchange_name_id in ?`, args...)) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load withdrawal_history") + } + + var resultSlice []*WithdrawalHistory + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice withdrawal_history") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results in eager load on withdrawal_history") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for withdrawal_history") + } + + if len(withdrawalHistoryAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + if singular { + object.R.ExchangeNameWithdrawalHistories = resultSlice + for _, foreign := range resultSlice { + if foreign.R == nil { + foreign.R = &withdrawalHistoryR{} + } + foreign.R.ExchangeName = object + } + return nil + } + + for _, foreign := range resultSlice { + for _, local := range slice { + if local.ID == foreign.ExchangeNameID { + local.R.ExchangeNameWithdrawalHistories = append(local.R.ExchangeNameWithdrawalHistories, foreign) + if foreign.R == nil { + foreign.R = &withdrawalHistoryR{} + } + foreign.R.ExchangeName = local + break + } + } + } + + return nil +} + +// AddExchangeNameCandles adds the given related objects to the existing relationships +// of the exchange, optionally inserting them as new records. +// Appends related to o.R.ExchangeNameCandles. +// Sets related.R.ExchangeName appropriately. +func (o *Exchange) AddExchangeNameCandles(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*Candle) error { + var err error + for _, rel := range related { + if insert { + rel.ExchangeNameID = o.ID + if err = rel.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } else { + updateQuery := fmt.Sprintf( + "UPDATE \"candle\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, []string{"exchange_name_id"}), + strmangle.WhereClause("\"", "\"", 2, candlePrimaryKeyColumns), + ) + values := []interface{}{o.ID, rel.ID} + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, updateQuery) + fmt.Fprintln(boil.DebugWriter, values) + } + + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update foreign table") + } + + rel.ExchangeNameID = o.ID + } + } + + if o.R == nil { + o.R = &exchangeR{ + ExchangeNameCandles: related, + } + } else { + o.R.ExchangeNameCandles = append(o.R.ExchangeNameCandles, related...) + } + + for _, rel := range related { + if rel.R == nil { + rel.R = &candleR{ + ExchangeName: o, + } + } else { + rel.R.ExchangeName = o + } + } + return nil +} + +// AddExchangeNameWithdrawalHistories adds the given related objects to the existing relationships +// of the exchange, optionally inserting them as new records. +// Appends related to o.R.ExchangeNameWithdrawalHistories. +// Sets related.R.ExchangeName appropriately. +func (o *Exchange) AddExchangeNameWithdrawalHistories(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*WithdrawalHistory) error { + var err error + for _, rel := range related { + if insert { + rel.ExchangeNameID = o.ID + if err = rel.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } else { + updateQuery := fmt.Sprintf( + "UPDATE \"withdrawal_history\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, []string{"exchange_name_id"}), + strmangle.WhereClause("\"", "\"", 2, withdrawalHistoryPrimaryKeyColumns), + ) + values := []interface{}{o.ID, rel.ID} + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, updateQuery) + fmt.Fprintln(boil.DebugWriter, values) + } + + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update foreign table") + } + + rel.ExchangeNameID = o.ID + } + } + + if o.R == nil { + o.R = &exchangeR{ + ExchangeNameWithdrawalHistories: related, + } + } else { + o.R.ExchangeNameWithdrawalHistories = append(o.R.ExchangeNameWithdrawalHistories, related...) + } + + for _, rel := range related { + if rel.R == nil { + rel.R = &withdrawalHistoryR{ + ExchangeName: o, + } + } else { + rel.R.ExchangeName = o + } + } + return nil +} + +// Exchanges retrieves all the records using an executor. +func Exchanges(mods ...qm.QueryMod) exchangeQuery { + mods = append(mods, qm.From("\"exchange\"")) + return exchangeQuery{NewQuery(mods...)} +} + +// FindExchange retrieves a single record by ID with an executor. +// If selectCols is empty Find will return all columns. +func FindExchange(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*Exchange, error) { + exchangeObj := &Exchange{} + + sel := "*" + if len(selectCols) > 0 { + sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") + } + query := fmt.Sprintf( + "select %s from \"exchange\" where \"id\"=$1", sel, + ) + + q := queries.Raw(query, iD) + + err := q.Bind(ctx, exec, exchangeObj) + if err != nil { + if errors.Cause(err) == sql.ErrNoRows { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "postgres: unable to select from exchange") + } + + return exchangeObj, nil +} + +// Insert a single record using an executor. +// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. +func (o *Exchange) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { + if o == nil { + return errors.New("postgres: no exchange provided for insertion") + } + + var err error + + if err := o.doBeforeInsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(exchangeColumnsWithDefault, o) + + key := makeCacheKey(columns, nzDefaults) + exchangeInsertCacheMut.RLock() + cache, cached := exchangeInsertCache[key] + exchangeInsertCacheMut.RUnlock() + + if !cached { + wl, returnColumns := columns.InsertColumnSet( + exchangeAllColumns, + exchangeColumnsWithDefault, + exchangeColumnsWithoutDefault, + nzDefaults, + ) + + cache.valueMapping, err = queries.BindMapping(exchangeType, exchangeMapping, wl) + if err != nil { + return err + } + cache.retMapping, err = queries.BindMapping(exchangeType, exchangeMapping, returnColumns) + if err != nil { + return err + } + if len(wl) != 0 { + cache.query = fmt.Sprintf("INSERT INTO \"exchange\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) + } else { + cache.query = "INSERT INTO \"exchange\" %sDEFAULT VALUES%s" + } + + var queryOutput, queryReturning string + + if len(cache.retMapping) != 0 { + queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) + } + + cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, vals) + } + + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + + if err != nil { + return errors.Wrap(err, "postgres: unable to insert into exchange") + } + + if !cached { + exchangeInsertCacheMut.Lock() + exchangeInsertCache[key] = cache + exchangeInsertCacheMut.Unlock() + } + + return o.doAfterInsertHooks(ctx, exec) +} + +// Update uses an executor to update the Exchange. +// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. +// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. +func (o *Exchange) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { + var err error + if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { + return 0, err + } + key := makeCacheKey(columns, nil) + exchangeUpdateCacheMut.RLock() + cache, cached := exchangeUpdateCache[key] + exchangeUpdateCacheMut.RUnlock() + + if !cached { + wl := columns.UpdateColumnSet( + exchangeAllColumns, + exchangePrimaryKeyColumns, + ) + + if len(wl) == 0 { + return 0, errors.New("postgres: unable to update exchange, could not build whitelist") + } + + cache.query = fmt.Sprintf("UPDATE \"exchange\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, wl), + strmangle.WhereClause("\"", "\"", len(wl)+1, exchangePrimaryKeyColumns), + ) + cache.valueMapping, err = queries.BindMapping(exchangeType, exchangeMapping, append(wl, exchangePrimaryKeyColumns...)) + if err != nil { + return 0, err + } + } + + values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, values) + } + + var result sql.Result + result, err = exec.ExecContext(ctx, cache.query, values...) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to update exchange row") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to get rows affected by update for exchange") + } + + if !cached { + exchangeUpdateCacheMut.Lock() + exchangeUpdateCache[key] = cache + exchangeUpdateCacheMut.Unlock() + } + + return rowsAff, o.doAfterUpdateHooks(ctx, exec) +} + +// UpdateAll updates all rows with the specified column values. +func (q exchangeQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + queries.SetUpdate(q.Query, cols) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to update all for exchange") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to retrieve rows affected for exchange") + } + + return rowsAff, nil +} + +// UpdateAll updates all rows with the specified column values, using an executor. +func (o ExchangeSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + ln := int64(len(o)) + if ln == 0 { + return 0, nil + } + + if len(cols) == 0 { + return 0, errors.New("postgres: update all requires at least one column argument") + } + + colNames := make([]string, len(cols)) + args := make([]interface{}, len(cols)) + + i := 0 + for name, value := range cols { + colNames[i] = name + args[i] = value + i++ + } + + // Append all of the primary key values for each column + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), exchangePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := fmt.Sprintf("UPDATE \"exchange\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, colNames), + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, exchangePrimaryKeyColumns, len(o))) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args...) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to update all in exchange slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to retrieve rows affected all in update all exchange") + } + return rowsAff, nil +} + +// Upsert attempts an insert using an executor, and does an update or ignore on conflict. +// See boil.Columns documentation for how to properly use updateColumns and insertColumns. +func (o *Exchange) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error { + if o == nil { + return errors.New("postgres: no exchange provided for upsert") + } + + if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(exchangeColumnsWithDefault, o) + + // Build cache key in-line uglily - mysql vs psql problems + buf := strmangle.GetBuffer() + if updateOnConflict { + buf.WriteByte('t') + } else { + buf.WriteByte('f') + } + buf.WriteByte('.') + for _, c := range conflictColumns { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(updateColumns.Kind)) + for _, c := range updateColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(insertColumns.Kind)) + for _, c := range insertColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + for _, c := range nzDefaults { + buf.WriteString(c) + } + key := buf.String() + strmangle.PutBuffer(buf) + + exchangeUpsertCacheMut.RLock() + cache, cached := exchangeUpsertCache[key] + exchangeUpsertCacheMut.RUnlock() + + var err error + + if !cached { + insert, ret := insertColumns.InsertColumnSet( + exchangeAllColumns, + exchangeColumnsWithDefault, + exchangeColumnsWithoutDefault, + nzDefaults, + ) + update := updateColumns.UpdateColumnSet( + exchangeAllColumns, + exchangePrimaryKeyColumns, + ) + + if updateOnConflict && len(update) == 0 { + return errors.New("postgres: unable to upsert exchange, could not build update column list") + } + + conflict := conflictColumns + if len(conflict) == 0 { + conflict = make([]string, len(exchangePrimaryKeyColumns)) + copy(conflict, exchangePrimaryKeyColumns) + } + cache.query = buildUpsertQueryPostgres(dialect, "\"exchange\"", updateOnConflict, ret, update, conflict, insert) + + cache.valueMapping, err = queries.BindMapping(exchangeType, exchangeMapping, insert) + if err != nil { + return err + } + if len(ret) != 0 { + cache.retMapping, err = queries.BindMapping(exchangeType, exchangeMapping, ret) + if err != nil { + return err + } + } + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + var returns []interface{} + if len(cache.retMapping) != 0 { + returns = queries.PtrsFromMapping(value, cache.retMapping) + } + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, vals) + } + + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) + if err == sql.ErrNoRows { + err = nil // Postgres doesn't return anything when there's no update + } + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + if err != nil { + return errors.Wrap(err, "postgres: unable to upsert exchange") + } + + if !cached { + exchangeUpsertCacheMut.Lock() + exchangeUpsertCache[key] = cache + exchangeUpsertCacheMut.Unlock() + } + + return o.doAfterUpsertHooks(ctx, exec) +} + +// Delete deletes a single Exchange record with an executor. +// Delete will match against the primary key column to find the record to delete. +func (o *Exchange) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if o == nil { + return 0, errors.New("postgres: no Exchange provided for delete") + } + + if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), exchangePrimaryKeyMapping) + sql := "DELETE FROM \"exchange\" WHERE \"id\"=$1" + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args...) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to delete from exchange") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to get rows affected by delete for exchange") + } + + if err := o.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + return rowsAff, nil +} + +// DeleteAll deletes all matching rows. +func (q exchangeQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if q.Query == nil { + return 0, errors.New("postgres: no exchangeQuery provided for delete all") + } + + queries.SetDelete(q.Query) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to delete all from exchange") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to get rows affected by deleteall for exchange") + } + + return rowsAff, nil +} + +// DeleteAll deletes all rows in the slice, using an executor. +func (o ExchangeSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if len(o) == 0 { + return 0, nil + } + + if len(exchangeBeforeDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + var args []interface{} + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), exchangePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "DELETE FROM \"exchange\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, exchangePrimaryKeyColumns, len(o)) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "postgres: unable to delete all from exchange slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "postgres: failed to get rows affected by deleteall for exchange") + } + + if len(exchangeAfterDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + return rowsAff, nil +} + +// Reload refetches the object from the database +// using the primary keys with an executor. +func (o *Exchange) Reload(ctx context.Context, exec boil.ContextExecutor) error { + ret, err := FindExchange(ctx, exec, o.ID) + if err != nil { + return err + } + + *o = *ret + return nil +} + +// ReloadAll refetches every row with matching primary key column values +// and overwrites the original object slice with the newly updated slice. +func (o *ExchangeSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { + if o == nil || len(*o) == 0 { + return nil + } + + slice := ExchangeSlice{} + var args []interface{} + for _, obj := range *o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), exchangePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "SELECT \"exchange\".* FROM \"exchange\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, exchangePrimaryKeyColumns, len(*o)) + + q := queries.Raw(sql, args...) + + err := q.Bind(ctx, exec, &slice) + if err != nil { + return errors.Wrap(err, "postgres: unable to reload all in ExchangeSlice") + } + + *o = slice + + return nil +} + +// ExchangeExists checks if the Exchange row exists. +func ExchangeExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { + var exists bool + sql := "select exists(select 1 from \"exchange\" where \"id\"=$1 limit 1)" + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, iD) + } + + row := exec.QueryRowContext(ctx, sql, iD) + + err := row.Scan(&exists) + if err != nil { + return false, errors.Wrap(err, "postgres: unable to check if exchange exists") + } + + return exists, nil +} diff --git a/database/models/postgres/exchange_test.go b/database/models/postgres/exchange_test.go new file mode 100644 index 00000000..def86bd2 --- /dev/null +++ b/database/models/postgres/exchange_test.go @@ -0,0 +1,1039 @@ +// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package postgres + +import ( + "bytes" + "context" + "reflect" + "testing" + + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries" + "github.com/thrasher-corp/sqlboiler/randomize" + "github.com/thrasher-corp/sqlboiler/strmangle" +) + +var ( + // Relationships sometimes use the reflection helper queries.Equal/queries.Assign + // so force a package dependency in case they don't. + _ = queries.Equal +) + +func testExchanges(t *testing.T) { + t.Parallel() + + query := Exchanges() + + if query.Query == nil { + t.Error("expected a query, got nothing") + } +} + +func testExchangesDelete(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if rowsAff, err := o.Delete(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testExchangesQueryDeleteAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if rowsAff, err := Exchanges().DeleteAll(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testExchangesSliceDeleteAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice := ExchangeSlice{o} + + if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testExchangesExists(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + e, err := ExchangeExists(ctx, tx, o.ID) + if err != nil { + t.Errorf("Unable to check if Exchange exists: %s", err) + } + if !e { + t.Errorf("Expected ExchangeExists to return true, but got false.") + } +} + +func testExchangesFind(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + exchangeFound, err := FindExchange(ctx, tx, o.ID) + if err != nil { + t.Error(err) + } + + if exchangeFound == nil { + t.Error("want a record, got nil") + } +} + +func testExchangesBind(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if err = Exchanges().Bind(ctx, tx, o); err != nil { + t.Error(err) + } +} + +func testExchangesOne(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if x, err := Exchanges().One(ctx, tx); err != nil { + t.Error(err) + } else if x == nil { + t.Error("expected to get a non nil record") + } +} + +func testExchangesAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + exchangeOne := &Exchange{} + exchangeTwo := &Exchange{} + if err = randomize.Struct(seed, exchangeOne, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + if err = randomize.Struct(seed, exchangeTwo, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = exchangeOne.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + if err = exchangeTwo.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice, err := Exchanges().All(ctx, tx) + if err != nil { + t.Error(err) + } + + if len(slice) != 2 { + t.Error("want 2 records, got:", len(slice)) + } +} + +func testExchangesCount(t *testing.T) { + t.Parallel() + + var err error + seed := randomize.NewSeed() + exchangeOne := &Exchange{} + exchangeTwo := &Exchange{} + if err = randomize.Struct(seed, exchangeOne, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + if err = randomize.Struct(seed, exchangeTwo, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = exchangeOne.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + if err = exchangeTwo.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 2 { + t.Error("want 2 records, got:", count) + } +} + +func exchangeBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func testExchangesHooks(t *testing.T) { + t.Parallel() + + var err error + + ctx := context.Background() + empty := &Exchange{} + o := &Exchange{} + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, o, exchangeDBTypes, false); err != nil { + t.Errorf("Unable to randomize Exchange object: %s", err) + } + + AddExchangeHook(boil.BeforeInsertHook, exchangeBeforeInsertHook) + if err = o.doBeforeInsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) + } + exchangeBeforeInsertHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterInsertHook, exchangeAfterInsertHook) + if err = o.doAfterInsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterInsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) + } + exchangeAfterInsertHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterSelectHook, exchangeAfterSelectHook) + if err = o.doAfterSelectHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterSelectHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) + } + exchangeAfterSelectHooks = []ExchangeHook{} + + AddExchangeHook(boil.BeforeUpdateHook, exchangeBeforeUpdateHook) + if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) + } + exchangeBeforeUpdateHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterUpdateHook, exchangeAfterUpdateHook) + if err = o.doAfterUpdateHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) + } + exchangeAfterUpdateHooks = []ExchangeHook{} + + AddExchangeHook(boil.BeforeDeleteHook, exchangeBeforeDeleteHook) + if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) + } + exchangeBeforeDeleteHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterDeleteHook, exchangeAfterDeleteHook) + if err = o.doAfterDeleteHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) + } + exchangeAfterDeleteHooks = []ExchangeHook{} + + AddExchangeHook(boil.BeforeUpsertHook, exchangeBeforeUpsertHook) + if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) + } + exchangeBeforeUpsertHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterUpsertHook, exchangeAfterUpsertHook) + if err = o.doAfterUpsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) + } + exchangeAfterUpsertHooks = []ExchangeHook{} +} + +func testExchangesInsert(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } +} + +func testExchangesInsertWhitelist(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Whitelist(exchangeColumnsWithoutDefault...)); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } +} + +func testExchangeToManyExchangeNameCandles(t *testing.T) { + var err error + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Exchange + var b, c Candle + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + if err = randomize.Struct(seed, &b, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &c, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Fatal(err) + } + + b.ExchangeNameID = a.ID + c.ExchangeNameID = a.ID + + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = c.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + check, err := a.ExchangeNameCandles().All(ctx, tx) + if err != nil { + t.Fatal(err) + } + + bFound, cFound := false, false + for _, v := range check { + if v.ExchangeNameID == b.ExchangeNameID { + bFound = true + } + if v.ExchangeNameID == c.ExchangeNameID { + cFound = true + } + } + + if !bFound { + t.Error("expected to find b") + } + if !cFound { + t.Error("expected to find c") + } + + slice := ExchangeSlice{&a} + if err = a.L.LoadExchangeNameCandles(ctx, tx, false, (*[]*Exchange)(&slice), nil); err != nil { + t.Fatal(err) + } + if got := len(a.R.ExchangeNameCandles); got != 2 { + t.Error("number of eager loaded records wrong, got:", got) + } + + a.R.ExchangeNameCandles = nil + if err = a.L.LoadExchangeNameCandles(ctx, tx, true, &a, nil); err != nil { + t.Fatal(err) + } + if got := len(a.R.ExchangeNameCandles); got != 2 { + t.Error("number of eager loaded records wrong, got:", got) + } + + if t.Failed() { + t.Logf("%#v", check) + } +} + +func testExchangeToManyExchangeNameWithdrawalHistories(t *testing.T) { + var err error + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Exchange + var b, c WithdrawalHistory + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + if err = randomize.Struct(seed, &b, withdrawalHistoryDBTypes, false, withdrawalHistoryColumnsWithDefault...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &c, withdrawalHistoryDBTypes, false, withdrawalHistoryColumnsWithDefault...); err != nil { + t.Fatal(err) + } + + b.ExchangeNameID = a.ID + c.ExchangeNameID = a.ID + + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = c.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + check, err := a.ExchangeNameWithdrawalHistories().All(ctx, tx) + if err != nil { + t.Fatal(err) + } + + bFound, cFound := false, false + for _, v := range check { + if v.ExchangeNameID == b.ExchangeNameID { + bFound = true + } + if v.ExchangeNameID == c.ExchangeNameID { + cFound = true + } + } + + if !bFound { + t.Error("expected to find b") + } + if !cFound { + t.Error("expected to find c") + } + + slice := ExchangeSlice{&a} + if err = a.L.LoadExchangeNameWithdrawalHistories(ctx, tx, false, (*[]*Exchange)(&slice), nil); err != nil { + t.Fatal(err) + } + if got := len(a.R.ExchangeNameWithdrawalHistories); got != 2 { + t.Error("number of eager loaded records wrong, got:", got) + } + + a.R.ExchangeNameWithdrawalHistories = nil + if err = a.L.LoadExchangeNameWithdrawalHistories(ctx, tx, true, &a, nil); err != nil { + t.Fatal(err) + } + if got := len(a.R.ExchangeNameWithdrawalHistories); got != 2 { + t.Error("number of eager loaded records wrong, got:", got) + } + + if t.Failed() { + t.Logf("%#v", check) + } +} + +func testExchangeToManyAddOpExchangeNameCandles(t *testing.T) { + var err error + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Exchange + var b, c, d, e Candle + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + foreigners := []*Candle{&b, &c, &d, &e} + for _, x := range foreigners { + if err = randomize.Struct(seed, x, candleDBTypes, false, strmangle.SetComplement(candlePrimaryKeyColumns, candleColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = c.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + foreignersSplitByInsertion := [][]*Candle{ + {&b, &c}, + {&d, &e}, + } + + for i, x := range foreignersSplitByInsertion { + err = a.AddExchangeNameCandles(ctx, tx, i != 0, x...) + if err != nil { + t.Fatal(err) + } + + first := x[0] + second := x[1] + + if a.ID != first.ExchangeNameID { + t.Error("foreign key was wrong value", a.ID, first.ExchangeNameID) + } + if a.ID != second.ExchangeNameID { + t.Error("foreign key was wrong value", a.ID, second.ExchangeNameID) + } + + if first.R.ExchangeName != &a { + t.Error("relationship was not added properly to the foreign slice") + } + if second.R.ExchangeName != &a { + t.Error("relationship was not added properly to the foreign slice") + } + + if a.R.ExchangeNameCandles[i*2] != first { + t.Error("relationship struct slice not set to correct value") + } + if a.R.ExchangeNameCandles[i*2+1] != second { + t.Error("relationship struct slice not set to correct value") + } + + count, err := a.ExchangeNameCandles().Count(ctx, tx) + if err != nil { + t.Fatal(err) + } + if want := int64((i + 1) * 2); count != want { + t.Error("want", want, "got", count) + } + } +} +func testExchangeToManyAddOpExchangeNameWithdrawalHistories(t *testing.T) { + var err error + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Exchange + var b, c, d, e WithdrawalHistory + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + foreigners := []*WithdrawalHistory{&b, &c, &d, &e} + for _, x := range foreigners { + if err = randomize.Struct(seed, x, withdrawalHistoryDBTypes, false, strmangle.SetComplement(withdrawalHistoryPrimaryKeyColumns, withdrawalHistoryColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = c.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + foreignersSplitByInsertion := [][]*WithdrawalHistory{ + {&b, &c}, + {&d, &e}, + } + + for i, x := range foreignersSplitByInsertion { + err = a.AddExchangeNameWithdrawalHistories(ctx, tx, i != 0, x...) + if err != nil { + t.Fatal(err) + } + + first := x[0] + second := x[1] + + if a.ID != first.ExchangeNameID { + t.Error("foreign key was wrong value", a.ID, first.ExchangeNameID) + } + if a.ID != second.ExchangeNameID { + t.Error("foreign key was wrong value", a.ID, second.ExchangeNameID) + } + + if first.R.ExchangeName != &a { + t.Error("relationship was not added properly to the foreign slice") + } + if second.R.ExchangeName != &a { + t.Error("relationship was not added properly to the foreign slice") + } + + if a.R.ExchangeNameWithdrawalHistories[i*2] != first { + t.Error("relationship struct slice not set to correct value") + } + if a.R.ExchangeNameWithdrawalHistories[i*2+1] != second { + t.Error("relationship struct slice not set to correct value") + } + + count, err := a.ExchangeNameWithdrawalHistories().Count(ctx, tx) + if err != nil { + t.Fatal(err) + } + if want := int64((i + 1) * 2); count != want { + t.Error("want", want, "got", count) + } + } +} + +func testExchangesReload(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if err = o.Reload(ctx, tx); err != nil { + t.Error(err) + } +} + +func testExchangesReloadAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice := ExchangeSlice{o} + + if err = slice.ReloadAll(ctx, tx); err != nil { + t.Error(err) + } +} + +func testExchangesSelect(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice, err := Exchanges().All(ctx, tx) + if err != nil { + t.Error(err) + } + + if len(slice) != 1 { + t.Error("want one record, got:", len(slice)) + } +} + +var ( + exchangeDBTypes = map[string]string{`ID`: `uuid`, `Name`: `character varying`} + _ = bytes.MinRead +) + +func testExchangesUpdate(t *testing.T) { + t.Parallel() + + if 0 == len(exchangePrimaryKeyColumns) { + t.Skip("Skipping table with no primary key columns") + } + if len(exchangeAllColumns) == len(exchangePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } + + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only affect one row but affected", rowsAff) + } +} + +func testExchangesSliceUpdateAll(t *testing.T) { + t.Parallel() + + if len(exchangeAllColumns) == len(exchangePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } + + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + // Remove Primary keys and unique columns from what we plan to update + var fields []string + if strmangle.StringSliceMatch(exchangeAllColumns, exchangePrimaryKeyColumns) { + fields = exchangeAllColumns + } else { + fields = strmangle.SetComplement( + exchangeAllColumns, + exchangePrimaryKeyColumns, + ) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + typ := reflect.TypeOf(o).Elem() + n := typ.NumField() + + updateMap := M{} + for _, col := range fields { + for i := 0; i < n; i++ { + f := typ.Field(i) + if f.Tag.Get("boil") == col { + updateMap[col] = value.Field(i).Interface() + } + } + } + + slice := ExchangeSlice{o} + if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("wanted one record updated but got", rowsAff) + } +} + +func testExchangesUpsert(t *testing.T) { + t.Parallel() + + if len(exchangeAllColumns) == len(exchangePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + // Attempt the INSERT side of an UPSERT + o := Exchange{} + if err = randomize.Struct(seed, &o, exchangeDBTypes, true); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Upsert(ctx, tx, false, nil, boil.Infer(), boil.Infer()); err != nil { + t.Errorf("Unable to upsert Exchange: %s", err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + if count != 1 { + t.Error("want one record, got:", count) + } + + // Attempt the UPDATE side of an UPSERT + if err = randomize.Struct(seed, &o, exchangeDBTypes, false, exchangePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err = o.Upsert(ctx, tx, true, nil, boil.Infer(), boil.Infer()); err != nil { + t.Errorf("Unable to upsert Exchange: %s", err) + } + + count, err = Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + if count != 1 { + t.Error("want one record, got:", count) + } +} diff --git a/database/models/postgres/psql_suites_test.go b/database/models/postgres/psql_suites_test.go index dcb65ac3..1580a8cd 100644 --- a/database/models/postgres/psql_suites_test.go +++ b/database/models/postgres/psql_suites_test.go @@ -7,6 +7,6 @@ import "testing" func TestUpsert(t *testing.T) { t.Run("AuditEvents", testAuditEventsUpsert) + t.Run("Exchanges", testExchangesUpsert) t.Run("Scripts", testScriptsUpsert) - t.Run("WithdrawalHistories", testWithdrawalHistoriesUpsert) } diff --git a/database/models/postgres/withdrawal_crypto.go b/database/models/postgres/withdrawal_crypto.go index b9d25341..eb8c73e6 100644 --- a/database/models/postgres/withdrawal_crypto.go +++ b/database/models/postgres/withdrawal_crypto.go @@ -50,21 +50,6 @@ var WithdrawalCryptoColumns = struct { // Generated where -type whereHelperfloat64 struct{ field string } - -func (w whereHelperfloat64) EQ(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) } -func (w whereHelperfloat64) NEQ(x float64) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.NEQ, x) -} -func (w whereHelperfloat64) LT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) } -func (w whereHelperfloat64) LTE(x float64) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.LTE, x) -} -func (w whereHelperfloat64) GT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) } -func (w whereHelperfloat64) GTE(x float64) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.GTE, x) -} - var WithdrawalCryptoWhere = struct { ID whereHelperint64 WithdrawalCryptoID whereHelpernull_String diff --git a/database/models/postgres/withdrawal_fiat.go b/database/models/postgres/withdrawal_fiat.go index 7e359b56..773549ee 100644 --- a/database/models/postgres/withdrawal_fiat.go +++ b/database/models/postgres/withdrawal_fiat.go @@ -111,8 +111,8 @@ type withdrawalFiatL struct{} var ( withdrawalFiatAllColumns = []string{"id", "withdrawal_fiat_id", "bank_name", "bank_address", "bank_account_name", "bank_account_number", "bsb", "swift_code", "iban", "bank_code"} - withdrawalFiatColumnsWithoutDefault = []string{"withdrawal_fiat_id", "bank_name", "bank_address", "bank_account_name", "bank_account_number", "bsb", "swift_code", "iban", "bank_code"} - withdrawalFiatColumnsWithDefault = []string{"id"} + withdrawalFiatColumnsWithoutDefault = []string{"withdrawal_fiat_id", "bank_name", "bank_address", "bank_account_name", "bank_account_number", "bank_code"} + withdrawalFiatColumnsWithDefault = []string{"id", "bsb", "swift_code", "iban"} withdrawalFiatPrimaryKeyColumns = []string{"id"} ) diff --git a/database/models/postgres/withdrawal_history.go b/database/models/postgres/withdrawal_history.go index 6518fe0d..5bfcfe40 100644 --- a/database/models/postgres/withdrawal_history.go +++ b/database/models/postgres/withdrawal_history.go @@ -24,43 +24,43 @@ import ( // WithdrawalHistory is an object representing the database table. type WithdrawalHistory struct { - ID string `boil:"id" json:"id" toml:"id" yaml:"id"` - Exchange string `boil:"exchange" json:"exchange" toml:"exchange" yaml:"exchange"` - ExchangeID string `boil:"exchange_id" json:"exchange_id" toml:"exchange_id" yaml:"exchange_id"` - Status string `boil:"status" json:"status" toml:"status" yaml:"status"` - Currency string `boil:"currency" json:"currency" toml:"currency" yaml:"currency"` - Amount float64 `boil:"amount" json:"amount" toml:"amount" yaml:"amount"` - Description null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"` - WithdrawType int `boil:"withdraw_type" json:"withdraw_type" toml:"withdraw_type" yaml:"withdraw_type"` - CreatedAt time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"` - UpdatedAt time.Time `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"` + ID string `boil:"id" json:"id" toml:"id" yaml:"id"` + ExchangeID string `boil:"exchange_id" json:"exchange_id" toml:"exchange_id" yaml:"exchange_id"` + Status string `boil:"status" json:"status" toml:"status" yaml:"status"` + Currency string `boil:"currency" json:"currency" toml:"currency" yaml:"currency"` + Amount float64 `boil:"amount" json:"amount" toml:"amount" yaml:"amount"` + Description null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"` + WithdrawType int `boil:"withdraw_type" json:"withdraw_type" toml:"withdraw_type" yaml:"withdraw_type"` + CreatedAt time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"` + UpdatedAt time.Time `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"` + ExchangeNameID string `boil:"exchange_name_id" json:"exchange_name_id" toml:"exchange_name_id" yaml:"exchange_name_id"` R *withdrawalHistoryR `boil:"-" json:"-" toml:"-" yaml:"-"` L withdrawalHistoryL `boil:"-" json:"-" toml:"-" yaml:"-"` } var WithdrawalHistoryColumns = struct { - ID string - Exchange string - ExchangeID string - Status string - Currency string - Amount string - Description string - WithdrawType string - CreatedAt string - UpdatedAt string + ID string + ExchangeID string + Status string + Currency string + Amount string + Description string + WithdrawType string + CreatedAt string + UpdatedAt string + ExchangeNameID string }{ - ID: "id", - Exchange: "exchange", - ExchangeID: "exchange_id", - Status: "status", - Currency: "currency", - Amount: "amount", - Description: "description", - WithdrawType: "withdraw_type", - CreatedAt: "created_at", - UpdatedAt: "updated_at", + ID: "id", + ExchangeID: "exchange_id", + Status: "status", + Currency: "currency", + Amount: "amount", + Description: "description", + WithdrawType: "withdraw_type", + CreatedAt: "created_at", + UpdatedAt: "updated_at", + ExchangeNameID: "exchange_name_id", } // Generated where @@ -82,40 +82,43 @@ func (w whereHelperint) IN(slice []int) qm.QueryMod { } var WithdrawalHistoryWhere = struct { - ID whereHelperstring - Exchange whereHelperstring - ExchangeID whereHelperstring - Status whereHelperstring - Currency whereHelperstring - Amount whereHelperfloat64 - Description whereHelpernull_String - WithdrawType whereHelperint - CreatedAt whereHelpertime_Time - UpdatedAt whereHelpertime_Time + ID whereHelperstring + ExchangeID whereHelperstring + Status whereHelperstring + Currency whereHelperstring + Amount whereHelperfloat64 + Description whereHelpernull_String + WithdrawType whereHelperint + CreatedAt whereHelpertime_Time + UpdatedAt whereHelpertime_Time + ExchangeNameID whereHelperstring }{ - ID: whereHelperstring{field: "\"withdrawal_history\".\"id\""}, - Exchange: whereHelperstring{field: "\"withdrawal_history\".\"exchange\""}, - ExchangeID: whereHelperstring{field: "\"withdrawal_history\".\"exchange_id\""}, - Status: whereHelperstring{field: "\"withdrawal_history\".\"status\""}, - Currency: whereHelperstring{field: "\"withdrawal_history\".\"currency\""}, - Amount: whereHelperfloat64{field: "\"withdrawal_history\".\"amount\""}, - Description: whereHelpernull_String{field: "\"withdrawal_history\".\"description\""}, - WithdrawType: whereHelperint{field: "\"withdrawal_history\".\"withdraw_type\""}, - CreatedAt: whereHelpertime_Time{field: "\"withdrawal_history\".\"created_at\""}, - UpdatedAt: whereHelpertime_Time{field: "\"withdrawal_history\".\"updated_at\""}, + ID: whereHelperstring{field: "\"withdrawal_history\".\"id\""}, + ExchangeID: whereHelperstring{field: "\"withdrawal_history\".\"exchange_id\""}, + Status: whereHelperstring{field: "\"withdrawal_history\".\"status\""}, + Currency: whereHelperstring{field: "\"withdrawal_history\".\"currency\""}, + Amount: whereHelperfloat64{field: "\"withdrawal_history\".\"amount\""}, + Description: whereHelpernull_String{field: "\"withdrawal_history\".\"description\""}, + WithdrawType: whereHelperint{field: "\"withdrawal_history\".\"withdraw_type\""}, + CreatedAt: whereHelpertime_Time{field: "\"withdrawal_history\".\"created_at\""}, + UpdatedAt: whereHelpertime_Time{field: "\"withdrawal_history\".\"updated_at\""}, + ExchangeNameID: whereHelperstring{field: "\"withdrawal_history\".\"exchange_name_id\""}, } // WithdrawalHistoryRels is where relationship names are stored. var WithdrawalHistoryRels = struct { + ExchangeName string WithdrawalCryptoWithdrawalCryptos string WithdrawalFiatWithdrawalFiats string }{ + ExchangeName: "ExchangeName", WithdrawalCryptoWithdrawalCryptos: "WithdrawalCryptoWithdrawalCryptos", WithdrawalFiatWithdrawalFiats: "WithdrawalFiatWithdrawalFiats", } // withdrawalHistoryR is where relationships are stored. type withdrawalHistoryR struct { + ExchangeName *Exchange WithdrawalCryptoWithdrawalCryptos WithdrawalCryptoSlice WithdrawalFiatWithdrawalFiats WithdrawalFiatSlice } @@ -129,8 +132,8 @@ func (*withdrawalHistoryR) NewStruct() *withdrawalHistoryR { type withdrawalHistoryL struct{} var ( - withdrawalHistoryAllColumns = []string{"id", "exchange", "exchange_id", "status", "currency", "amount", "description", "withdraw_type", "created_at", "updated_at"} - withdrawalHistoryColumnsWithoutDefault = []string{"exchange", "exchange_id", "status", "currency", "amount", "description", "withdraw_type"} + withdrawalHistoryAllColumns = []string{"id", "exchange_id", "status", "currency", "amount", "description", "withdraw_type", "created_at", "updated_at", "exchange_name_id"} + withdrawalHistoryColumnsWithoutDefault = []string{"exchange_id", "status", "currency", "amount", "description", "withdraw_type", "exchange_name_id"} withdrawalHistoryColumnsWithDefault = []string{"id", "created_at", "updated_at"} withdrawalHistoryPrimaryKeyColumns = []string{"id"} ) @@ -410,6 +413,20 @@ func (q withdrawalHistoryQuery) Exists(ctx context.Context, exec boil.ContextExe return count > 0, nil } +// ExchangeName pointed to by the foreign key. +func (o *WithdrawalHistory) ExchangeName(mods ...qm.QueryMod) exchangeQuery { + queryMods := []qm.QueryMod{ + qm.Where("\"id\" = ?", o.ExchangeNameID), + } + + queryMods = append(queryMods, mods...) + + query := Exchanges(queryMods...) + queries.SetFrom(query.Query, "\"exchange\"") + + return query +} + // WithdrawalCryptoWithdrawalCryptos retrieves all the withdrawal_crypto's WithdrawalCryptos with an executor via withdrawal_crypto_id column. func (o *WithdrawalHistory) WithdrawalCryptoWithdrawalCryptos(mods ...qm.QueryMod) withdrawalCryptoQuery { var queryMods []qm.QueryMod @@ -452,6 +469,107 @@ func (o *WithdrawalHistory) WithdrawalFiatWithdrawalFiats(mods ...qm.QueryMod) w return query } +// LoadExchangeName allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for an N-1 relationship. +func (withdrawalHistoryL) LoadExchangeName(ctx context.Context, e boil.ContextExecutor, singular bool, maybeWithdrawalHistory interface{}, mods queries.Applicator) error { + var slice []*WithdrawalHistory + var object *WithdrawalHistory + + if singular { + object = maybeWithdrawalHistory.(*WithdrawalHistory) + } else { + slice = *maybeWithdrawalHistory.(*[]*WithdrawalHistory) + } + + args := make([]interface{}, 0, 1) + if singular { + if object.R == nil { + object.R = &withdrawalHistoryR{} + } + args = append(args, object.ExchangeNameID) + + } else { + Outer: + for _, obj := range slice { + if obj.R == nil { + obj.R = &withdrawalHistoryR{} + } + + for _, a := range args { + if a == obj.ExchangeNameID { + continue Outer + } + } + + args = append(args, obj.ExchangeNameID) + + } + } + + if len(args) == 0 { + return nil + } + + query := NewQuery(qm.From(`exchange`), qm.WhereIn(`exchange.id in ?`, args...)) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load Exchange") + } + + var resultSlice []*Exchange + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice Exchange") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results of eager load for exchange") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for exchange") + } + + if len(withdrawalHistoryAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + + if len(resultSlice) == 0 { + return nil + } + + if singular { + foreign := resultSlice[0] + object.R.ExchangeName = foreign + if foreign.R == nil { + foreign.R = &exchangeR{} + } + foreign.R.ExchangeNameWithdrawalHistories = append(foreign.R.ExchangeNameWithdrawalHistories, object) + return nil + } + + for _, local := range slice { + for _, foreign := range resultSlice { + if local.ExchangeNameID == foreign.ID { + local.R.ExchangeName = foreign + if foreign.R == nil { + foreign.R = &exchangeR{} + } + foreign.R.ExchangeNameWithdrawalHistories = append(foreign.R.ExchangeNameWithdrawalHistories, local) + break + } + } + } + + return nil +} + // LoadWithdrawalCryptoWithdrawalCryptos allows an eager lookup of values, cached into the // loaded structs of the objects. This is for a 1-M or N-M relationship. func (withdrawalHistoryL) LoadWithdrawalCryptoWithdrawalCryptos(ctx context.Context, e boil.ContextExecutor, singular bool, maybeWithdrawalHistory interface{}, mods queries.Applicator) error { @@ -642,6 +760,53 @@ func (withdrawalHistoryL) LoadWithdrawalFiatWithdrawalFiats(ctx context.Context, return nil } +// SetExchangeName of the withdrawalHistory to the related item. +// Sets o.R.ExchangeName to related. +// Adds o to related.R.ExchangeNameWithdrawalHistories. +func (o *WithdrawalHistory) SetExchangeName(ctx context.Context, exec boil.ContextExecutor, insert bool, related *Exchange) error { + var err error + if insert { + if err = related.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } + + updateQuery := fmt.Sprintf( + "UPDATE \"withdrawal_history\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, []string{"exchange_name_id"}), + strmangle.WhereClause("\"", "\"", 2, withdrawalHistoryPrimaryKeyColumns), + ) + values := []interface{}{related.ID, o.ID} + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, updateQuery) + fmt.Fprintln(boil.DebugWriter, values) + } + + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update local table") + } + + o.ExchangeNameID = related.ID + if o.R == nil { + o.R = &withdrawalHistoryR{ + ExchangeName: related, + } + } else { + o.R.ExchangeName = related + } + + if related.R == nil { + related.R = &exchangeR{ + ExchangeNameWithdrawalHistories: WithdrawalHistorySlice{o}, + } + } else { + related.R.ExchangeNameWithdrawalHistories = append(related.R.ExchangeNameWithdrawalHistories, o) + } + + return nil +} + // AddWithdrawalCryptoWithdrawalCryptos adds the given related objects to the existing relationships // of the withdrawal_history, optionally inserting them as new records. // Appends related to o.R.WithdrawalCryptoWithdrawalCryptos. diff --git a/database/models/postgres/withdrawal_history_test.go b/database/models/postgres/withdrawal_history_test.go index d4e68ecc..4b244664 100644 --- a/database/models/postgres/withdrawal_history_test.go +++ b/database/models/postgres/withdrawal_history_test.go @@ -1150,6 +1150,115 @@ func testWithdrawalHistoryToManyRemoveOpWithdrawalFiatWithdrawalFiats(t *testing } } +func testWithdrawalHistoryToOneExchangeUsingExchangeName(t *testing.T) { + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var local WithdrawalHistory + var foreign Exchange + + seed := randomize.NewSeed() + if err := randomize.Struct(seed, &local, withdrawalHistoryDBTypes, false, withdrawalHistoryColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize WithdrawalHistory struct: %s", err) + } + if err := randomize.Struct(seed, &foreign, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + local.ExchangeNameID = foreign.ID + if err := local.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + check, err := local.ExchangeName().One(ctx, tx) + if err != nil { + t.Fatal(err) + } + + if check.ID != foreign.ID { + t.Errorf("want: %v, got %v", foreign.ID, check.ID) + } + + slice := WithdrawalHistorySlice{&local} + if err = local.L.LoadExchangeName(ctx, tx, false, (*[]*WithdrawalHistory)(&slice), nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeName == nil { + t.Error("struct should have been eager loaded") + } + + local.R.ExchangeName = nil + if err = local.L.LoadExchangeName(ctx, tx, true, &local, nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeName == nil { + t.Error("struct should have been eager loaded") + } +} + +func testWithdrawalHistoryToOneSetOpExchangeUsingExchangeName(t *testing.T) { + var err error + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a WithdrawalHistory + var b, c Exchange + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, withdrawalHistoryDBTypes, false, strmangle.SetComplement(withdrawalHistoryPrimaryKeyColumns, withdrawalHistoryColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &b, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &c, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + for i, x := range []*Exchange{&b, &c} { + err = a.SetExchangeName(ctx, tx, i != 0, x) + if err != nil { + t.Fatal(err) + } + + if a.R.ExchangeName != x { + t.Error("relationship struct not set to correct value") + } + + if x.R.ExchangeNameWithdrawalHistories[0] != &a { + t.Error("failed to append to foreign relationship struct") + } + if a.ExchangeNameID != x.ID { + t.Error("foreign key was wrong value", a.ExchangeNameID) + } + + zero := reflect.Zero(reflect.TypeOf(a.ExchangeNameID)) + reflect.Indirect(reflect.ValueOf(&a.ExchangeNameID)).Set(zero) + + if err = a.Reload(ctx, tx); err != nil { + t.Fatal("failed to reload", err) + } + + if a.ExchangeNameID != x.ID { + t.Error("foreign key was wrong value", a.ExchangeNameID, x.ID) + } + } +} + func testWithdrawalHistoriesReload(t *testing.T) { t.Parallel() @@ -1224,7 +1333,7 @@ func testWithdrawalHistoriesSelect(t *testing.T) { } var ( - withdrawalHistoryDBTypes = map[string]string{`ID`: `uuid`, `Exchange`: `text`, `ExchangeID`: `text`, `Status`: `character varying`, `Currency`: `text`, `Amount`: `double precision`, `Description`: `text`, `WithdrawType`: `integer`, `CreatedAt`: `timestamp without time zone`, `UpdatedAt`: `timestamp without time zone`} + withdrawalHistoryDBTypes = map[string]string{`ID`: `uuid`, `ExchangeID`: `text`, `Status`: `character varying`, `Currency`: `text`, `Amount`: `double precision`, `Description`: `text`, `WithdrawType`: `integer`, `CreatedAt`: `timestamp without time zone`, `UpdatedAt`: `timestamp without time zone`, `ExchangeNameID`: `uuid`} _ = bytes.MinRead ) diff --git a/database/models/sqlite3/boil_suites_test.go b/database/models/sqlite3/boil_suites_test.go index 8ed14c29..821f981d 100644 --- a/database/models/sqlite3/boil_suites_test.go +++ b/database/models/sqlite3/boil_suites_test.go @@ -13,6 +13,8 @@ import "testing" // Separating the tests thusly grants avoidance of Postgres deadlocks. func TestParent(t *testing.T) { t.Run("AuditEvents", testAuditEvents) + t.Run("Candles", testCandles) + t.Run("Exchanges", testExchanges) t.Run("Scripts", testScripts) t.Run("ScriptExecutions", testScriptExecutions) t.Run("WithdrawalCryptos", testWithdrawalCryptos) @@ -22,6 +24,8 @@ func TestParent(t *testing.T) { func TestDelete(t *testing.T) { t.Run("AuditEvents", testAuditEventsDelete) + t.Run("Candles", testCandlesDelete) + t.Run("Exchanges", testExchangesDelete) t.Run("Scripts", testScriptsDelete) t.Run("ScriptExecutions", testScriptExecutionsDelete) t.Run("WithdrawalCryptos", testWithdrawalCryptosDelete) @@ -31,6 +35,8 @@ func TestDelete(t *testing.T) { func TestQueryDeleteAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsQueryDeleteAll) + t.Run("Candles", testCandlesQueryDeleteAll) + t.Run("Exchanges", testExchangesQueryDeleteAll) t.Run("Scripts", testScriptsQueryDeleteAll) t.Run("ScriptExecutions", testScriptExecutionsQueryDeleteAll) t.Run("WithdrawalCryptos", testWithdrawalCryptosQueryDeleteAll) @@ -40,6 +46,8 @@ func TestQueryDeleteAll(t *testing.T) { func TestSliceDeleteAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsSliceDeleteAll) + t.Run("Candles", testCandlesSliceDeleteAll) + t.Run("Exchanges", testExchangesSliceDeleteAll) t.Run("Scripts", testScriptsSliceDeleteAll) t.Run("ScriptExecutions", testScriptExecutionsSliceDeleteAll) t.Run("WithdrawalCryptos", testWithdrawalCryptosSliceDeleteAll) @@ -49,6 +57,8 @@ func TestSliceDeleteAll(t *testing.T) { func TestExists(t *testing.T) { t.Run("AuditEvents", testAuditEventsExists) + t.Run("Candles", testCandlesExists) + t.Run("Exchanges", testExchangesExists) t.Run("Scripts", testScriptsExists) t.Run("ScriptExecutions", testScriptExecutionsExists) t.Run("WithdrawalCryptos", testWithdrawalCryptosExists) @@ -58,6 +68,8 @@ func TestExists(t *testing.T) { func TestFind(t *testing.T) { t.Run("AuditEvents", testAuditEventsFind) + t.Run("Candles", testCandlesFind) + t.Run("Exchanges", testExchangesFind) t.Run("Scripts", testScriptsFind) t.Run("ScriptExecutions", testScriptExecutionsFind) t.Run("WithdrawalCryptos", testWithdrawalCryptosFind) @@ -67,6 +79,8 @@ func TestFind(t *testing.T) { func TestBind(t *testing.T) { t.Run("AuditEvents", testAuditEventsBind) + t.Run("Candles", testCandlesBind) + t.Run("Exchanges", testExchangesBind) t.Run("Scripts", testScriptsBind) t.Run("ScriptExecutions", testScriptExecutionsBind) t.Run("WithdrawalCryptos", testWithdrawalCryptosBind) @@ -76,6 +90,8 @@ func TestBind(t *testing.T) { func TestOne(t *testing.T) { t.Run("AuditEvents", testAuditEventsOne) + t.Run("Candles", testCandlesOne) + t.Run("Exchanges", testExchangesOne) t.Run("Scripts", testScriptsOne) t.Run("ScriptExecutions", testScriptExecutionsOne) t.Run("WithdrawalCryptos", testWithdrawalCryptosOne) @@ -85,6 +101,8 @@ func TestOne(t *testing.T) { func TestAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsAll) + t.Run("Candles", testCandlesAll) + t.Run("Exchanges", testExchangesAll) t.Run("Scripts", testScriptsAll) t.Run("ScriptExecutions", testScriptExecutionsAll) t.Run("WithdrawalCryptos", testWithdrawalCryptosAll) @@ -94,6 +112,8 @@ func TestAll(t *testing.T) { func TestCount(t *testing.T) { t.Run("AuditEvents", testAuditEventsCount) + t.Run("Candles", testCandlesCount) + t.Run("Exchanges", testExchangesCount) t.Run("Scripts", testScriptsCount) t.Run("ScriptExecutions", testScriptExecutionsCount) t.Run("WithdrawalCryptos", testWithdrawalCryptosCount) @@ -103,6 +123,8 @@ func TestCount(t *testing.T) { func TestHooks(t *testing.T) { t.Run("AuditEvents", testAuditEventsHooks) + t.Run("Candles", testCandlesHooks) + t.Run("Exchanges", testExchangesHooks) t.Run("Scripts", testScriptsHooks) t.Run("ScriptExecutions", testScriptExecutionsHooks) t.Run("WithdrawalCryptos", testWithdrawalCryptosHooks) @@ -113,6 +135,10 @@ func TestHooks(t *testing.T) { func TestInsert(t *testing.T) { t.Run("AuditEvents", testAuditEventsInsert) t.Run("AuditEvents", testAuditEventsInsertWhitelist) + t.Run("Candles", testCandlesInsert) + t.Run("Candles", testCandlesInsertWhitelist) + t.Run("Exchanges", testExchangesInsert) + t.Run("Exchanges", testExchangesInsertWhitelist) t.Run("Scripts", testScriptsInsert) t.Run("Scripts", testScriptsInsertWhitelist) t.Run("ScriptExecutions", testScriptExecutionsInsert) @@ -128,18 +154,23 @@ func TestInsert(t *testing.T) { // TestToOne tests cannot be run in parallel // or deadlocks can occur. func TestToOne(t *testing.T) { + t.Run("CandleToExchangeUsingExchangeName", testCandleToOneExchangeUsingExchangeName) t.Run("ScriptExecutionToScriptUsingScript", testScriptExecutionToOneScriptUsingScript) t.Run("WithdrawalCryptoToWithdrawalHistoryUsingWithdrawalHistory", testWithdrawalCryptoToOneWithdrawalHistoryUsingWithdrawalHistory) t.Run("WithdrawalFiatToWithdrawalHistoryUsingWithdrawalHistory", testWithdrawalFiatToOneWithdrawalHistoryUsingWithdrawalHistory) + t.Run("WithdrawalHistoryToExchangeUsingExchangeName", testWithdrawalHistoryToOneExchangeUsingExchangeName) } // TestOneToOne tests cannot be run in parallel // or deadlocks can occur. -func TestOneToOne(t *testing.T) {} +func TestOneToOne(t *testing.T) { + t.Run("ExchangeToCandleUsingExchangeNameCandle", testExchangeOneToOneCandleUsingExchangeNameCandle) +} // TestToMany tests cannot be run in parallel // or deadlocks can occur. func TestToMany(t *testing.T) { + t.Run("ExchangeToExchangeNameWithdrawalHistories", testExchangeToManyExchangeNameWithdrawalHistories) t.Run("ScriptToScriptExecutions", testScriptToManyScriptExecutions) t.Run("WithdrawalHistoryToWithdrawalCryptos", testWithdrawalHistoryToManyWithdrawalCryptos) t.Run("WithdrawalHistoryToWithdrawalFiats", testWithdrawalHistoryToManyWithdrawalFiats) @@ -148,9 +179,11 @@ func TestToMany(t *testing.T) { // TestToOneSet tests cannot be run in parallel // or deadlocks can occur. func TestToOneSet(t *testing.T) { + t.Run("CandleToExchangeUsingExchangeNameCandle", testCandleToOneSetOpExchangeUsingExchangeName) t.Run("ScriptExecutionToScriptUsingScriptExecutions", testScriptExecutionToOneSetOpScriptUsingScript) t.Run("WithdrawalCryptoToWithdrawalHistoryUsingWithdrawalCryptos", testWithdrawalCryptoToOneSetOpWithdrawalHistoryUsingWithdrawalHistory) t.Run("WithdrawalFiatToWithdrawalHistoryUsingWithdrawalFiats", testWithdrawalFiatToOneSetOpWithdrawalHistoryUsingWithdrawalHistory) + t.Run("WithdrawalHistoryToExchangeUsingExchangeNameWithdrawalHistories", testWithdrawalHistoryToOneSetOpExchangeUsingExchangeName) } // TestToOneRemove tests cannot be run in parallel @@ -159,7 +192,9 @@ func TestToOneRemove(t *testing.T) {} // TestOneToOneSet tests cannot be run in parallel // or deadlocks can occur. -func TestOneToOneSet(t *testing.T) {} +func TestOneToOneSet(t *testing.T) { + t.Run("ExchangeToCandleUsingExchangeNameCandle", testExchangeOneToOneSetOpCandleUsingExchangeNameCandle) +} // TestOneToOneRemove tests cannot be run in parallel // or deadlocks can occur. @@ -168,6 +203,7 @@ func TestOneToOneRemove(t *testing.T) {} // TestToManyAdd tests cannot be run in parallel // or deadlocks can occur. func TestToManyAdd(t *testing.T) { + t.Run("ExchangeToExchangeNameWithdrawalHistories", testExchangeToManyAddOpExchangeNameWithdrawalHistories) t.Run("ScriptToScriptExecutions", testScriptToManyAddOpScriptExecutions) t.Run("WithdrawalHistoryToWithdrawalCryptos", testWithdrawalHistoryToManyAddOpWithdrawalCryptos) t.Run("WithdrawalHistoryToWithdrawalFiats", testWithdrawalHistoryToManyAddOpWithdrawalFiats) @@ -183,6 +219,8 @@ func TestToManyRemove(t *testing.T) {} func TestReload(t *testing.T) { t.Run("AuditEvents", testAuditEventsReload) + t.Run("Candles", testCandlesReload) + t.Run("Exchanges", testExchangesReload) t.Run("Scripts", testScriptsReload) t.Run("ScriptExecutions", testScriptExecutionsReload) t.Run("WithdrawalCryptos", testWithdrawalCryptosReload) @@ -192,6 +230,8 @@ func TestReload(t *testing.T) { func TestReloadAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsReloadAll) + t.Run("Candles", testCandlesReloadAll) + t.Run("Exchanges", testExchangesReloadAll) t.Run("Scripts", testScriptsReloadAll) t.Run("ScriptExecutions", testScriptExecutionsReloadAll) t.Run("WithdrawalCryptos", testWithdrawalCryptosReloadAll) @@ -201,6 +241,8 @@ func TestReloadAll(t *testing.T) { func TestSelect(t *testing.T) { t.Run("AuditEvents", testAuditEventsSelect) + t.Run("Candles", testCandlesSelect) + t.Run("Exchanges", testExchangesSelect) t.Run("Scripts", testScriptsSelect) t.Run("ScriptExecutions", testScriptExecutionsSelect) t.Run("WithdrawalCryptos", testWithdrawalCryptosSelect) @@ -210,6 +252,8 @@ func TestSelect(t *testing.T) { func TestUpdate(t *testing.T) { t.Run("AuditEvents", testAuditEventsUpdate) + t.Run("Candles", testCandlesUpdate) + t.Run("Exchanges", testExchangesUpdate) t.Run("Scripts", testScriptsUpdate) t.Run("ScriptExecutions", testScriptExecutionsUpdate) t.Run("WithdrawalCryptos", testWithdrawalCryptosUpdate) @@ -219,6 +263,8 @@ func TestUpdate(t *testing.T) { func TestSliceUpdateAll(t *testing.T) { t.Run("AuditEvents", testAuditEventsSliceUpdateAll) + t.Run("Candles", testCandlesSliceUpdateAll) + t.Run("Exchanges", testExchangesSliceUpdateAll) t.Run("Scripts", testScriptsSliceUpdateAll) t.Run("ScriptExecutions", testScriptExecutionsSliceUpdateAll) t.Run("WithdrawalCryptos", testWithdrawalCryptosSliceUpdateAll) diff --git a/database/models/sqlite3/boil_table_names.go b/database/models/sqlite3/boil_table_names.go index 554f8970..97944900 100644 --- a/database/models/sqlite3/boil_table_names.go +++ b/database/models/sqlite3/boil_table_names.go @@ -5,6 +5,8 @@ package sqlite3 var TableNames = struct { AuditEvent string + Candle string + Exchange string Script string ScriptExecution string WithdrawalCrypto string @@ -12,6 +14,8 @@ var TableNames = struct { WithdrawalHistory string }{ AuditEvent: "audit_event", + Candle: "candle", + Exchange: "exchange", Script: "script", ScriptExecution: "script_execution", WithdrawalCrypto: "withdrawal_crypto", diff --git a/database/models/sqlite3/candle.go b/database/models/sqlite3/candle.go new file mode 100644 index 00000000..2fb45de7 --- /dev/null +++ b/database/models/sqlite3/candle.go @@ -0,0 +1,996 @@ +// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package sqlite3 + +import ( + "context" + "database/sql" + "fmt" + "reflect" + "strings" + "sync" + "time" + + "github.com/pkg/errors" + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries" + "github.com/thrasher-corp/sqlboiler/queries/qm" + "github.com/thrasher-corp/sqlboiler/queries/qmhelper" + "github.com/thrasher-corp/sqlboiler/strmangle" +) + +// Candle is an object representing the database table. +type Candle struct { + ID string `boil:"id" json:"id" toml:"id" yaml:"id"` + ExchangeNameID string `boil:"exchange_name_id" json:"exchange_name_id" toml:"exchange_name_id" yaml:"exchange_name_id"` + Base string `boil:"Base" json:"Base" toml:"Base" yaml:"Base"` + Quote string `boil:"Quote" json:"Quote" toml:"Quote" yaml:"Quote"` + Interval string `boil:"Interval" json:"Interval" toml:"Interval" yaml:"Interval"` + Timestamp string `boil:"Timestamp" json:"Timestamp" toml:"Timestamp" yaml:"Timestamp"` + Open float64 `boil:"Open" json:"Open" toml:"Open" yaml:"Open"` + High float64 `boil:"High" json:"High" toml:"High" yaml:"High"` + Low float64 `boil:"Low" json:"Low" toml:"Low" yaml:"Low"` + Close float64 `boil:"Close" json:"Close" toml:"Close" yaml:"Close"` + Volume float64 `boil:"Volume" json:"Volume" toml:"Volume" yaml:"Volume"` + Asset string `boil:"Asset" json:"Asset" toml:"Asset" yaml:"Asset"` + + R *candleR `boil:"-" json:"-" toml:"-" yaml:"-"` + L candleL `boil:"-" json:"-" toml:"-" yaml:"-"` +} + +var CandleColumns = struct { + ID string + ExchangeNameID string + Base string + Quote string + Interval string + Timestamp string + Open string + High string + Low string + Close string + Volume string + Asset string +}{ + ID: "id", + ExchangeNameID: "exchange_name_id", + Base: "Base", + Quote: "Quote", + Interval: "Interval", + Timestamp: "Timestamp", + Open: "Open", + High: "High", + Low: "Low", + Close: "Close", + Volume: "Volume", + Asset: "Asset", +} + +// Generated where + +type whereHelperfloat64 struct{ field string } + +func (w whereHelperfloat64) EQ(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) } +func (w whereHelperfloat64) NEQ(x float64) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.NEQ, x) +} +func (w whereHelperfloat64) LT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) } +func (w whereHelperfloat64) LTE(x float64) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.LTE, x) +} +func (w whereHelperfloat64) GT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) } +func (w whereHelperfloat64) GTE(x float64) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.GTE, x) +} + +var CandleWhere = struct { + ID whereHelperstring + ExchangeNameID whereHelperstring + Base whereHelperstring + Quote whereHelperstring + Interval whereHelperstring + Timestamp whereHelperstring + Open whereHelperfloat64 + High whereHelperfloat64 + Low whereHelperfloat64 + Close whereHelperfloat64 + Volume whereHelperfloat64 + Asset whereHelperstring +}{ + ID: whereHelperstring{field: "\"candle\".\"id\""}, + ExchangeNameID: whereHelperstring{field: "\"candle\".\"exchange_name_id\""}, + Base: whereHelperstring{field: "\"candle\".\"Base\""}, + Quote: whereHelperstring{field: "\"candle\".\"Quote\""}, + Interval: whereHelperstring{field: "\"candle\".\"Interval\""}, + Timestamp: whereHelperstring{field: "\"candle\".\"Timestamp\""}, + Open: whereHelperfloat64{field: "\"candle\".\"Open\""}, + High: whereHelperfloat64{field: "\"candle\".\"High\""}, + Low: whereHelperfloat64{field: "\"candle\".\"Low\""}, + Close: whereHelperfloat64{field: "\"candle\".\"Close\""}, + Volume: whereHelperfloat64{field: "\"candle\".\"Volume\""}, + Asset: whereHelperstring{field: "\"candle\".\"Asset\""}, +} + +// CandleRels is where relationship names are stored. +var CandleRels = struct { + ExchangeName string +}{ + ExchangeName: "ExchangeName", +} + +// candleR is where relationships are stored. +type candleR struct { + ExchangeName *Exchange +} + +// NewStruct creates a new relationship struct +func (*candleR) NewStruct() *candleR { + return &candleR{} +} + +// candleL is where Load methods for each relationship are stored. +type candleL struct{} + +var ( + candleAllColumns = []string{"id", "exchange_name_id", "Base", "Quote", "Interval", "Timestamp", "Open", "High", "Low", "Close", "Volume", "Asset"} + candleColumnsWithoutDefault = []string{"id", "exchange_name_id", "Base", "Quote", "Interval", "Timestamp", "Open", "High", "Low", "Close", "Volume", "Asset"} + candleColumnsWithDefault = []string{} + candlePrimaryKeyColumns = []string{"id"} +) + +type ( + // CandleSlice is an alias for a slice of pointers to Candle. + // This should generally be used opposed to []Candle. + CandleSlice []*Candle + // CandleHook is the signature for custom Candle hook methods + CandleHook func(context.Context, boil.ContextExecutor, *Candle) error + + candleQuery struct { + *queries.Query + } +) + +// Cache for insert, update and upsert +var ( + candleType = reflect.TypeOf(&Candle{}) + candleMapping = queries.MakeStructMapping(candleType) + candlePrimaryKeyMapping, _ = queries.BindMapping(candleType, candleMapping, candlePrimaryKeyColumns) + candleInsertCacheMut sync.RWMutex + candleInsertCache = make(map[string]insertCache) + candleUpdateCacheMut sync.RWMutex + candleUpdateCache = make(map[string]updateCache) + candleUpsertCacheMut sync.RWMutex + candleUpsertCache = make(map[string]insertCache) +) + +var ( + // Force time package dependency for automated UpdatedAt/CreatedAt. + _ = time.Second + // Force qmhelper dependency for where clause generation (which doesn't + // always happen) + _ = qmhelper.Where +) + +var candleBeforeInsertHooks []CandleHook +var candleBeforeUpdateHooks []CandleHook +var candleBeforeDeleteHooks []CandleHook +var candleBeforeUpsertHooks []CandleHook + +var candleAfterInsertHooks []CandleHook +var candleAfterSelectHooks []CandleHook +var candleAfterUpdateHooks []CandleHook +var candleAfterDeleteHooks []CandleHook +var candleAfterUpsertHooks []CandleHook + +// doBeforeInsertHooks executes all "before insert" hooks. +func (o *Candle) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleBeforeInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpdateHooks executes all "before Update" hooks. +func (o *Candle) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleBeforeUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeDeleteHooks executes all "before Delete" hooks. +func (o *Candle) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleBeforeDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpsertHooks executes all "before Upsert" hooks. +func (o *Candle) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleBeforeUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterInsertHooks executes all "after Insert" hooks. +func (o *Candle) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterSelectHooks executes all "after Select" hooks. +func (o *Candle) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterSelectHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpdateHooks executes all "after Update" hooks. +func (o *Candle) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterDeleteHooks executes all "after Delete" hooks. +func (o *Candle) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpsertHooks executes all "after Upsert" hooks. +func (o *Candle) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range candleAfterUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// AddCandleHook registers your hook function for all future operations. +func AddCandleHook(hookPoint boil.HookPoint, candleHook CandleHook) { + switch hookPoint { + case boil.BeforeInsertHook: + candleBeforeInsertHooks = append(candleBeforeInsertHooks, candleHook) + case boil.BeforeUpdateHook: + candleBeforeUpdateHooks = append(candleBeforeUpdateHooks, candleHook) + case boil.BeforeDeleteHook: + candleBeforeDeleteHooks = append(candleBeforeDeleteHooks, candleHook) + case boil.BeforeUpsertHook: + candleBeforeUpsertHooks = append(candleBeforeUpsertHooks, candleHook) + case boil.AfterInsertHook: + candleAfterInsertHooks = append(candleAfterInsertHooks, candleHook) + case boil.AfterSelectHook: + candleAfterSelectHooks = append(candleAfterSelectHooks, candleHook) + case boil.AfterUpdateHook: + candleAfterUpdateHooks = append(candleAfterUpdateHooks, candleHook) + case boil.AfterDeleteHook: + candleAfterDeleteHooks = append(candleAfterDeleteHooks, candleHook) + case boil.AfterUpsertHook: + candleAfterUpsertHooks = append(candleAfterUpsertHooks, candleHook) + } +} + +// One returns a single candle record from the query. +func (q candleQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Candle, error) { + o := &Candle{} + + queries.SetLimit(q.Query, 1) + + err := q.Bind(ctx, exec, o) + if err != nil { + if errors.Cause(err) == sql.ErrNoRows { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "sqlite3: failed to execute a one query for candle") + } + + if err := o.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + + return o, nil +} + +// All returns all Candle records from the query. +func (q candleQuery) All(ctx context.Context, exec boil.ContextExecutor) (CandleSlice, error) { + var o []*Candle + + err := q.Bind(ctx, exec, &o) + if err != nil { + return nil, errors.Wrap(err, "sqlite3: failed to assign all query results to Candle slice") + } + + if len(candleAfterSelectHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + } + } + + return o, nil +} + +// Count returns the count of all Candle records in the query. +func (q candleQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to count candle rows") + } + + return count, nil +} + +// Exists checks if the row exists in the table. +func (q candleQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + queries.SetLimit(q.Query, 1) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return false, errors.Wrap(err, "sqlite3: failed to check if candle exists") + } + + return count > 0, nil +} + +// ExchangeName pointed to by the foreign key. +func (o *Candle) ExchangeName(mods ...qm.QueryMod) exchangeQuery { + queryMods := []qm.QueryMod{ + qm.Where("\"id\" = ?", o.ExchangeNameID), + } + + queryMods = append(queryMods, mods...) + + query := Exchanges(queryMods...) + queries.SetFrom(query.Query, "\"exchange\"") + + return query +} + +// LoadExchangeName allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for an N-1 relationship. +func (candleL) LoadExchangeName(ctx context.Context, e boil.ContextExecutor, singular bool, maybeCandle interface{}, mods queries.Applicator) error { + var slice []*Candle + var object *Candle + + if singular { + object = maybeCandle.(*Candle) + } else { + slice = *maybeCandle.(*[]*Candle) + } + + args := make([]interface{}, 0, 1) + if singular { + if object.R == nil { + object.R = &candleR{} + } + args = append(args, object.ExchangeNameID) + + } else { + Outer: + for _, obj := range slice { + if obj.R == nil { + obj.R = &candleR{} + } + + for _, a := range args { + if a == obj.ExchangeNameID { + continue Outer + } + } + + args = append(args, obj.ExchangeNameID) + + } + } + + if len(args) == 0 { + return nil + } + + query := NewQuery(qm.From(`exchange`), qm.WhereIn(`exchange.id in ?`, args...)) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load Exchange") + } + + var resultSlice []*Exchange + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice Exchange") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results of eager load for exchange") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for exchange") + } + + if len(candleAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + + if len(resultSlice) == 0 { + return nil + } + + if singular { + foreign := resultSlice[0] + object.R.ExchangeName = foreign + if foreign.R == nil { + foreign.R = &exchangeR{} + } + foreign.R.ExchangeNameCandle = object + return nil + } + + for _, local := range slice { + for _, foreign := range resultSlice { + if local.ExchangeNameID == foreign.ID { + local.R.ExchangeName = foreign + if foreign.R == nil { + foreign.R = &exchangeR{} + } + foreign.R.ExchangeNameCandle = local + break + } + } + } + + return nil +} + +// SetExchangeName of the candle to the related item. +// Sets o.R.ExchangeName to related. +// Adds o to related.R.ExchangeNameCandle. +func (o *Candle) SetExchangeName(ctx context.Context, exec boil.ContextExecutor, insert bool, related *Exchange) error { + var err error + if insert { + if err = related.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } + + updateQuery := fmt.Sprintf( + "UPDATE \"candle\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 0, []string{"exchange_name_id"}), + strmangle.WhereClause("\"", "\"", 0, candlePrimaryKeyColumns), + ) + values := []interface{}{related.ID, o.ID} + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, updateQuery) + fmt.Fprintln(boil.DebugWriter, values) + } + + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update local table") + } + + o.ExchangeNameID = related.ID + if o.R == nil { + o.R = &candleR{ + ExchangeName: related, + } + } else { + o.R.ExchangeName = related + } + + if related.R == nil { + related.R = &exchangeR{ + ExchangeNameCandle: o, + } + } else { + related.R.ExchangeNameCandle = o + } + + return nil +} + +// Candles retrieves all the records using an executor. +func Candles(mods ...qm.QueryMod) candleQuery { + mods = append(mods, qm.From("\"candle\"")) + return candleQuery{NewQuery(mods...)} +} + +// FindCandle retrieves a single record by ID with an executor. +// If selectCols is empty Find will return all columns. +func FindCandle(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*Candle, error) { + candleObj := &Candle{} + + sel := "*" + if len(selectCols) > 0 { + sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") + } + query := fmt.Sprintf( + "select %s from \"candle\" where \"id\"=?", sel, + ) + + q := queries.Raw(query, iD) + + err := q.Bind(ctx, exec, candleObj) + if err != nil { + if errors.Cause(err) == sql.ErrNoRows { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "sqlite3: unable to select from candle") + } + + return candleObj, nil +} + +// Insert a single record using an executor. +// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. +func (o *Candle) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { + if o == nil { + return errors.New("sqlite3: no candle provided for insertion") + } + + var err error + + if err := o.doBeforeInsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(candleColumnsWithDefault, o) + + key := makeCacheKey(columns, nzDefaults) + candleInsertCacheMut.RLock() + cache, cached := candleInsertCache[key] + candleInsertCacheMut.RUnlock() + + if !cached { + wl, returnColumns := columns.InsertColumnSet( + candleAllColumns, + candleColumnsWithDefault, + candleColumnsWithoutDefault, + nzDefaults, + ) + + cache.valueMapping, err = queries.BindMapping(candleType, candleMapping, wl) + if err != nil { + return err + } + cache.retMapping, err = queries.BindMapping(candleType, candleMapping, returnColumns) + if err != nil { + return err + } + if len(wl) != 0 { + cache.query = fmt.Sprintf("INSERT INTO \"candle\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) + } else { + cache.query = "INSERT INTO \"candle\" () VALUES ()%s%s" + } + + var queryOutput, queryReturning string + + if len(cache.retMapping) != 0 { + cache.retQuery = fmt.Sprintf("SELECT \"%s\" FROM \"candle\" WHERE %s", strings.Join(returnColumns, "\",\""), strmangle.WhereClause("\"", "\"", 0, candlePrimaryKeyColumns)) + } + + cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, vals) + } + + _, err = exec.ExecContext(ctx, cache.query, vals...) + + if err != nil { + return errors.Wrap(err, "sqlite3: unable to insert into candle") + } + + var identifierCols []interface{} + + if len(cache.retMapping) == 0 { + goto CacheNoHooks + } + + identifierCols = []interface{}{ + o.ID, + } + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.retQuery) + fmt.Fprintln(boil.DebugWriter, identifierCols...) + } + + err = exec.QueryRowContext(ctx, cache.retQuery, identifierCols...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) + if err != nil { + return errors.Wrap(err, "sqlite3: unable to populate default values for candle") + } + +CacheNoHooks: + if !cached { + candleInsertCacheMut.Lock() + candleInsertCache[key] = cache + candleInsertCacheMut.Unlock() + } + + return o.doAfterInsertHooks(ctx, exec) +} + +// Update uses an executor to update the Candle. +// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. +// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. +func (o *Candle) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { + var err error + if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { + return 0, err + } + key := makeCacheKey(columns, nil) + candleUpdateCacheMut.RLock() + cache, cached := candleUpdateCache[key] + candleUpdateCacheMut.RUnlock() + + if !cached { + wl := columns.UpdateColumnSet( + candleAllColumns, + candlePrimaryKeyColumns, + ) + + if len(wl) == 0 { + return 0, errors.New("sqlite3: unable to update candle, could not build whitelist") + } + + cache.query = fmt.Sprintf("UPDATE \"candle\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 0, wl), + strmangle.WhereClause("\"", "\"", 0, candlePrimaryKeyColumns), + ) + cache.valueMapping, err = queries.BindMapping(candleType, candleMapping, append(wl, candlePrimaryKeyColumns...)) + if err != nil { + return 0, err + } + } + + values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, values) + } + + var result sql.Result + result, err = exec.ExecContext(ctx, cache.query, values...) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to update candle row") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by update for candle") + } + + if !cached { + candleUpdateCacheMut.Lock() + candleUpdateCache[key] = cache + candleUpdateCacheMut.Unlock() + } + + return rowsAff, o.doAfterUpdateHooks(ctx, exec) +} + +// UpdateAll updates all rows with the specified column values. +func (q candleQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + queries.SetUpdate(q.Query, cols) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to update all for candle") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to retrieve rows affected for candle") + } + + return rowsAff, nil +} + +// UpdateAll updates all rows with the specified column values, using an executor. +func (o CandleSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + ln := int64(len(o)) + if ln == 0 { + return 0, nil + } + + if len(cols) == 0 { + return 0, errors.New("sqlite3: update all requires at least one column argument") + } + + colNames := make([]string, len(cols)) + args := make([]interface{}, len(cols)) + + i := 0 + for name, value := range cols { + colNames[i] = name + args[i] = value + i++ + } + + // Append all of the primary key values for each column + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), candlePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := fmt.Sprintf("UPDATE \"candle\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 0, colNames), + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, candlePrimaryKeyColumns, len(o))) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args...) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to update all in candle slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to retrieve rows affected all in update all candle") + } + return rowsAff, nil +} + +// Delete deletes a single Candle record with an executor. +// Delete will match against the primary key column to find the record to delete. +func (o *Candle) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if o == nil { + return 0, errors.New("sqlite3: no Candle provided for delete") + } + + if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), candlePrimaryKeyMapping) + sql := "DELETE FROM \"candle\" WHERE \"id\"=?" + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args...) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to delete from candle") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by delete for candle") + } + + if err := o.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + return rowsAff, nil +} + +// DeleteAll deletes all matching rows. +func (q candleQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if q.Query == nil { + return 0, errors.New("sqlite3: no candleQuery provided for delete all") + } + + queries.SetDelete(q.Query) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to delete all from candle") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by deleteall for candle") + } + + return rowsAff, nil +} + +// DeleteAll deletes all rows in the slice, using an executor. +func (o CandleSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if len(o) == 0 { + return 0, nil + } + + if len(candleBeforeDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + var args []interface{} + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), candlePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "DELETE FROM \"candle\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, candlePrimaryKeyColumns, len(o)) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to delete all from candle slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by deleteall for candle") + } + + if len(candleAfterDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + return rowsAff, nil +} + +// Reload refetches the object from the database +// using the primary keys with an executor. +func (o *Candle) Reload(ctx context.Context, exec boil.ContextExecutor) error { + ret, err := FindCandle(ctx, exec, o.ID) + if err != nil { + return err + } + + *o = *ret + return nil +} + +// ReloadAll refetches every row with matching primary key column values +// and overwrites the original object slice with the newly updated slice. +func (o *CandleSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { + if o == nil || len(*o) == 0 { + return nil + } + + slice := CandleSlice{} + var args []interface{} + for _, obj := range *o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), candlePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "SELECT \"candle\".* FROM \"candle\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, candlePrimaryKeyColumns, len(*o)) + + q := queries.Raw(sql, args...) + + err := q.Bind(ctx, exec, &slice) + if err != nil { + return errors.Wrap(err, "sqlite3: unable to reload all in CandleSlice") + } + + *o = slice + + return nil +} + +// CandleExists checks if the Candle row exists. +func CandleExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { + var exists bool + sql := "select exists(select 1 from \"candle\" where \"id\"=? limit 1)" + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, iD) + } + + row := exec.QueryRowContext(ctx, sql, iD) + + err := row.Scan(&exists) + if err != nil { + return false, errors.Wrap(err, "sqlite3: unable to check if candle exists") + } + + return exists, nil +} diff --git a/database/models/sqlite3/candle_test.go b/database/models/sqlite3/candle_test.go new file mode 100644 index 00000000..e8d9f640 --- /dev/null +++ b/database/models/sqlite3/candle_test.go @@ -0,0 +1,793 @@ +// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package sqlite3 + +import ( + "bytes" + "context" + "reflect" + "testing" + + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries" + "github.com/thrasher-corp/sqlboiler/randomize" + "github.com/thrasher-corp/sqlboiler/strmangle" +) + +var ( + // Relationships sometimes use the reflection helper queries.Equal/queries.Assign + // so force a package dependency in case they don't. + _ = queries.Equal +) + +func testCandles(t *testing.T) { + t.Parallel() + + query := Candles() + + if query.Query == nil { + t.Error("expected a query, got nothing") + } +} + +func testCandlesDelete(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if rowsAff, err := o.Delete(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testCandlesQueryDeleteAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if rowsAff, err := Candles().DeleteAll(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testCandlesSliceDeleteAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice := CandleSlice{o} + + if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testCandlesExists(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + e, err := CandleExists(ctx, tx, o.ID) + if err != nil { + t.Errorf("Unable to check if Candle exists: %s", err) + } + if !e { + t.Errorf("Expected CandleExists to return true, but got false.") + } +} + +func testCandlesFind(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + candleFound, err := FindCandle(ctx, tx, o.ID) + if err != nil { + t.Error(err) + } + + if candleFound == nil { + t.Error("want a record, got nil") + } +} + +func testCandlesBind(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if err = Candles().Bind(ctx, tx, o); err != nil { + t.Error(err) + } +} + +func testCandlesOne(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if x, err := Candles().One(ctx, tx); err != nil { + t.Error(err) + } else if x == nil { + t.Error("expected to get a non nil record") + } +} + +func testCandlesAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + candleOne := &Candle{} + candleTwo := &Candle{} + if err = randomize.Struct(seed, candleOne, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + if err = randomize.Struct(seed, candleTwo, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = candleOne.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + if err = candleTwo.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice, err := Candles().All(ctx, tx) + if err != nil { + t.Error(err) + } + + if len(slice) != 2 { + t.Error("want 2 records, got:", len(slice)) + } +} + +func testCandlesCount(t *testing.T) { + t.Parallel() + + var err error + seed := randomize.NewSeed() + candleOne := &Candle{} + candleTwo := &Candle{} + if err = randomize.Struct(seed, candleOne, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + if err = randomize.Struct(seed, candleTwo, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = candleOne.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + if err = candleTwo.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 2 { + t.Error("want 2 records, got:", count) + } +} + +func candleBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func candleAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Candle) error { + *o = Candle{} + return nil +} + +func testCandlesHooks(t *testing.T) { + t.Parallel() + + var err error + + ctx := context.Background() + empty := &Candle{} + o := &Candle{} + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, o, candleDBTypes, false); err != nil { + t.Errorf("Unable to randomize Candle object: %s", err) + } + + AddCandleHook(boil.BeforeInsertHook, candleBeforeInsertHook) + if err = o.doBeforeInsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) + } + candleBeforeInsertHooks = []CandleHook{} + + AddCandleHook(boil.AfterInsertHook, candleAfterInsertHook) + if err = o.doAfterInsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterInsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) + } + candleAfterInsertHooks = []CandleHook{} + + AddCandleHook(boil.AfterSelectHook, candleAfterSelectHook) + if err = o.doAfterSelectHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterSelectHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) + } + candleAfterSelectHooks = []CandleHook{} + + AddCandleHook(boil.BeforeUpdateHook, candleBeforeUpdateHook) + if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) + } + candleBeforeUpdateHooks = []CandleHook{} + + AddCandleHook(boil.AfterUpdateHook, candleAfterUpdateHook) + if err = o.doAfterUpdateHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) + } + candleAfterUpdateHooks = []CandleHook{} + + AddCandleHook(boil.BeforeDeleteHook, candleBeforeDeleteHook) + if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) + } + candleBeforeDeleteHooks = []CandleHook{} + + AddCandleHook(boil.AfterDeleteHook, candleAfterDeleteHook) + if err = o.doAfterDeleteHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) + } + candleAfterDeleteHooks = []CandleHook{} + + AddCandleHook(boil.BeforeUpsertHook, candleBeforeUpsertHook) + if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) + } + candleBeforeUpsertHooks = []CandleHook{} + + AddCandleHook(boil.AfterUpsertHook, candleAfterUpsertHook) + if err = o.doAfterUpsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) + } + candleAfterUpsertHooks = []CandleHook{} +} + +func testCandlesInsert(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } +} + +func testCandlesInsertWhitelist(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Whitelist(candleColumnsWithoutDefault...)); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } +} + +func testCandleToOneExchangeUsingExchangeName(t *testing.T) { + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var local Candle + var foreign Exchange + + seed := randomize.NewSeed() + if err := randomize.Struct(seed, &local, candleDBTypes, false, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + if err := randomize.Struct(seed, &foreign, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + local.ExchangeNameID = foreign.ID + if err := local.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + check, err := local.ExchangeName().One(ctx, tx) + if err != nil { + t.Fatal(err) + } + + if check.ID != foreign.ID { + t.Errorf("want: %v, got %v", foreign.ID, check.ID) + } + + slice := CandleSlice{&local} + if err = local.L.LoadExchangeName(ctx, tx, false, (*[]*Candle)(&slice), nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeName == nil { + t.Error("struct should have been eager loaded") + } + + local.R.ExchangeName = nil + if err = local.L.LoadExchangeName(ctx, tx, true, &local, nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeName == nil { + t.Error("struct should have been eager loaded") + } +} + +func testCandleToOneSetOpExchangeUsingExchangeName(t *testing.T) { + var err error + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Candle + var b, c Exchange + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, candleDBTypes, false, strmangle.SetComplement(candlePrimaryKeyColumns, candleColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &b, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &c, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + for i, x := range []*Exchange{&b, &c} { + err = a.SetExchangeName(ctx, tx, i != 0, x) + if err != nil { + t.Fatal(err) + } + + if a.R.ExchangeName != x { + t.Error("relationship struct not set to correct value") + } + + if x.R.ExchangeNameCandle != &a { + t.Error("failed to append to foreign relationship struct") + } + if a.ExchangeNameID != x.ID { + t.Error("foreign key was wrong value", a.ExchangeNameID) + } + + zero := reflect.Zero(reflect.TypeOf(a.ExchangeNameID)) + reflect.Indirect(reflect.ValueOf(&a.ExchangeNameID)).Set(zero) + + if err = a.Reload(ctx, tx); err != nil { + t.Fatal("failed to reload", err) + } + + if a.ExchangeNameID != x.ID { + t.Error("foreign key was wrong value", a.ExchangeNameID, x.ID) + } + } +} + +func testCandlesReload(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if err = o.Reload(ctx, tx); err != nil { + t.Error(err) + } +} + +func testCandlesReloadAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice := CandleSlice{o} + + if err = slice.ReloadAll(ctx, tx); err != nil { + t.Error(err) + } +} + +func testCandlesSelect(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice, err := Candles().All(ctx, tx) + if err != nil { + t.Error(err) + } + + if len(slice) != 1 { + t.Error("want one record, got:", len(slice)) + } +} + +var ( + candleDBTypes = map[string]string{`ID`: `TEXT`, `ExchangeNameID`: `UUID`, `Base`: `TEXT`, `Quote`: `TEXT`, `Interval`: `TEXT`, `Timestamp`: `TIMESTAMP`, `Open`: `REAL`, `High`: `REAL`, `Low`: `REAL`, `Close`: `REAL`, `Volume`: `REAL`, `Asset`: `TEXT`} + _ = bytes.MinRead +) + +func testCandlesUpdate(t *testing.T) { + t.Parallel() + + if 0 == len(candlePrimaryKeyColumns) { + t.Skip("Skipping table with no primary key columns") + } + if len(candleAllColumns) == len(candlePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } + + if err = randomize.Struct(seed, o, candleDBTypes, true, candlePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only affect one row but affected", rowsAff) + } +} + +func testCandlesSliceUpdateAll(t *testing.T) { + t.Parallel() + + if len(candleAllColumns) == len(candlePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + o := &Candle{} + if err = randomize.Struct(seed, o, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Candles().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } + + if err = randomize.Struct(seed, o, candleDBTypes, true, candlePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + + // Remove Primary keys and unique columns from what we plan to update + var fields []string + if strmangle.StringSliceMatch(candleAllColumns, candlePrimaryKeyColumns) { + fields = candleAllColumns + } else { + fields = strmangle.SetComplement( + candleAllColumns, + candlePrimaryKeyColumns, + ) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + typ := reflect.TypeOf(o).Elem() + n := typ.NumField() + + updateMap := M{} + for _, col := range fields { + for i := 0; i < n; i++ { + f := typ.Field(i) + if f.Tag.Get("boil") == col { + updateMap[col] = value.Field(i).Interface() + } + } + } + + slice := CandleSlice{o} + if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("wanted one record updated but got", rowsAff) + } +} diff --git a/database/models/sqlite3/exchange.go b/database/models/sqlite3/exchange.go new file mode 100644 index 00000000..21d93091 --- /dev/null +++ b/database/models/sqlite3/exchange.go @@ -0,0 +1,1104 @@ +// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package sqlite3 + +import ( + "context" + "database/sql" + "fmt" + "reflect" + "strings" + "sync" + "time" + + "github.com/pkg/errors" + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries" + "github.com/thrasher-corp/sqlboiler/queries/qm" + "github.com/thrasher-corp/sqlboiler/queries/qmhelper" + "github.com/thrasher-corp/sqlboiler/strmangle" +) + +// Exchange is an object representing the database table. +type Exchange struct { + ID string `boil:"id" json:"id" toml:"id" yaml:"id"` + Name string `boil:"name" json:"name" toml:"name" yaml:"name"` + + R *exchangeR `boil:"-" json:"-" toml:"-" yaml:"-"` + L exchangeL `boil:"-" json:"-" toml:"-" yaml:"-"` +} + +var ExchangeColumns = struct { + ID string + Name string +}{ + ID: "id", + Name: "name", +} + +// Generated where + +var ExchangeWhere = struct { + ID whereHelperstring + Name whereHelperstring +}{ + ID: whereHelperstring{field: "\"exchange\".\"id\""}, + Name: whereHelperstring{field: "\"exchange\".\"name\""}, +} + +// ExchangeRels is where relationship names are stored. +var ExchangeRels = struct { + ExchangeNameCandle string + ExchangeNameWithdrawalHistories string +}{ + ExchangeNameCandle: "ExchangeNameCandle", + ExchangeNameWithdrawalHistories: "ExchangeNameWithdrawalHistories", +} + +// exchangeR is where relationships are stored. +type exchangeR struct { + ExchangeNameCandle *Candle + ExchangeNameWithdrawalHistories WithdrawalHistorySlice +} + +// NewStruct creates a new relationship struct +func (*exchangeR) NewStruct() *exchangeR { + return &exchangeR{} +} + +// exchangeL is where Load methods for each relationship are stored. +type exchangeL struct{} + +var ( + exchangeAllColumns = []string{"id", "name"} + exchangeColumnsWithoutDefault = []string{"id", "name"} + exchangeColumnsWithDefault = []string{} + exchangePrimaryKeyColumns = []string{"id"} +) + +type ( + // ExchangeSlice is an alias for a slice of pointers to Exchange. + // This should generally be used opposed to []Exchange. + ExchangeSlice []*Exchange + // ExchangeHook is the signature for custom Exchange hook methods + ExchangeHook func(context.Context, boil.ContextExecutor, *Exchange) error + + exchangeQuery struct { + *queries.Query + } +) + +// Cache for insert, update and upsert +var ( + exchangeType = reflect.TypeOf(&Exchange{}) + exchangeMapping = queries.MakeStructMapping(exchangeType) + exchangePrimaryKeyMapping, _ = queries.BindMapping(exchangeType, exchangeMapping, exchangePrimaryKeyColumns) + exchangeInsertCacheMut sync.RWMutex + exchangeInsertCache = make(map[string]insertCache) + exchangeUpdateCacheMut sync.RWMutex + exchangeUpdateCache = make(map[string]updateCache) + exchangeUpsertCacheMut sync.RWMutex + exchangeUpsertCache = make(map[string]insertCache) +) + +var ( + // Force time package dependency for automated UpdatedAt/CreatedAt. + _ = time.Second + // Force qmhelper dependency for where clause generation (which doesn't + // always happen) + _ = qmhelper.Where +) + +var exchangeBeforeInsertHooks []ExchangeHook +var exchangeBeforeUpdateHooks []ExchangeHook +var exchangeBeforeDeleteHooks []ExchangeHook +var exchangeBeforeUpsertHooks []ExchangeHook + +var exchangeAfterInsertHooks []ExchangeHook +var exchangeAfterSelectHooks []ExchangeHook +var exchangeAfterUpdateHooks []ExchangeHook +var exchangeAfterDeleteHooks []ExchangeHook +var exchangeAfterUpsertHooks []ExchangeHook + +// doBeforeInsertHooks executes all "before insert" hooks. +func (o *Exchange) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeBeforeInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpdateHooks executes all "before Update" hooks. +func (o *Exchange) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeBeforeUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeDeleteHooks executes all "before Delete" hooks. +func (o *Exchange) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeBeforeDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpsertHooks executes all "before Upsert" hooks. +func (o *Exchange) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeBeforeUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterInsertHooks executes all "after Insert" hooks. +func (o *Exchange) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterSelectHooks executes all "after Select" hooks. +func (o *Exchange) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterSelectHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpdateHooks executes all "after Update" hooks. +func (o *Exchange) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterDeleteHooks executes all "after Delete" hooks. +func (o *Exchange) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpsertHooks executes all "after Upsert" hooks. +func (o *Exchange) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range exchangeAfterUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// AddExchangeHook registers your hook function for all future operations. +func AddExchangeHook(hookPoint boil.HookPoint, exchangeHook ExchangeHook) { + switch hookPoint { + case boil.BeforeInsertHook: + exchangeBeforeInsertHooks = append(exchangeBeforeInsertHooks, exchangeHook) + case boil.BeforeUpdateHook: + exchangeBeforeUpdateHooks = append(exchangeBeforeUpdateHooks, exchangeHook) + case boil.BeforeDeleteHook: + exchangeBeforeDeleteHooks = append(exchangeBeforeDeleteHooks, exchangeHook) + case boil.BeforeUpsertHook: + exchangeBeforeUpsertHooks = append(exchangeBeforeUpsertHooks, exchangeHook) + case boil.AfterInsertHook: + exchangeAfterInsertHooks = append(exchangeAfterInsertHooks, exchangeHook) + case boil.AfterSelectHook: + exchangeAfterSelectHooks = append(exchangeAfterSelectHooks, exchangeHook) + case boil.AfterUpdateHook: + exchangeAfterUpdateHooks = append(exchangeAfterUpdateHooks, exchangeHook) + case boil.AfterDeleteHook: + exchangeAfterDeleteHooks = append(exchangeAfterDeleteHooks, exchangeHook) + case boil.AfterUpsertHook: + exchangeAfterUpsertHooks = append(exchangeAfterUpsertHooks, exchangeHook) + } +} + +// One returns a single exchange record from the query. +func (q exchangeQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Exchange, error) { + o := &Exchange{} + + queries.SetLimit(q.Query, 1) + + err := q.Bind(ctx, exec, o) + if err != nil { + if errors.Cause(err) == sql.ErrNoRows { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "sqlite3: failed to execute a one query for exchange") + } + + if err := o.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + + return o, nil +} + +// All returns all Exchange records from the query. +func (q exchangeQuery) All(ctx context.Context, exec boil.ContextExecutor) (ExchangeSlice, error) { + var o []*Exchange + + err := q.Bind(ctx, exec, &o) + if err != nil { + return nil, errors.Wrap(err, "sqlite3: failed to assign all query results to Exchange slice") + } + + if len(exchangeAfterSelectHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + } + } + + return o, nil +} + +// Count returns the count of all Exchange records in the query. +func (q exchangeQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to count exchange rows") + } + + return count, nil +} + +// Exists checks if the row exists in the table. +func (q exchangeQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + queries.SetLimit(q.Query, 1) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return false, errors.Wrap(err, "sqlite3: failed to check if exchange exists") + } + + return count > 0, nil +} + +// ExchangeNameCandle pointed to by the foreign key. +func (o *Exchange) ExchangeNameCandle(mods ...qm.QueryMod) candleQuery { + queryMods := []qm.QueryMod{ + qm.Where("\"exchange_name_id\" = ?", o.ID), + } + + queryMods = append(queryMods, mods...) + + query := Candles(queryMods...) + queries.SetFrom(query.Query, "\"candle\"") + + return query +} + +// ExchangeNameWithdrawalHistories retrieves all the withdrawal_history's WithdrawalHistories with an executor via exchange_name_id column. +func (o *Exchange) ExchangeNameWithdrawalHistories(mods ...qm.QueryMod) withdrawalHistoryQuery { + var queryMods []qm.QueryMod + if len(mods) != 0 { + queryMods = append(queryMods, mods...) + } + + queryMods = append(queryMods, + qm.Where("\"withdrawal_history\".\"exchange_name_id\"=?", o.ID), + ) + + query := WithdrawalHistories(queryMods...) + queries.SetFrom(query.Query, "\"withdrawal_history\"") + + if len(queries.GetSelect(query.Query)) == 0 { + queries.SetSelect(query.Query, []string{"\"withdrawal_history\".*"}) + } + + return query +} + +// LoadExchangeNameCandle allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for a 1-1 relationship. +func (exchangeL) LoadExchangeNameCandle(ctx context.Context, e boil.ContextExecutor, singular bool, maybeExchange interface{}, mods queries.Applicator) error { + var slice []*Exchange + var object *Exchange + + if singular { + object = maybeExchange.(*Exchange) + } else { + slice = *maybeExchange.(*[]*Exchange) + } + + args := make([]interface{}, 0, 1) + if singular { + if object.R == nil { + object.R = &exchangeR{} + } + args = append(args, object.ID) + } else { + Outer: + for _, obj := range slice { + if obj.R == nil { + obj.R = &exchangeR{} + } + + for _, a := range args { + if a == obj.ID { + continue Outer + } + } + + args = append(args, obj.ID) + } + } + + if len(args) == 0 { + return nil + } + + query := NewQuery(qm.From(`candle`), qm.WhereIn(`candle.exchange_name_id in ?`, args...)) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load Candle") + } + + var resultSlice []*Candle + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice Candle") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results of eager load for candle") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for candle") + } + + if len(exchangeAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + + if len(resultSlice) == 0 { + return nil + } + + if singular { + foreign := resultSlice[0] + object.R.ExchangeNameCandle = foreign + if foreign.R == nil { + foreign.R = &candleR{} + } + foreign.R.ExchangeName = object + } + + for _, local := range slice { + for _, foreign := range resultSlice { + if local.ID == foreign.ExchangeNameID { + local.R.ExchangeNameCandle = foreign + if foreign.R == nil { + foreign.R = &candleR{} + } + foreign.R.ExchangeName = local + break + } + } + } + + return nil +} + +// LoadExchangeNameWithdrawalHistories allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for a 1-M or N-M relationship. +func (exchangeL) LoadExchangeNameWithdrawalHistories(ctx context.Context, e boil.ContextExecutor, singular bool, maybeExchange interface{}, mods queries.Applicator) error { + var slice []*Exchange + var object *Exchange + + if singular { + object = maybeExchange.(*Exchange) + } else { + slice = *maybeExchange.(*[]*Exchange) + } + + args := make([]interface{}, 0, 1) + if singular { + if object.R == nil { + object.R = &exchangeR{} + } + args = append(args, object.ID) + } else { + Outer: + for _, obj := range slice { + if obj.R == nil { + obj.R = &exchangeR{} + } + + for _, a := range args { + if a == obj.ID { + continue Outer + } + } + + args = append(args, obj.ID) + } + } + + if len(args) == 0 { + return nil + } + + query := NewQuery(qm.From(`withdrawal_history`), qm.WhereIn(`withdrawal_history.exchange_name_id in ?`, args...)) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load withdrawal_history") + } + + var resultSlice []*WithdrawalHistory + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice withdrawal_history") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results in eager load on withdrawal_history") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for withdrawal_history") + } + + if len(withdrawalHistoryAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + if singular { + object.R.ExchangeNameWithdrawalHistories = resultSlice + for _, foreign := range resultSlice { + if foreign.R == nil { + foreign.R = &withdrawalHistoryR{} + } + foreign.R.ExchangeName = object + } + return nil + } + + for _, foreign := range resultSlice { + for _, local := range slice { + if local.ID == foreign.ExchangeNameID { + local.R.ExchangeNameWithdrawalHistories = append(local.R.ExchangeNameWithdrawalHistories, foreign) + if foreign.R == nil { + foreign.R = &withdrawalHistoryR{} + } + foreign.R.ExchangeName = local + break + } + } + } + + return nil +} + +// SetExchangeNameCandle of the exchange to the related item. +// Sets o.R.ExchangeNameCandle to related. +// Adds o to related.R.ExchangeName. +func (o *Exchange) SetExchangeNameCandle(ctx context.Context, exec boil.ContextExecutor, insert bool, related *Candle) error { + var err error + + if insert { + related.ExchangeNameID = o.ID + + if err = related.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } else { + updateQuery := fmt.Sprintf( + "UPDATE \"candle\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 0, []string{"exchange_name_id"}), + strmangle.WhereClause("\"", "\"", 0, candlePrimaryKeyColumns), + ) + values := []interface{}{o.ID, related.ID} + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, updateQuery) + fmt.Fprintln(boil.DebugWriter, values) + } + + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update foreign table") + } + + related.ExchangeNameID = o.ID + + } + + if o.R == nil { + o.R = &exchangeR{ + ExchangeNameCandle: related, + } + } else { + o.R.ExchangeNameCandle = related + } + + if related.R == nil { + related.R = &candleR{ + ExchangeName: o, + } + } else { + related.R.ExchangeName = o + } + return nil +} + +// AddExchangeNameWithdrawalHistories adds the given related objects to the existing relationships +// of the exchange, optionally inserting them as new records. +// Appends related to o.R.ExchangeNameWithdrawalHistories. +// Sets related.R.ExchangeName appropriately. +func (o *Exchange) AddExchangeNameWithdrawalHistories(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*WithdrawalHistory) error { + var err error + for _, rel := range related { + if insert { + rel.ExchangeNameID = o.ID + if err = rel.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } else { + updateQuery := fmt.Sprintf( + "UPDATE \"withdrawal_history\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 0, []string{"exchange_name_id"}), + strmangle.WhereClause("\"", "\"", 0, withdrawalHistoryPrimaryKeyColumns), + ) + values := []interface{}{o.ID, rel.ID} + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, updateQuery) + fmt.Fprintln(boil.DebugWriter, values) + } + + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update foreign table") + } + + rel.ExchangeNameID = o.ID + } + } + + if o.R == nil { + o.R = &exchangeR{ + ExchangeNameWithdrawalHistories: related, + } + } else { + o.R.ExchangeNameWithdrawalHistories = append(o.R.ExchangeNameWithdrawalHistories, related...) + } + + for _, rel := range related { + if rel.R == nil { + rel.R = &withdrawalHistoryR{ + ExchangeName: o, + } + } else { + rel.R.ExchangeName = o + } + } + return nil +} + +// Exchanges retrieves all the records using an executor. +func Exchanges(mods ...qm.QueryMod) exchangeQuery { + mods = append(mods, qm.From("\"exchange\"")) + return exchangeQuery{NewQuery(mods...)} +} + +// FindExchange retrieves a single record by ID with an executor. +// If selectCols is empty Find will return all columns. +func FindExchange(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*Exchange, error) { + exchangeObj := &Exchange{} + + sel := "*" + if len(selectCols) > 0 { + sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") + } + query := fmt.Sprintf( + "select %s from \"exchange\" where \"id\"=?", sel, + ) + + q := queries.Raw(query, iD) + + err := q.Bind(ctx, exec, exchangeObj) + if err != nil { + if errors.Cause(err) == sql.ErrNoRows { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "sqlite3: unable to select from exchange") + } + + return exchangeObj, nil +} + +// Insert a single record using an executor. +// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. +func (o *Exchange) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { + if o == nil { + return errors.New("sqlite3: no exchange provided for insertion") + } + + var err error + + if err := o.doBeforeInsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(exchangeColumnsWithDefault, o) + + key := makeCacheKey(columns, nzDefaults) + exchangeInsertCacheMut.RLock() + cache, cached := exchangeInsertCache[key] + exchangeInsertCacheMut.RUnlock() + + if !cached { + wl, returnColumns := columns.InsertColumnSet( + exchangeAllColumns, + exchangeColumnsWithDefault, + exchangeColumnsWithoutDefault, + nzDefaults, + ) + + cache.valueMapping, err = queries.BindMapping(exchangeType, exchangeMapping, wl) + if err != nil { + return err + } + cache.retMapping, err = queries.BindMapping(exchangeType, exchangeMapping, returnColumns) + if err != nil { + return err + } + if len(wl) != 0 { + cache.query = fmt.Sprintf("INSERT INTO \"exchange\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) + } else { + cache.query = "INSERT INTO \"exchange\" () VALUES ()%s%s" + } + + var queryOutput, queryReturning string + + if len(cache.retMapping) != 0 { + cache.retQuery = fmt.Sprintf("SELECT \"%s\" FROM \"exchange\" WHERE %s", strings.Join(returnColumns, "\",\""), strmangle.WhereClause("\"", "\"", 0, exchangePrimaryKeyColumns)) + } + + cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, vals) + } + + _, err = exec.ExecContext(ctx, cache.query, vals...) + + if err != nil { + return errors.Wrap(err, "sqlite3: unable to insert into exchange") + } + + var identifierCols []interface{} + + if len(cache.retMapping) == 0 { + goto CacheNoHooks + } + + identifierCols = []interface{}{ + o.ID, + } + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.retQuery) + fmt.Fprintln(boil.DebugWriter, identifierCols...) + } + + err = exec.QueryRowContext(ctx, cache.retQuery, identifierCols...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) + if err != nil { + return errors.Wrap(err, "sqlite3: unable to populate default values for exchange") + } + +CacheNoHooks: + if !cached { + exchangeInsertCacheMut.Lock() + exchangeInsertCache[key] = cache + exchangeInsertCacheMut.Unlock() + } + + return o.doAfterInsertHooks(ctx, exec) +} + +// Update uses an executor to update the Exchange. +// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. +// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. +func (o *Exchange) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { + var err error + if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { + return 0, err + } + key := makeCacheKey(columns, nil) + exchangeUpdateCacheMut.RLock() + cache, cached := exchangeUpdateCache[key] + exchangeUpdateCacheMut.RUnlock() + + if !cached { + wl := columns.UpdateColumnSet( + exchangeAllColumns, + exchangePrimaryKeyColumns, + ) + + if len(wl) == 0 { + return 0, errors.New("sqlite3: unable to update exchange, could not build whitelist") + } + + cache.query = fmt.Sprintf("UPDATE \"exchange\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 0, wl), + strmangle.WhereClause("\"", "\"", 0, exchangePrimaryKeyColumns), + ) + cache.valueMapping, err = queries.BindMapping(exchangeType, exchangeMapping, append(wl, exchangePrimaryKeyColumns...)) + if err != nil { + return 0, err + } + } + + values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, cache.query) + fmt.Fprintln(boil.DebugWriter, values) + } + + var result sql.Result + result, err = exec.ExecContext(ctx, cache.query, values...) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to update exchange row") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by update for exchange") + } + + if !cached { + exchangeUpdateCacheMut.Lock() + exchangeUpdateCache[key] = cache + exchangeUpdateCacheMut.Unlock() + } + + return rowsAff, o.doAfterUpdateHooks(ctx, exec) +} + +// UpdateAll updates all rows with the specified column values. +func (q exchangeQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + queries.SetUpdate(q.Query, cols) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to update all for exchange") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to retrieve rows affected for exchange") + } + + return rowsAff, nil +} + +// UpdateAll updates all rows with the specified column values, using an executor. +func (o ExchangeSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + ln := int64(len(o)) + if ln == 0 { + return 0, nil + } + + if len(cols) == 0 { + return 0, errors.New("sqlite3: update all requires at least one column argument") + } + + colNames := make([]string, len(cols)) + args := make([]interface{}, len(cols)) + + i := 0 + for name, value := range cols { + colNames[i] = name + args[i] = value + i++ + } + + // Append all of the primary key values for each column + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), exchangePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := fmt.Sprintf("UPDATE \"exchange\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 0, colNames), + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, exchangePrimaryKeyColumns, len(o))) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args...) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to update all in exchange slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to retrieve rows affected all in update all exchange") + } + return rowsAff, nil +} + +// Delete deletes a single Exchange record with an executor. +// Delete will match against the primary key column to find the record to delete. +func (o *Exchange) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if o == nil { + return 0, errors.New("sqlite3: no Exchange provided for delete") + } + + if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), exchangePrimaryKeyMapping) + sql := "DELETE FROM \"exchange\" WHERE \"id\"=?" + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args...) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to delete from exchange") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by delete for exchange") + } + + if err := o.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + return rowsAff, nil +} + +// DeleteAll deletes all matching rows. +func (q exchangeQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if q.Query == nil { + return 0, errors.New("sqlite3: no exchangeQuery provided for delete all") + } + + queries.SetDelete(q.Query) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to delete all from exchange") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by deleteall for exchange") + } + + return rowsAff, nil +} + +// DeleteAll deletes all rows in the slice, using an executor. +func (o ExchangeSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if len(o) == 0 { + return 0, nil + } + + if len(exchangeBeforeDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + var args []interface{} + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), exchangePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "DELETE FROM \"exchange\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, exchangePrimaryKeyColumns, len(o)) + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, args) + } + + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "sqlite3: unable to delete all from exchange slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by deleteall for exchange") + } + + if len(exchangeAfterDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + return rowsAff, nil +} + +// Reload refetches the object from the database +// using the primary keys with an executor. +func (o *Exchange) Reload(ctx context.Context, exec boil.ContextExecutor) error { + ret, err := FindExchange(ctx, exec, o.ID) + if err != nil { + return err + } + + *o = *ret + return nil +} + +// ReloadAll refetches every row with matching primary key column values +// and overwrites the original object slice with the newly updated slice. +func (o *ExchangeSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { + if o == nil || len(*o) == 0 { + return nil + } + + slice := ExchangeSlice{} + var args []interface{} + for _, obj := range *o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), exchangePrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "SELECT \"exchange\".* FROM \"exchange\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, exchangePrimaryKeyColumns, len(*o)) + + q := queries.Raw(sql, args...) + + err := q.Bind(ctx, exec, &slice) + if err != nil { + return errors.Wrap(err, "sqlite3: unable to reload all in ExchangeSlice") + } + + *o = slice + + return nil +} + +// ExchangeExists checks if the Exchange row exists. +func ExchangeExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { + var exists bool + sql := "select exists(select 1 from \"exchange\" where \"id\"=? limit 1)" + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, sql) + fmt.Fprintln(boil.DebugWriter, iD) + } + + row := exec.QueryRowContext(ctx, sql, iD) + + err := row.Scan(&exists) + if err != nil { + return false, errors.Wrap(err, "sqlite3: unable to check if exchange exists") + } + + return exists, nil +} diff --git a/database/models/sqlite3/exchange_test.go b/database/models/sqlite3/exchange_test.go new file mode 100644 index 00000000..f348f874 --- /dev/null +++ b/database/models/sqlite3/exchange_test.go @@ -0,0 +1,951 @@ +// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package sqlite3 + +import ( + "bytes" + "context" + "reflect" + "testing" + + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries" + "github.com/thrasher-corp/sqlboiler/randomize" + "github.com/thrasher-corp/sqlboiler/strmangle" +) + +var ( + // Relationships sometimes use the reflection helper queries.Equal/queries.Assign + // so force a package dependency in case they don't. + _ = queries.Equal +) + +func testExchanges(t *testing.T) { + t.Parallel() + + query := Exchanges() + + if query.Query == nil { + t.Error("expected a query, got nothing") + } +} + +func testExchangesDelete(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if rowsAff, err := o.Delete(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testExchangesQueryDeleteAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if rowsAff, err := Exchanges().DeleteAll(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testExchangesSliceDeleteAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice := ExchangeSlice{o} + + if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only have deleted one row, but affected:", rowsAff) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 0 { + t.Error("want zero records, got:", count) + } +} + +func testExchangesExists(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + e, err := ExchangeExists(ctx, tx, o.ID) + if err != nil { + t.Errorf("Unable to check if Exchange exists: %s", err) + } + if !e { + t.Errorf("Expected ExchangeExists to return true, but got false.") + } +} + +func testExchangesFind(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + exchangeFound, err := FindExchange(ctx, tx, o.ID) + if err != nil { + t.Error(err) + } + + if exchangeFound == nil { + t.Error("want a record, got nil") + } +} + +func testExchangesBind(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if err = Exchanges().Bind(ctx, tx, o); err != nil { + t.Error(err) + } +} + +func testExchangesOne(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if x, err := Exchanges().One(ctx, tx); err != nil { + t.Error(err) + } else if x == nil { + t.Error("expected to get a non nil record") + } +} + +func testExchangesAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + exchangeOne := &Exchange{} + exchangeTwo := &Exchange{} + if err = randomize.Struct(seed, exchangeOne, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + if err = randomize.Struct(seed, exchangeTwo, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = exchangeOne.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + if err = exchangeTwo.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice, err := Exchanges().All(ctx, tx) + if err != nil { + t.Error(err) + } + + if len(slice) != 2 { + t.Error("want 2 records, got:", len(slice)) + } +} + +func testExchangesCount(t *testing.T) { + t.Parallel() + + var err error + seed := randomize.NewSeed() + exchangeOne := &Exchange{} + exchangeTwo := &Exchange{} + if err = randomize.Struct(seed, exchangeOne, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + if err = randomize.Struct(seed, exchangeTwo, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = exchangeOne.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + if err = exchangeTwo.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 2 { + t.Error("want 2 records, got:", count) + } +} + +func exchangeBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func exchangeAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Exchange) error { + *o = Exchange{} + return nil +} + +func testExchangesHooks(t *testing.T) { + t.Parallel() + + var err error + + ctx := context.Background() + empty := &Exchange{} + o := &Exchange{} + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, o, exchangeDBTypes, false); err != nil { + t.Errorf("Unable to randomize Exchange object: %s", err) + } + + AddExchangeHook(boil.BeforeInsertHook, exchangeBeforeInsertHook) + if err = o.doBeforeInsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) + } + exchangeBeforeInsertHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterInsertHook, exchangeAfterInsertHook) + if err = o.doAfterInsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterInsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) + } + exchangeAfterInsertHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterSelectHook, exchangeAfterSelectHook) + if err = o.doAfterSelectHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterSelectHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) + } + exchangeAfterSelectHooks = []ExchangeHook{} + + AddExchangeHook(boil.BeforeUpdateHook, exchangeBeforeUpdateHook) + if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) + } + exchangeBeforeUpdateHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterUpdateHook, exchangeAfterUpdateHook) + if err = o.doAfterUpdateHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) + } + exchangeAfterUpdateHooks = []ExchangeHook{} + + AddExchangeHook(boil.BeforeDeleteHook, exchangeBeforeDeleteHook) + if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) + } + exchangeBeforeDeleteHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterDeleteHook, exchangeAfterDeleteHook) + if err = o.doAfterDeleteHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) + } + exchangeAfterDeleteHooks = []ExchangeHook{} + + AddExchangeHook(boil.BeforeUpsertHook, exchangeBeforeUpsertHook) + if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) + } + exchangeBeforeUpsertHooks = []ExchangeHook{} + + AddExchangeHook(boil.AfterUpsertHook, exchangeAfterUpsertHook) + if err = o.doAfterUpsertHooks(ctx, nil); err != nil { + t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) + } + if !reflect.DeepEqual(o, empty) { + t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) + } + exchangeAfterUpsertHooks = []ExchangeHook{} +} + +func testExchangesInsert(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } +} + +func testExchangesInsertWhitelist(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Whitelist(exchangeColumnsWithoutDefault...)); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } +} + +func testExchangeOneToOneCandleUsingExchangeNameCandle(t *testing.T) { + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var foreign Candle + var local Exchange + + seed := randomize.NewSeed() + if err := randomize.Struct(seed, &foreign, candleDBTypes, true, candleColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Candle struct: %s", err) + } + if err := randomize.Struct(seed, &local, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err := local.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + foreign.ExchangeNameID = local.ID + if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + check, err := local.ExchangeNameCandle().One(ctx, tx) + if err != nil { + t.Fatal(err) + } + + if check.ExchangeNameID != foreign.ExchangeNameID { + t.Errorf("want: %v, got %v", foreign.ExchangeNameID, check.ExchangeNameID) + } + + slice := ExchangeSlice{&local} + if err = local.L.LoadExchangeNameCandle(ctx, tx, false, (*[]*Exchange)(&slice), nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeNameCandle == nil { + t.Error("struct should have been eager loaded") + } + + local.R.ExchangeNameCandle = nil + if err = local.L.LoadExchangeNameCandle(ctx, tx, true, &local, nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeNameCandle == nil { + t.Error("struct should have been eager loaded") + } +} + +func testExchangeOneToOneSetOpCandleUsingExchangeNameCandle(t *testing.T) { + var err error + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Exchange + var b, c Candle + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &b, candleDBTypes, false, strmangle.SetComplement(candlePrimaryKeyColumns, candleColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &c, candleDBTypes, false, strmangle.SetComplement(candlePrimaryKeyColumns, candleColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + for i, x := range []*Candle{&b, &c} { + err = a.SetExchangeNameCandle(ctx, tx, i != 0, x) + if err != nil { + t.Fatal(err) + } + + if a.R.ExchangeNameCandle != x { + t.Error("relationship struct not set to correct value") + } + if x.R.ExchangeName != &a { + t.Error("failed to append to foreign relationship struct") + } + + if a.ID != x.ExchangeNameID { + t.Error("foreign key was wrong value", a.ID) + } + + zero := reflect.Zero(reflect.TypeOf(x.ExchangeNameID)) + reflect.Indirect(reflect.ValueOf(&x.ExchangeNameID)).Set(zero) + + if err = x.Reload(ctx, tx); err != nil { + t.Fatal("failed to reload", err) + } + + if a.ID != x.ExchangeNameID { + t.Error("foreign key was wrong value", a.ID, x.ExchangeNameID) + } + + if _, err = x.Delete(ctx, tx); err != nil { + t.Fatal("failed to delete x", err) + } + } +} + +func testExchangeToManyExchangeNameWithdrawalHistories(t *testing.T) { + var err error + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Exchange + var b, c WithdrawalHistory + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + if err = randomize.Struct(seed, &b, withdrawalHistoryDBTypes, false, withdrawalHistoryColumnsWithDefault...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &c, withdrawalHistoryDBTypes, false, withdrawalHistoryColumnsWithDefault...); err != nil { + t.Fatal(err) + } + + b.ExchangeNameID = a.ID + c.ExchangeNameID = a.ID + + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = c.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + check, err := a.ExchangeNameWithdrawalHistories().All(ctx, tx) + if err != nil { + t.Fatal(err) + } + + bFound, cFound := false, false + for _, v := range check { + if v.ExchangeNameID == b.ExchangeNameID { + bFound = true + } + if v.ExchangeNameID == c.ExchangeNameID { + cFound = true + } + } + + if !bFound { + t.Error("expected to find b") + } + if !cFound { + t.Error("expected to find c") + } + + slice := ExchangeSlice{&a} + if err = a.L.LoadExchangeNameWithdrawalHistories(ctx, tx, false, (*[]*Exchange)(&slice), nil); err != nil { + t.Fatal(err) + } + if got := len(a.R.ExchangeNameWithdrawalHistories); got != 2 { + t.Error("number of eager loaded records wrong, got:", got) + } + + a.R.ExchangeNameWithdrawalHistories = nil + if err = a.L.LoadExchangeNameWithdrawalHistories(ctx, tx, true, &a, nil); err != nil { + t.Fatal(err) + } + if got := len(a.R.ExchangeNameWithdrawalHistories); got != 2 { + t.Error("number of eager loaded records wrong, got:", got) + } + + if t.Failed() { + t.Logf("%#v", check) + } +} + +func testExchangeToManyAddOpExchangeNameWithdrawalHistories(t *testing.T) { + var err error + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a Exchange + var b, c, d, e WithdrawalHistory + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + foreigners := []*WithdrawalHistory{&b, &c, &d, &e} + for _, x := range foreigners { + if err = randomize.Struct(seed, x, withdrawalHistoryDBTypes, false, strmangle.SetComplement(withdrawalHistoryPrimaryKeyColumns, withdrawalHistoryColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = c.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + foreignersSplitByInsertion := [][]*WithdrawalHistory{ + {&b, &c}, + {&d, &e}, + } + + for i, x := range foreignersSplitByInsertion { + err = a.AddExchangeNameWithdrawalHistories(ctx, tx, i != 0, x...) + if err != nil { + t.Fatal(err) + } + + first := x[0] + second := x[1] + + if a.ID != first.ExchangeNameID { + t.Error("foreign key was wrong value", a.ID, first.ExchangeNameID) + } + if a.ID != second.ExchangeNameID { + t.Error("foreign key was wrong value", a.ID, second.ExchangeNameID) + } + + if first.R.ExchangeName != &a { + t.Error("relationship was not added properly to the foreign slice") + } + if second.R.ExchangeName != &a { + t.Error("relationship was not added properly to the foreign slice") + } + + if a.R.ExchangeNameWithdrawalHistories[i*2] != first { + t.Error("relationship struct slice not set to correct value") + } + if a.R.ExchangeNameWithdrawalHistories[i*2+1] != second { + t.Error("relationship struct slice not set to correct value") + } + + count, err := a.ExchangeNameWithdrawalHistories().Count(ctx, tx) + if err != nil { + t.Fatal(err) + } + if want := int64((i + 1) * 2); count != want { + t.Error("want", want, "got", count) + } + } +} + +func testExchangesReload(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + if err = o.Reload(ctx, tx); err != nil { + t.Error(err) + } +} + +func testExchangesReloadAll(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice := ExchangeSlice{o} + + if err = slice.ReloadAll(ctx, tx); err != nil { + t.Error(err) + } +} + +func testExchangesSelect(t *testing.T) { + t.Parallel() + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + slice, err := Exchanges().All(ctx, tx) + if err != nil { + t.Error(err) + } + + if len(slice) != 1 { + t.Error("want one record, got:", len(slice)) + } +} + +var ( + exchangeDBTypes = map[string]string{`ID`: `TEXT`, `Name`: `TEXT`} + _ = bytes.MinRead +) + +func testExchangesUpdate(t *testing.T) { + t.Parallel() + + if 0 == len(exchangePrimaryKeyColumns) { + t.Skip("Skipping table with no primary key columns") + } + if len(exchangeAllColumns) == len(exchangePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } + + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("should only affect one row but affected", rowsAff) + } +} + +func testExchangesSliceUpdateAll(t *testing.T) { + t.Parallel() + + if len(exchangeAllColumns) == len(exchangePrimaryKeyColumns) { + t.Skip("Skipping table with only primary key columns") + } + + seed := randomize.NewSeed() + var err error + o := &Exchange{} + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + if err = o.Insert(ctx, tx, boil.Infer()); err != nil { + t.Error(err) + } + + count, err := Exchanges().Count(ctx, tx) + if err != nil { + t.Error(err) + } + + if count != 1 { + t.Error("want one record, got:", count) + } + + if err = randomize.Struct(seed, o, exchangeDBTypes, true, exchangePrimaryKeyColumns...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + // Remove Primary keys and unique columns from what we plan to update + var fields []string + if strmangle.StringSliceMatch(exchangeAllColumns, exchangePrimaryKeyColumns) { + fields = exchangeAllColumns + } else { + fields = strmangle.SetComplement( + exchangeAllColumns, + exchangePrimaryKeyColumns, + ) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + typ := reflect.TypeOf(o).Elem() + n := typ.NumField() + + updateMap := M{} + for _, col := range fields { + for i := 0; i < n; i++ { + f := typ.Field(i) + if f.Tag.Get("boil") == col { + updateMap[col] = value.Field(i).Interface() + } + } + } + + slice := ExchangeSlice{o} + if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { + t.Error(err) + } else if rowsAff != 1 { + t.Error("wanted one record updated but got", rowsAff) + } +} diff --git a/database/models/sqlite3/withdrawal_crypto.go b/database/models/sqlite3/withdrawal_crypto.go index 00aacfdd..43bfac93 100644 --- a/database/models/sqlite3/withdrawal_crypto.go +++ b/database/models/sqlite3/withdrawal_crypto.go @@ -72,21 +72,6 @@ func (w whereHelpernull_String) GTE(x null.String) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GTE, x) } -type whereHelperfloat64 struct{ field string } - -func (w whereHelperfloat64) EQ(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) } -func (w whereHelperfloat64) NEQ(x float64) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.NEQ, x) -} -func (w whereHelperfloat64) LT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) } -func (w whereHelperfloat64) LTE(x float64) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.LTE, x) -} -func (w whereHelperfloat64) GT(x float64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) } -func (w whereHelperfloat64) GTE(x float64) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.GTE, x) -} - var WithdrawalCryptoWhere = struct { ID whereHelperint64 Address whereHelperstring diff --git a/database/models/sqlite3/withdrawal_fiat.go b/database/models/sqlite3/withdrawal_fiat.go index 3b815499..5ced95f6 100644 --- a/database/models/sqlite3/withdrawal_fiat.go +++ b/database/models/sqlite3/withdrawal_fiat.go @@ -109,8 +109,8 @@ type withdrawalFiatL struct{} var ( withdrawalFiatAllColumns = []string{"id", "bank_name", "bank_address", "bank_account_name", "bank_account_number", "bsb", "swift_code", "iban", "bank_code", "withdrawal_history_id"} - withdrawalFiatColumnsWithoutDefault = []string{"bank_name", "bank_address", "bank_account_name", "bank_account_number", "bsb", "swift_code", "iban", "bank_code", "withdrawal_history_id"} - withdrawalFiatColumnsWithDefault = []string{"id"} + withdrawalFiatColumnsWithoutDefault = []string{"bank_name", "bank_address", "bank_account_name", "bank_account_number", "bank_code", "withdrawal_history_id"} + withdrawalFiatColumnsWithDefault = []string{"id", "bsb", "swift_code", "iban"} withdrawalFiatPrimaryKeyColumns = []string{"id"} ) diff --git a/database/models/sqlite3/withdrawal_history.go b/database/models/sqlite3/withdrawal_history.go index 3e598933..62f17c43 100644 --- a/database/models/sqlite3/withdrawal_history.go +++ b/database/models/sqlite3/withdrawal_history.go @@ -23,82 +23,85 @@ import ( // WithdrawalHistory is an object representing the database table. type WithdrawalHistory struct { - ID string `boil:"id" json:"id" toml:"id" yaml:"id"` - Exchange string `boil:"exchange" json:"exchange" toml:"exchange" yaml:"exchange"` - ExchangeID string `boil:"exchange_id" json:"exchange_id" toml:"exchange_id" yaml:"exchange_id"` - Status string `boil:"status" json:"status" toml:"status" yaml:"status"` - Currency string `boil:"currency" json:"currency" toml:"currency" yaml:"currency"` - Amount float64 `boil:"amount" json:"amount" toml:"amount" yaml:"amount"` - Description null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"` - WithdrawType int64 `boil:"withdraw_type" json:"withdraw_type" toml:"withdraw_type" yaml:"withdraw_type"` - CreatedAt string `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"` - UpdatedAt string `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"` + ID string `boil:"id" json:"id" toml:"id" yaml:"id"` + ExchangeNameID string `boil:"exchange_name_id" json:"exchange_name_id" toml:"exchange_name_id" yaml:"exchange_name_id"` + ExchangeID string `boil:"exchange_id" json:"exchange_id" toml:"exchange_id" yaml:"exchange_id"` + Status string `boil:"status" json:"status" toml:"status" yaml:"status"` + Currency string `boil:"currency" json:"currency" toml:"currency" yaml:"currency"` + Amount float64 `boil:"amount" json:"amount" toml:"amount" yaml:"amount"` + Description null.String `boil:"description" json:"description,omitempty" toml:"description" yaml:"description,omitempty"` + WithdrawType int64 `boil:"withdraw_type" json:"withdraw_type" toml:"withdraw_type" yaml:"withdraw_type"` + CreatedAt string `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"` + UpdatedAt string `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"` R *withdrawalHistoryR `boil:"-" json:"-" toml:"-" yaml:"-"` L withdrawalHistoryL `boil:"-" json:"-" toml:"-" yaml:"-"` } var WithdrawalHistoryColumns = struct { - ID string - Exchange string - ExchangeID string - Status string - Currency string - Amount string - Description string - WithdrawType string - CreatedAt string - UpdatedAt string + ID string + ExchangeNameID string + ExchangeID string + Status string + Currency string + Amount string + Description string + WithdrawType string + CreatedAt string + UpdatedAt string }{ - ID: "id", - Exchange: "exchange", - ExchangeID: "exchange_id", - Status: "status", - Currency: "currency", - Amount: "amount", - Description: "description", - WithdrawType: "withdraw_type", - CreatedAt: "created_at", - UpdatedAt: "updated_at", + ID: "id", + ExchangeNameID: "exchange_name_id", + ExchangeID: "exchange_id", + Status: "status", + Currency: "currency", + Amount: "amount", + Description: "description", + WithdrawType: "withdraw_type", + CreatedAt: "created_at", + UpdatedAt: "updated_at", } // Generated where var WithdrawalHistoryWhere = struct { - ID whereHelperstring - Exchange whereHelperstring - ExchangeID whereHelperstring - Status whereHelperstring - Currency whereHelperstring - Amount whereHelperfloat64 - Description whereHelpernull_String - WithdrawType whereHelperint64 - CreatedAt whereHelperstring - UpdatedAt whereHelperstring + ID whereHelperstring + ExchangeNameID whereHelperstring + ExchangeID whereHelperstring + Status whereHelperstring + Currency whereHelperstring + Amount whereHelperfloat64 + Description whereHelpernull_String + WithdrawType whereHelperint64 + CreatedAt whereHelperstring + UpdatedAt whereHelperstring }{ - ID: whereHelperstring{field: "\"withdrawal_history\".\"id\""}, - Exchange: whereHelperstring{field: "\"withdrawal_history\".\"exchange\""}, - ExchangeID: whereHelperstring{field: "\"withdrawal_history\".\"exchange_id\""}, - Status: whereHelperstring{field: "\"withdrawal_history\".\"status\""}, - Currency: whereHelperstring{field: "\"withdrawal_history\".\"currency\""}, - Amount: whereHelperfloat64{field: "\"withdrawal_history\".\"amount\""}, - Description: whereHelpernull_String{field: "\"withdrawal_history\".\"description\""}, - WithdrawType: whereHelperint64{field: "\"withdrawal_history\".\"withdraw_type\""}, - CreatedAt: whereHelperstring{field: "\"withdrawal_history\".\"created_at\""}, - UpdatedAt: whereHelperstring{field: "\"withdrawal_history\".\"updated_at\""}, + ID: whereHelperstring{field: "\"withdrawal_history\".\"id\""}, + ExchangeNameID: whereHelperstring{field: "\"withdrawal_history\".\"exchange_name_id\""}, + ExchangeID: whereHelperstring{field: "\"withdrawal_history\".\"exchange_id\""}, + Status: whereHelperstring{field: "\"withdrawal_history\".\"status\""}, + Currency: whereHelperstring{field: "\"withdrawal_history\".\"currency\""}, + Amount: whereHelperfloat64{field: "\"withdrawal_history\".\"amount\""}, + Description: whereHelpernull_String{field: "\"withdrawal_history\".\"description\""}, + WithdrawType: whereHelperint64{field: "\"withdrawal_history\".\"withdraw_type\""}, + CreatedAt: whereHelperstring{field: "\"withdrawal_history\".\"created_at\""}, + UpdatedAt: whereHelperstring{field: "\"withdrawal_history\".\"updated_at\""}, } // WithdrawalHistoryRels is where relationship names are stored. var WithdrawalHistoryRels = struct { + ExchangeName string WithdrawalCryptos string WithdrawalFiats string }{ + ExchangeName: "ExchangeName", WithdrawalCryptos: "WithdrawalCryptos", WithdrawalFiats: "WithdrawalFiats", } // withdrawalHistoryR is where relationships are stored. type withdrawalHistoryR struct { + ExchangeName *Exchange WithdrawalCryptos WithdrawalCryptoSlice WithdrawalFiats WithdrawalFiatSlice } @@ -112,8 +115,8 @@ func (*withdrawalHistoryR) NewStruct() *withdrawalHistoryR { type withdrawalHistoryL struct{} var ( - withdrawalHistoryAllColumns = []string{"id", "exchange", "exchange_id", "status", "currency", "amount", "description", "withdraw_type", "created_at", "updated_at"} - withdrawalHistoryColumnsWithoutDefault = []string{"id", "exchange", "exchange_id", "status", "currency", "amount", "description", "withdraw_type"} + withdrawalHistoryAllColumns = []string{"id", "exchange_name_id", "exchange_id", "status", "currency", "amount", "description", "withdraw_type", "created_at", "updated_at"} + withdrawalHistoryColumnsWithoutDefault = []string{"id", "exchange_name_id", "exchange_id", "status", "currency", "amount", "description", "withdraw_type"} withdrawalHistoryColumnsWithDefault = []string{"created_at", "updated_at"} withdrawalHistoryPrimaryKeyColumns = []string{"id"} ) @@ -393,6 +396,20 @@ func (q withdrawalHistoryQuery) Exists(ctx context.Context, exec boil.ContextExe return count > 0, nil } +// ExchangeName pointed to by the foreign key. +func (o *WithdrawalHistory) ExchangeName(mods ...qm.QueryMod) exchangeQuery { + queryMods := []qm.QueryMod{ + qm.Where("\"id\" = ?", o.ExchangeNameID), + } + + queryMods = append(queryMods, mods...) + + query := Exchanges(queryMods...) + queries.SetFrom(query.Query, "\"exchange\"") + + return query +} + // WithdrawalCryptos retrieves all the withdrawal_crypto's WithdrawalCryptos with an executor. func (o *WithdrawalHistory) WithdrawalCryptos(mods ...qm.QueryMod) withdrawalCryptoQuery { var queryMods []qm.QueryMod @@ -435,6 +452,107 @@ func (o *WithdrawalHistory) WithdrawalFiats(mods ...qm.QueryMod) withdrawalFiatQ return query } +// LoadExchangeName allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for an N-1 relationship. +func (withdrawalHistoryL) LoadExchangeName(ctx context.Context, e boil.ContextExecutor, singular bool, maybeWithdrawalHistory interface{}, mods queries.Applicator) error { + var slice []*WithdrawalHistory + var object *WithdrawalHistory + + if singular { + object = maybeWithdrawalHistory.(*WithdrawalHistory) + } else { + slice = *maybeWithdrawalHistory.(*[]*WithdrawalHistory) + } + + args := make([]interface{}, 0, 1) + if singular { + if object.R == nil { + object.R = &withdrawalHistoryR{} + } + args = append(args, object.ExchangeNameID) + + } else { + Outer: + for _, obj := range slice { + if obj.R == nil { + obj.R = &withdrawalHistoryR{} + } + + for _, a := range args { + if a == obj.ExchangeNameID { + continue Outer + } + } + + args = append(args, obj.ExchangeNameID) + + } + } + + if len(args) == 0 { + return nil + } + + query := NewQuery(qm.From(`exchange`), qm.WhereIn(`exchange.id in ?`, args...)) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load Exchange") + } + + var resultSlice []*Exchange + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice Exchange") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results of eager load for exchange") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for exchange") + } + + if len(withdrawalHistoryAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + + if len(resultSlice) == 0 { + return nil + } + + if singular { + foreign := resultSlice[0] + object.R.ExchangeName = foreign + if foreign.R == nil { + foreign.R = &exchangeR{} + } + foreign.R.ExchangeNameWithdrawalHistories = append(foreign.R.ExchangeNameWithdrawalHistories, object) + return nil + } + + for _, local := range slice { + for _, foreign := range resultSlice { + if local.ExchangeNameID == foreign.ID { + local.R.ExchangeName = foreign + if foreign.R == nil { + foreign.R = &exchangeR{} + } + foreign.R.ExchangeNameWithdrawalHistories = append(foreign.R.ExchangeNameWithdrawalHistories, local) + break + } + } + } + + return nil +} + // LoadWithdrawalCryptos allows an eager lookup of values, cached into the // loaded structs of the objects. This is for a 1-M or N-M relationship. func (withdrawalHistoryL) LoadWithdrawalCryptos(ctx context.Context, e boil.ContextExecutor, singular bool, maybeWithdrawalHistory interface{}, mods queries.Applicator) error { @@ -625,6 +743,53 @@ func (withdrawalHistoryL) LoadWithdrawalFiats(ctx context.Context, e boil.Contex return nil } +// SetExchangeName of the withdrawalHistory to the related item. +// Sets o.R.ExchangeName to related. +// Adds o to related.R.ExchangeNameWithdrawalHistories. +func (o *WithdrawalHistory) SetExchangeName(ctx context.Context, exec boil.ContextExecutor, insert bool, related *Exchange) error { + var err error + if insert { + if err = related.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } + + updateQuery := fmt.Sprintf( + "UPDATE \"withdrawal_history\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 0, []string{"exchange_name_id"}), + strmangle.WhereClause("\"", "\"", 0, withdrawalHistoryPrimaryKeyColumns), + ) + values := []interface{}{related.ID, o.ID} + + if boil.DebugMode { + fmt.Fprintln(boil.DebugWriter, updateQuery) + fmt.Fprintln(boil.DebugWriter, values) + } + + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update local table") + } + + o.ExchangeNameID = related.ID + if o.R == nil { + o.R = &withdrawalHistoryR{ + ExchangeName: related, + } + } else { + o.R.ExchangeName = related + } + + if related.R == nil { + related.R = &exchangeR{ + ExchangeNameWithdrawalHistories: WithdrawalHistorySlice{o}, + } + } else { + related.R.ExchangeNameWithdrawalHistories = append(related.R.ExchangeNameWithdrawalHistories, o) + } + + return nil +} + // AddWithdrawalCryptos adds the given related objects to the existing relationships // of the withdrawal_history, optionally inserting them as new records. // Appends related to o.R.WithdrawalCryptos. diff --git a/database/models/sqlite3/withdrawal_history_test.go b/database/models/sqlite3/withdrawal_history_test.go index 96154f72..f6d174d5 100644 --- a/database/models/sqlite3/withdrawal_history_test.go +++ b/database/models/sqlite3/withdrawal_history_test.go @@ -800,6 +800,114 @@ func testWithdrawalHistoryToManyAddOpWithdrawalFiats(t *testing.T) { } } } +func testWithdrawalHistoryToOneExchangeUsingExchangeName(t *testing.T) { + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var local WithdrawalHistory + var foreign Exchange + + seed := randomize.NewSeed() + if err := randomize.Struct(seed, &local, withdrawalHistoryDBTypes, false, withdrawalHistoryColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize WithdrawalHistory struct: %s", err) + } + if err := randomize.Struct(seed, &foreign, exchangeDBTypes, false, exchangeColumnsWithDefault...); err != nil { + t.Errorf("Unable to randomize Exchange struct: %s", err) + } + + if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + local.ExchangeNameID = foreign.ID + if err := local.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + check, err := local.ExchangeName().One(ctx, tx) + if err != nil { + t.Fatal(err) + } + + if check.ID != foreign.ID { + t.Errorf("want: %v, got %v", foreign.ID, check.ID) + } + + slice := WithdrawalHistorySlice{&local} + if err = local.L.LoadExchangeName(ctx, tx, false, (*[]*WithdrawalHistory)(&slice), nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeName == nil { + t.Error("struct should have been eager loaded") + } + + local.R.ExchangeName = nil + if err = local.L.LoadExchangeName(ctx, tx, true, &local, nil); err != nil { + t.Fatal(err) + } + if local.R.ExchangeName == nil { + t.Error("struct should have been eager loaded") + } +} + +func testWithdrawalHistoryToOneSetOpExchangeUsingExchangeName(t *testing.T) { + var err error + + ctx := context.Background() + tx := MustTx(boil.BeginTx(ctx, nil)) + defer func() { _ = tx.Rollback() }() + + var a WithdrawalHistory + var b, c Exchange + + seed := randomize.NewSeed() + if err = randomize.Struct(seed, &a, withdrawalHistoryDBTypes, false, strmangle.SetComplement(withdrawalHistoryPrimaryKeyColumns, withdrawalHistoryColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &b, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + if err = randomize.Struct(seed, &c, exchangeDBTypes, false, strmangle.SetComplement(exchangePrimaryKeyColumns, exchangeColumnsWithoutDefault)...); err != nil { + t.Fatal(err) + } + + if err := a.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + if err = b.Insert(ctx, tx, boil.Infer()); err != nil { + t.Fatal(err) + } + + for i, x := range []*Exchange{&b, &c} { + err = a.SetExchangeName(ctx, tx, i != 0, x) + if err != nil { + t.Fatal(err) + } + + if a.R.ExchangeName != x { + t.Error("relationship struct not set to correct value") + } + + if x.R.ExchangeNameWithdrawalHistories[0] != &a { + t.Error("failed to append to foreign relationship struct") + } + if a.ExchangeNameID != x.ID { + t.Error("foreign key was wrong value", a.ExchangeNameID) + } + + zero := reflect.Zero(reflect.TypeOf(a.ExchangeNameID)) + reflect.Indirect(reflect.ValueOf(&a.ExchangeNameID)).Set(zero) + + if err = a.Reload(ctx, tx); err != nil { + t.Fatal("failed to reload", err) + } + + if a.ExchangeNameID != x.ID { + t.Error("foreign key was wrong value", a.ExchangeNameID, x.ID) + } + } +} func testWithdrawalHistoriesReload(t *testing.T) { t.Parallel() @@ -875,7 +983,7 @@ func testWithdrawalHistoriesSelect(t *testing.T) { } var ( - withdrawalHistoryDBTypes = map[string]string{`ID`: `TEXT`, `Exchange`: `TEXT`, `ExchangeID`: `TEXT`, `Status`: `TEXT`, `Currency`: `TEXT`, `Amount`: `REAL`, `Description`: `TEXT`, `WithdrawType`: `INTEGER`, `CreatedAt`: `TIMESTAMP`, `UpdatedAt`: `TIMESTAMP`} + withdrawalHistoryDBTypes = map[string]string{`ID`: `TEXT`, `ExchangeNameID`: `TEXT`, `ExchangeID`: `TEXT`, `Status`: `TEXT`, `Currency`: `TEXT`, `Amount`: `REAL`, `Description`: `TEXT`, `WithdrawType`: `INTEGER`, `CreatedAt`: `TIMESTAMP`, `UpdatedAt`: `TIMESTAMP`} _ = bytes.MinRead ) diff --git a/database/repository/audit/audit.go b/database/repository/audit/audit.go index a34752c3..793350e9 100644 --- a/database/repository/audit/audit.go +++ b/database/repository/audit/audit.go @@ -56,10 +56,6 @@ func Event(id, msgtype, message string) { err = tx.Commit() if err != nil { log.Errorf(log.Global, "Event Transaction commit failed: %v", err) - err = tx.Rollback() - if err != nil { - log.Errorf(log.Global, "Event Transaction rollback failed: %v", err) - } return } } diff --git a/database/repository/audit/audit_test.go b/database/repository/audit/audit_test.go index 71c08e20..8dfc8e2f 100644 --- a/database/repository/audit/audit_test.go +++ b/database/repository/audit/audit_test.go @@ -4,16 +4,13 @@ import ( "fmt" "io/ioutil" "os" - "path/filepath" "sync" "testing" "time" "github.com/thrasher-corp/gocryptotrader/database" "github.com/thrasher-corp/gocryptotrader/database/drivers" - "github.com/thrasher-corp/gocryptotrader/database/repository" "github.com/thrasher-corp/gocryptotrader/database/testhelpers" - "github.com/thrasher-corp/goose" ) func TestMain(m *testing.M) { @@ -26,7 +23,6 @@ func TestMain(m *testing.M) { } t := m.Run() - err = os.RemoveAll(testhelpers.TempDir) if err != nil { fmt.Printf("Failed to remove temp db file: %v", err) @@ -93,12 +89,6 @@ func TestAudit(t *testing.T) { t.Fatal(err) } - path := filepath.Join("..", "..", "migrations") - err = goose.Run("up", dbConn.SQL, repository.GetSQLDialect(), path, "") - if err != nil { - t.Fatalf("failed to run migrations %v", err) - } - if test.runner != nil { test.runner(t) } diff --git a/database/repository/candle/candle.go b/database/repository/candle/candle.go new file mode 100644 index 00000000..c6c961db --- /dev/null +++ b/database/repository/candle/candle.go @@ -0,0 +1,270 @@ +package candle + +import ( + "context" + "database/sql" + "encoding/csv" + "fmt" + "io" + "math" + "os" + "strconv" + "strings" + "time" + + "github.com/gofrs/uuid" + "github.com/thrasher-corp/gocryptotrader/database" + modelPSQL "github.com/thrasher-corp/gocryptotrader/database/models/postgres" + modelSQLite "github.com/thrasher-corp/gocryptotrader/database/models/sqlite3" + "github.com/thrasher-corp/gocryptotrader/database/repository" + "github.com/thrasher-corp/gocryptotrader/database/repository/exchange" + "github.com/thrasher-corp/gocryptotrader/log" + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries/qm" +) + +// Series returns candle data +func Series(exchangeName, base, quote string, interval int64, asset string, start, end time.Time) (out Item, err error) { + if exchangeName == "" || base == "" || quote == "" || asset == "" || interval <= 0 { + return out, errInvalidInput + } + + queries := []qm.QueryMod{ + qm.Where("base = ?", strings.ToUpper(base)), + qm.Where("quote = ?", strings.ToUpper(quote)), + qm.Where("interval = ?", interval), + qm.Where("asset = ?", asset), + qm.Where("timestamp between ? and ?", start.UTC(), end.UTC()), + } + + exchangeUUID, errS := exchange.UUIDByName(exchangeName) + if errS != nil { + return out, errS + } + queries = append(queries, qm.Where("exchange_name_id = ?", exchangeUUID.String())) + + if repository.GetSQLDialect() == database.DBSQLite3 { + retCandle, errC := modelSQLite.Candles(queries...).All(context.Background(), database.DB.SQL) + if errC != nil { + return out, errC + } + for x := range retCandle { + t, errT := time.Parse(time.RFC3339, retCandle[x].Timestamp) + if errT != nil { + return out, errT + } + out.Candles = append(out.Candles, Candle{ + Timestamp: t, + Open: retCandle[x].Open, + High: retCandle[x].High, + Low: retCandle[x].Low, + Close: retCandle[x].Close, + Volume: retCandle[x].Volume, + }) + } + } else { + retCandle, errC := modelPSQL.Candles(queries...).All(context.Background(), database.DB.SQL) + if errC != nil { + return out, errC + } + + for x := range retCandle { + out.Candles = append(out.Candles, Candle{ + Timestamp: retCandle[x].Timestamp, + Open: retCandle[x].Open, + High: retCandle[x].High, + Low: retCandle[x].Low, + Close: retCandle[x].Close, + Volume: retCandle[x].Volume, + }) + } + } + if len(out.Candles) < 1 { + return out, fmt.Errorf(errNoCandleDataFound, exchangeName, base, quote, interval, asset) + } + + out.ExchangeID = exchangeName + out.Interval = interval + out.Base = base + out.Quote = quote + out.Asset = asset + return out, err +} + +// Insert series of candles +func Insert(in *Item) (uint64, error) { + if database.DB.SQL == nil { + return 0, database.ErrDatabaseSupportDisabled + } + + if len(in.Candles) < 1 { + return 0, errNoCandleData + } + + ctx := context.Background() + tx, err := database.DB.SQL.BeginTx(ctx, nil) + if err != nil { + return 0, err + } + + var totalInserted uint64 + if repository.GetSQLDialect() == database.DBSQLite3 { + totalInserted, err = insertSQLite(ctx, tx, in) + } else { + totalInserted, err = insertPostgresSQL(ctx, tx, in) + } + if err != nil { + errRB := tx.Rollback() + if errRB != nil { + log.Errorln(log.DatabaseMgr, errRB) + } + return 0, err + } + + err = tx.Commit() + if err != nil { + return 0, err + } + return totalInserted, nil +} + +func insertSQLite(ctx context.Context, tx *sql.Tx, in *Item) (uint64, error) { + var totalInserted uint64 + for x := range in.Candles { + var tempCandle = modelSQLite.Candle{ + ExchangeNameID: in.ExchangeID, + Base: strings.ToUpper(in.Base), + Quote: strings.ToUpper(in.Quote), + Interval: strconv.FormatInt(in.Interval, 10), + Asset: in.Asset, + Timestamp: in.Candles[x].Timestamp.UTC().Format(time.RFC3339), + Open: in.Candles[x].Open, + High: in.Candles[x].High, + Low: in.Candles[x].Low, + Close: in.Candles[x].Close, + Volume: in.Candles[x].Volume, + } + tempUUID, err := uuid.NewV4() + if err != nil { + return 0, err + } + tempCandle.ID = tempUUID.String() + err = tempCandle.Insert(ctx, tx, boil.Infer()) + if err != nil { + return 0, err + } + if totalInserted < math.MaxUint64 { + totalInserted++ + } + } + return totalInserted, nil +} + +func insertPostgresSQL(ctx context.Context, tx *sql.Tx, in *Item) (uint64, error) { + var totalInserted uint64 + for x := range in.Candles { + var tempCandle = modelPSQL.Candle{ + ExchangeNameID: in.ExchangeID, + Base: strings.ToUpper(in.Base), + Quote: strings.ToUpper(in.Quote), + Interval: in.Interval, + Asset: in.Asset, + Timestamp: in.Candles[x].Timestamp, + Open: in.Candles[x].Open, + High: in.Candles[x].High, + Low: in.Candles[x].Low, + Close: in.Candles[x].Close, + Volume: in.Candles[x].Volume, + } + err := tempCandle.Upsert(ctx, tx, true, []string{"timestamp", "exchange_name_id", "base", "quote", "interval", "asset"}, boil.Infer(), boil.Infer()) + if err != nil { + return 0, err + } + if totalInserted < math.MaxUint64 { + totalInserted++ + } + } + return totalInserted, nil +} + +// InsertFromCSV load a CSV list of candle data and insert into database +func InsertFromCSV(exchangeName, base, quote string, interval int64, asset, file string) (uint64, error) { + csvFile, err := os.Open(file) + if err != nil { + return 0, err + } + + defer func() { + err = csvFile.Close() + if err != nil { + log.Errorln(log.Global, err) + } + }() + + csvData := csv.NewReader(csvFile) + + exchangeUUID, err := exchange.UUIDByName(exchangeName) + if err != nil { + return 0, err + } + + tempCandle := &Item{ + ExchangeID: exchangeUUID.String(), + Base: base, + Quote: quote, + Interval: interval, + Asset: asset, + } + + for { + row, errCSV := csvData.Read() + if errCSV != nil { + if errCSV == io.EOF { + break + } + return 0, errCSV + } + + tempTick := Candle{} + v, errParse := strconv.ParseInt(row[0], 10, 32) + if errParse != nil { + return 0, errParse + } + tempTick.Timestamp = time.Unix(v, 0).UTC() + if tempTick.Timestamp.IsZero() { + err = fmt.Errorf("invalid timestamp received on row %v", row) + break + } + + tempTick.Volume, err = strconv.ParseFloat(row[1], 64) + if err != nil { + break + } + + tempTick.Open, err = strconv.ParseFloat(row[2], 64) + if err != nil { + break + } + + tempTick.High, err = strconv.ParseFloat(row[3], 64) + if err != nil { + break + } + + tempTick.Low, err = strconv.ParseFloat(row[4], 64) + if err != nil { + break + } + + tempTick.Close, err = strconv.ParseFloat(row[5], 64) + if err != nil { + break + } + tempCandle.Candles = append(tempCandle.Candles, tempTick) + } + if err != nil { + return 0, err + } + + return Insert(tempCandle) +} diff --git a/database/repository/candle/candle_test.go b/database/repository/candle/candle_test.go new file mode 100644 index 00000000..94b74fbb --- /dev/null +++ b/database/repository/candle/candle_test.go @@ -0,0 +1,306 @@ +package candle + +import ( + "errors" + "fmt" + "io/ioutil" + "os" + "path/filepath" + "testing" + "time" + + "github.com/thrasher-corp/gocryptotrader/currency" + "github.com/thrasher-corp/gocryptotrader/database" + "github.com/thrasher-corp/gocryptotrader/database/drivers" + "github.com/thrasher-corp/gocryptotrader/database/repository/exchange" + "github.com/thrasher-corp/gocryptotrader/database/testhelpers" +) + +var ( + verbose = false + testExchanges = []exchange.Details{ + { + Name: "one", + }, + { + Name: "two", + }, + } +) + +func TestMain(m *testing.M) { + if verbose { + testhelpers.EnableVerboseTestOutput() + } + + var err error + testhelpers.PostgresTestDatabase = testhelpers.GetConnectionDetails() + testhelpers.TempDir, err = ioutil.TempDir("", "gct-temp") + if err != nil { + fmt.Printf("failed to create temp file: %v", err) + os.Exit(1) + } + + t := m.Run() + + err = os.RemoveAll(testhelpers.TempDir) + if err != nil { + fmt.Printf("Failed to remove temp db file: %v", err) + } + + os.Exit(t) +} + +func TestInsert(t *testing.T) { + testCases := []struct { + name string + config *database.Config + seedDB func(includeOHLCVData bool) error + runner func(t *testing.T) + closer func(dbConn *database.Instance) error + }{ + { + name: "postgresql", + config: testhelpers.PostgresTestDatabase, + seedDB: seedDB, + }, + { + name: "SQLite", + config: &database.Config{ + Driver: database.DBSQLite3, + ConnectionDetails: drivers.ConnectionDetails{Database: "./testdb"}, + }, + seedDB: seedDB, + }, + } + + for x := range testCases { + test := testCases[x] + + t.Run(test.name, func(t *testing.T) { + if !testhelpers.CheckValidConfig(&test.config.ConnectionDetails) { + t.Skip("database not configured skipping test") + } + + dbConn, err := testhelpers.ConnectToDatabase(test.config) + if err != nil { + t.Fatal(err) + } + + if test.seedDB != nil { + err = test.seedDB(false) + if err != nil { + t.Fatal(err) + } + } + + data, err := genOHCLVData() + if err != nil { + t.Fatal(err) + } + + r, err := Insert(&data) + if err != nil { + t.Fatal(err) + } + + if r != 365 { + t.Fatalf("unexpected number inserted: %v", r) + } + err = testhelpers.CloseDatabase(dbConn) + if err != nil { + t.Error(err) + } + }) + } +} + +func TestInsertFromCSV(t *testing.T) { + testCases := []struct { + name string + config *database.Config + seedDB func(includeOHLCVData bool) error + runner func(t *testing.T) + closer func(dbConn *database.Instance) error + }{ + { + name: "postgresql", + config: testhelpers.PostgresTestDatabase, + seedDB: seedDB, + }, + { + name: "SQLite", + config: &database.Config{ + Driver: database.DBSQLite3, + ConnectionDetails: drivers.ConnectionDetails{Database: "./testdb"}, + }, + seedDB: seedDB, + }, + } + + for x := range testCases { + test := testCases[x] + + t.Run(test.name, func(t *testing.T) { + if !testhelpers.CheckValidConfig(&test.config.ConnectionDetails) { + t.Skip("database not configured skipping test") + } + + dbConn, err := testhelpers.ConnectToDatabase(test.config) + if err != nil { + t.Fatal(err) + } + + if test.seedDB != nil { + err = test.seedDB(false) + if err != nil { + t.Fatal(err) + } + } + + exchange.ResetExchangeCache() + testFile := filepath.Join("..", "..", "..", "testdata", "binance_BTCUSDT_24h_2019_01_01_2020_01_01.csv") + count, err := InsertFromCSV(testExchanges[0].Name, "BTC", "USDT", 86400, "spot", testFile) + if err != nil { + t.Fatal(err) + } + if count != 365 { + t.Fatalf("expected 365 results to be inserted received: %v", count) + } + + err = testhelpers.CloseDatabase(dbConn) + if err != nil { + t.Error(err) + } + }) + } +} + +func TestSeries(t *testing.T) { + testCases := []struct { + name string + config *database.Config + seedDB func(includeOHLCVData bool) error + runner func(t *testing.T) + closer func(dbConn *database.Instance) error + }{ + { + name: "postgresql", + config: testhelpers.PostgresTestDatabase, + seedDB: seedDB, + }, + { + name: "SQLite", + config: &database.Config{ + Driver: database.DBSQLite3, + ConnectionDetails: drivers.ConnectionDetails{Database: "./testdb"}, + }, + seedDB: seedDB, + }, + } + + for x := range testCases { + test := testCases[x] + + t.Run(test.name, func(t *testing.T) { + if !testhelpers.CheckValidConfig(&test.config.ConnectionDetails) { + t.Skip("database not configured skipping test") + } + + dbConn, err := testhelpers.ConnectToDatabase(test.config) + if err != nil { + t.Fatal(err) + } + + if test.seedDB != nil { + err = test.seedDB(true) + if err != nil { + t.Fatal(err) + } + } + + start := time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC) + end := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC) + ret, err := Series(testExchanges[0].Name, + "BTC", "USDT", + 86400, "spot", + start, end) + if err != nil { + t.Fatal(err) + } + if len(ret.Candles) != 365 { + t.Errorf("unexpected number of results received: %v", len(ret.Candles)) + } + + ret, err = Series("", "", "", 0, "", start, end) + if err != nil { + if !errors.Is(err, errInvalidInput) { + t.Fatal(err) + } + } + + ret, err = Series(testExchanges[0].Name, + "BTC", "MOON", + 864000, "spot", + start, end) + if err != nil { + if !errors.Is(err, errInvalidInput) { + if err.Error() != fmt.Errorf(errNoCandleDataFound, testExchanges[0].Name, + "BTC", "MOON", + "864000", "spot").Error() { + t.Fatal(err) + } + } + } + + err = testhelpers.CloseDatabase(dbConn) + if err != nil { + t.Error(err) + } + }) + } +} + +func seedDB(includeOHLCVData bool) error { + err := exchange.InsertMany(testExchanges) + if err != nil { + return err + } + + if includeOHLCVData { + exchange.ResetExchangeCache() + data, err := genOHCLVData() + if err != nil { + return err + } + _, err = Insert(&data) + return err + } + return nil +} + +func genOHCLVData() (out Item, err error) { + exchangeUUID, err := exchange.UUIDByName(testExchanges[0].Name) + if err != nil { + return + } + out.ExchangeID = exchangeUUID.String() + out.Base = currency.BTC.String() + out.Quote = currency.USDT.String() + out.Interval = 86400 + out.Asset = "spot" + + start := time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC) + for x := 0; x < 365; x++ { + out.Candles = append(out.Candles, Candle{ + Timestamp: start.Add(time.Hour * 24 * time.Duration(x)), + Open: 1000, + High: 1000, + Low: 1000, + Close: 1000, + Volume: 1000, + }) + } + + return out, nil +} diff --git a/database/repository/candle/candle_types.go b/database/repository/candle/candle_types.go new file mode 100644 index 00000000..09477b56 --- /dev/null +++ b/database/repository/candle/candle_types.go @@ -0,0 +1,36 @@ +package candle + +import ( + "errors" + "time" +) + +const ( + errNoCandleDataFound = "no candle data found: %v %v %v %v %v" +) + +var ( + errInvalidInput = errors.New("exchange, base , quote, asset, interval, start & end cannot be empty") + errNoCandleData = errors.New("no candle data provided") +) + +// Item generic candle holder for modelPSQL & modelSQLite +type Item struct { + ID string + ExchangeID string + Base string + Quote string + Interval int64 + Asset string + Candles []Candle +} + +// Candle holds each interval +type Candle struct { + Timestamp time.Time + Open float64 + High float64 + Low float64 + Close float64 + Volume float64 +} diff --git a/database/repository/exchange/exchange.go b/database/repository/exchange/exchange.go new file mode 100644 index 00000000..c2d736e6 --- /dev/null +++ b/database/repository/exchange/exchange.go @@ -0,0 +1,229 @@ +package exchange + +import ( + "context" + "database/sql" + "encoding/csv" + "io" + "os" + "strings" + + "github.com/gofrs/uuid" + "github.com/thrasher-corp/gocryptotrader/common/cache" + "github.com/thrasher-corp/gocryptotrader/database" + modelPSQL "github.com/thrasher-corp/gocryptotrader/database/models/postgres" + modelSQLite "github.com/thrasher-corp/gocryptotrader/database/models/sqlite3" + "github.com/thrasher-corp/gocryptotrader/database/repository" + "github.com/thrasher-corp/gocryptotrader/log" + "github.com/thrasher-corp/sqlboiler/boil" + "github.com/thrasher-corp/sqlboiler/queries/qm" +) + +// One returns one exchange by Name +func One(in string) (Details, error) { + return one(in, "name") +} + +// OneByUUID returns one exchange by UUID +func OneByUUID(in uuid.UUID) (Details, error) { + return one(in.String(), "id") +} + +// one returns one exchange by clause +func one(in, clause string) (out Details, err error) { + if database.DB.SQL == nil { + return out, database.ErrDatabaseSupportDisabled + } + + whereQM := qm.Where(clause+"= ?", in) + if repository.GetSQLDialect() == database.DBSQLite3 { + ret, errS := modelSQLite.Exchanges(whereQM).One(context.Background(), database.DB.SQL) + if errS != nil { + return out, errS + } + out.Name = ret.Name + out.UUID, errS = uuid.FromString(ret.ID) + if errS != nil { + return out, errS + } + } else { + ret, errS := modelPSQL.Exchanges(whereQM).One(context.Background(), database.DB.SQL) + if errS != nil { + return out, errS + } + out.Name = ret.Name + out.UUID, errS = uuid.FromString(ret.ID) + if errS != nil { + return out, errS + } + } + + return out, err +} + +// Insert writes a single entry into database +func Insert(in Details) error { + if database.DB.SQL == nil { + return database.ErrDatabaseSupportDisabled + } + + ctx := context.Background() + tx, err := database.DB.SQL.BeginTx(ctx, nil) + if err != nil { + return err + } + + if repository.GetSQLDialect() == database.DBSQLite3 { + err = insertSQLite(ctx, tx, []Details{in}) + } else { + err = insertPostgresql(ctx, tx, []Details{in}) + } + + if err != nil { + errRB := tx.Rollback() + if errRB != nil { + log.Errorln(log.DatabaseMgr, errRB) + } + return err + } + + err = tx.Commit() + if err != nil { + return err + } + + return nil +} + +// InsertMany writes multiple entries into database +func InsertMany(in []Details) error { + if database.DB.SQL == nil { + return database.ErrDatabaseSupportDisabled + } + + ctx := context.Background() + tx, err := database.DB.SQL.BeginTx(ctx, nil) + if err != nil { + return err + } + + if repository.GetSQLDialect() == database.DBSQLite3 { + err = insertSQLite(ctx, tx, in) + } else { + err = insertPostgresql(ctx, tx, in) + } + + if err != nil { + errRB := tx.Rollback() + if errRB != nil { + log.Errorln(log.DatabaseMgr, errRB) + } + return err + } + + err = tx.Commit() + if err != nil { + errRB := tx.Rollback() + if errRB != nil { + log.Errorln(log.DatabaseMgr, errRB) + } + return err + } + return nil +} + +func insertSQLite(ctx context.Context, tx *sql.Tx, in []Details) (err error) { + for x := range in { + tempUUID, errUUID := uuid.NewV4() + if errUUID != nil { + return errUUID + } + var tempInsert = modelSQLite.Exchange{ + Name: in[x].Name, + ID: tempUUID.String(), + } + + err = tempInsert.Insert(ctx, tx, boil.Infer()) + if err != nil { + errRB := tx.Rollback() + if errRB != nil { + log.Errorln(log.DatabaseMgr, errRB) + } + return err + } + } + + return nil +} + +func insertPostgresql(ctx context.Context, tx *sql.Tx, in []Details) (err error) { + for x := range in { + var tempInsert = modelPSQL.Exchange{ + Name: in[x].Name, + } + + err = tempInsert.Upsert(ctx, tx, true, []string{"name"}, boil.Infer(), boil.Infer()) + if err != nil { + errRB := tx.Rollback() + if errRB != nil { + log.Errorln(log.DatabaseMgr, errRB) + } + return + } + } + return nil +} + +// UUIDByName returns UUID of exchange +func UUIDByName(exchange string) (uuid.UUID, error) { + exchange = strings.ToLower(exchange) + v := exchangeCache.Get(exchange) + if v != nil { + return v.(uuid.UUID), nil + } + ret, err := One(exchange) + if err != nil { + if err != sql.ErrNoRows { + return uuid.UUID{}, err + } + return uuid.UUID{}, ErrNoExchangeFound + } + + exchangeCache.Add(exchange, ret.UUID) + return ret.UUID, nil +} + +// ResetExchangeCache reinitialise cache to blank state used to clear cache for testing +func ResetExchangeCache() { + exchangeCache = cache.New(10) +} + +// LoadCSV loads & parses a CSV list of exchanges +func LoadCSV(file string) (out []Details, err error) { + csvFile, err := os.Open(file) + if err != nil { + return out, err + } + + defer func() { + err = csvFile.Close() + if err != nil { + log.Errorln(log.Global, err) + } + }() + + csvData := csv.NewReader(csvFile) + for { + row, errCSV := csvData.Read() + if errCSV != nil { + if errCSV == io.EOF { + return out, err + } + return out, errCSV + } + + out = append(out, Details{ + Name: row[0], + }) + } +} diff --git a/database/repository/exchange/exchange_test.go b/database/repository/exchange/exchange_test.go new file mode 100644 index 00000000..1ce6a359 --- /dev/null +++ b/database/repository/exchange/exchange_test.go @@ -0,0 +1,184 @@ +package exchange + +import ( + "fmt" + "io/ioutil" + "os" + "path/filepath" + "testing" + + "github.com/thrasher-corp/gocryptotrader/database" + "github.com/thrasher-corp/gocryptotrader/database/drivers" + "github.com/thrasher-corp/gocryptotrader/database/testhelpers" +) + +var ( + verbose = false + + testExchanges = []Details{ + { + Name: "one", + }, + { + Name: "two", + }, + { + Name: "three", + }, + } +) + +func TestMain(m *testing.M) { + if verbose { + testhelpers.EnableVerboseTestOutput() + } + + var err error + testhelpers.PostgresTestDatabase = testhelpers.GetConnectionDetails() + testhelpers.TempDir, err = ioutil.TempDir("", "gct-temp") + if err != nil { + fmt.Printf("failed to create temp file: %v", err) + os.Exit(1) + } + + t := m.Run() + + err = os.RemoveAll(testhelpers.TempDir) + if err != nil { + fmt.Printf("Failed to remove temp db file: %v", err) + } + + os.Exit(t) +} + +func TestInsertMany(t *testing.T) { + testCases := []struct { + name string + config *database.Config + seedDB func() error + runner func(t *testing.T) + closer func(dbConn *database.Instance) error + }{ + { + name: "postgresql", + config: testhelpers.PostgresTestDatabase, + seedDB: seed, + }, + { + name: "SQLite", + config: &database.Config{ + Driver: database.DBSQLite3, + ConnectionDetails: drivers.ConnectionDetails{Database: "./testdb"}, + }, + seedDB: seed, + }, + } + + for x := range testCases { + test := testCases[x] + + t.Run(test.name, func(t *testing.T) { + if !testhelpers.CheckValidConfig(&test.config.ConnectionDetails) { + t.Skip("database not configured skipping test") + } + + dbConn, err := testhelpers.ConnectToDatabase(test.config) + if err != nil { + t.Fatal(err) + } + + if test.seedDB != nil { + err = test.seedDB() + if err != nil { + t.Error(err) + } + } + + err = InsertMany(testExchanges) + if err != nil { + t.Fatal(err) + } + + err = testhelpers.CloseDatabase(dbConn) + if err != nil { + t.Error(err) + } + }) + } +} + +func TestOneAndOneByUUID(t *testing.T) { + testCases := []struct { + name string + config *database.Config + seedDB func() error + runner func(t *testing.T) + closer func(dbConn *database.Instance) error + }{ + { + name: "postgresql", + config: testhelpers.PostgresTestDatabase, + seedDB: seed, + }, + { + name: "SQLite", + config: &database.Config{ + Driver: database.DBSQLite3, + ConnectionDetails: drivers.ConnectionDetails{Database: "./testdb"}, + }, + seedDB: seed, + }, + } + + for x := range testCases { + test := testCases[x] + + t.Run(test.name, func(t *testing.T) { + if !testhelpers.CheckValidConfig(&test.config.ConnectionDetails) { + t.Skip("database not configured skipping test") + } + + dbConn, err := testhelpers.ConnectToDatabase(test.config) + if err != nil { + t.Fatal(err) + } + + if test.seedDB != nil { + err = test.seedDB() + if err != nil { + t.Error(err) + } + } + + ret, err := One("one") + if err != nil { + t.Fatal(err) + } + + ret2, err := OneByUUID(ret.UUID) + if err != nil { + t.Fatal(err) + } + + if ret.Name != ret2.Name { + t.Fatalf("unexpected value received: %v", ret2.Name) + } + err = testhelpers.CloseDatabase(dbConn) + if err != nil { + t.Error(err) + } + }) + } +} + +func seed() error { + return InsertMany(testExchanges) +} + +func TestLoadCSV(t *testing.T) { + testData := filepath.Join("..", "..", "..", "testdata", "exchangelist.csv") + _, err := LoadCSV(testData) + if err != nil { + t.Fatal(err) + } +} diff --git a/database/repository/exchange/exchange_types.go b/database/repository/exchange/exchange_types.go new file mode 100644 index 00000000..b143e8df --- /dev/null +++ b/database/repository/exchange/exchange_types.go @@ -0,0 +1,19 @@ +package exchange + +import ( + "errors" + + "github.com/gofrs/uuid" + "github.com/thrasher-corp/gocryptotrader/common/cache" +) + +var ( + exchangeCache = cache.New(10) + ErrNoExchangeFound = errors.New("exchange not found") +) + +// Details holds exchange information such as Name +type Details struct { + UUID uuid.UUID + Name string +} diff --git a/database/repository/repository_test.go b/database/repository/repository_test.go new file mode 100644 index 00000000..140c0f0b --- /dev/null +++ b/database/repository/repository_test.go @@ -0,0 +1,44 @@ +package repository + +import ( + "testing" + + "github.com/thrasher-corp/gocryptotrader/database" +) + +func TestGetSQLDialect(t *testing.T) { + testCases := []struct { + driver string + expectedReturn string + }{ + { + "postgresql", + database.DBPostgreSQL, + }, + { + "sqlite", + database.DBSQLite3, + }, + { + "sqlite3", + database.DBSQLite3, + }, + { + "invalid", + database.DBInvalidDriver, + }, + } + for x := range testCases { + test := testCases[x] + + t.Run(test.driver, func(t *testing.T) { + database.DB.Config = &database.Config{ + Driver: test.driver, + } + ret := GetSQLDialect() + if ret != test.expectedReturn { + t.Fatalf("unexpected return: %v", ret) + } + }) + } +} diff --git a/database/repository/script/script.go b/database/repository/script/script.go index d200acde..9bc575b8 100644 --- a/database/repository/script/script.go +++ b/database/repository/script/script.go @@ -118,9 +118,5 @@ func Event(id, name, path string, data null.Bytes, executionType, status string, err = tx.Commit() if err != nil { log.Errorf(log.DatabaseMgr, "Event Transaction commit failed: %v", err) - err = tx.Rollback() - if err != nil { - log.Errorf(log.DatabaseMgr, "Event Transaction rollback failed: %v", err) - } } } diff --git a/database/repository/script/script_test.go b/database/repository/script/script_test.go index 64c20bca..51812a12 100644 --- a/database/repository/script/script_test.go +++ b/database/repository/script/script_test.go @@ -4,19 +4,20 @@ import ( "fmt" "io/ioutil" "os" - "path/filepath" "sync" "testing" "time" "github.com/thrasher-corp/gocryptotrader/database" "github.com/thrasher-corp/gocryptotrader/database/drivers" - "github.com/thrasher-corp/gocryptotrader/database/repository" "github.com/thrasher-corp/gocryptotrader/database/testhelpers" - "github.com/thrasher-corp/goose" "github.com/volatiletech/null" ) +var ( + verbose = false +) + func TestMain(m *testing.M) { var err error testhelpers.PostgresTestDatabase = testhelpers.GetConnectionDetails() @@ -26,6 +27,10 @@ func TestMain(m *testing.M) { os.Exit(1) } + if verbose { + testhelpers.EnableVerboseTestOutput() + } + t := m.Run() err = os.RemoveAll(testhelpers.TempDir) @@ -63,8 +68,8 @@ func TestScript(t *testing.T) { }, } - for _, tests := range testCases { - test := tests + for x := range testCases { + test := testCases[x] t.Run(test.name, func(t *testing.T) { if !testhelpers.CheckValidConfig(&test.config.ConnectionDetails) { t.Skip("database not configured skipping test") @@ -75,12 +80,6 @@ func TestScript(t *testing.T) { t.Fatal(err) } - path := filepath.Join("..", "..", "migrations") - err = goose.Run("up", dbConn.SQL, repository.GetSQLDialect(), path, "") - if err != nil { - t.Fatalf("failed to run migrations %v", err) - } - if test.runner != nil { test.runner() } diff --git a/database/repository/withdraw/withdraw.go b/database/repository/withdraw/withdraw.go index 2360be17..6c4b539d 100644 --- a/database/repository/withdraw/withdraw.go +++ b/database/repository/withdraw/withdraw.go @@ -12,6 +12,7 @@ import ( modelPSQL "github.com/thrasher-corp/gocryptotrader/database/models/postgres" modelSQLite "github.com/thrasher-corp/gocryptotrader/database/models/sqlite3" "github.com/thrasher-corp/gocryptotrader/database/repository" + exchangeDB "github.com/thrasher-corp/gocryptotrader/database/repository/exchange" "github.com/thrasher-corp/gocryptotrader/log" "github.com/thrasher-corp/gocryptotrader/portfolio/banking" "github.com/thrasher-corp/gocryptotrader/portfolio/withdraw" @@ -33,6 +34,13 @@ func Event(res *withdraw.Response) { ctx := context.Background() ctx = boil.SkipTimestamps(ctx) + exchangeUUID, err := exchangeDB.UUIDByName(res.Exchange.Name) + if err != nil { + log.Error(log.DatabaseMgr, err) + return + } + + res.Exchange.Name = exchangeUUID.String() tx, err := database.DB.SQL.BeginTx(ctx, nil) if err != nil { log.Errorf(log.DatabaseMgr, "Event transaction being failed: %v", err) @@ -56,22 +64,18 @@ func Event(res *withdraw.Response) { err = tx.Commit() if err != nil { log.Errorf(log.DatabaseMgr, "Event Transaction commit failed: %v", err) - err = tx.Rollback() - if err != nil { - log.Errorf(log.DatabaseMgr, "Event Transaction rollback failed: %v", err) - } return } } func addPSQLEvent(ctx context.Context, tx *sql.Tx, res *withdraw.Response) (err error) { var tempEvent = modelPSQL.WithdrawalHistory{ - Exchange: res.Exchange.Name, - ExchangeID: res.Exchange.ID, - Status: res.Exchange.Status, - Currency: res.RequestDetails.Currency.String(), - Amount: res.RequestDetails.Amount, - WithdrawType: int(res.RequestDetails.Type), + ExchangeNameID: res.Exchange.Name, + ExchangeID: res.Exchange.ID, + Status: res.Exchange.Status, + Currency: res.RequestDetails.Currency.String(), + Amount: res.RequestDetails.Amount, + WithdrawType: int(res.RequestDetails.Type), } if res.RequestDetails.Description != "" { @@ -146,13 +150,13 @@ func addSQLiteEvent(ctx context.Context, tx *sql.Tx, res *withdraw.Response) (er } var tempEvent = modelSQLite.WithdrawalHistory{ - ID: newUUID.String(), - Exchange: res.Exchange.Name, - ExchangeID: res.Exchange.ID, - Status: res.Exchange.Status, - Currency: res.RequestDetails.Currency.String(), - Amount: res.RequestDetails.Amount, - WithdrawType: int64(res.RequestDetails.Type), + ID: newUUID.String(), + ExchangeNameID: res.Exchange.Name, + ExchangeID: res.Exchange.ID, + Status: res.Exchange.Status, + Currency: res.RequestDetails.Currency.String(), + Amount: res.RequestDetails.Amount, + WithdrawType: int64(res.RequestDetails.Type), } if res.RequestDetails.Description != "" { @@ -227,12 +231,22 @@ func GetEventByUUID(id string) (*withdraw.Response, error) { // GetEventsByExchange returns all withdrawal requests by exchange func GetEventsByExchange(exchange string, limit int) ([]*withdraw.Response, error) { - return getByColumns(generateWhereQuery([]string{"exchange"}, []string{exchange}, limit)) + exch, err := exchangeDB.UUIDByName(exchange) + if err != nil { + log.Error(log.DatabaseMgr, err) + return nil, err + } + return getByColumns(generateWhereQuery([]string{"exchange_name_id"}, []string{exch.String()}, limit)) } // GetEventByExchangeID return requested withdraw information by Exchange ID func GetEventByExchangeID(exchange, id string) (*withdraw.Response, error) { - resp, err := getByColumns(generateWhereQuery([]string{"exchange", "exchange_id"}, []string{exchange, id}, 1)) + exch, err := exchangeDB.UUIDByName(exchange) + if err != nil { + log.Error(log.DatabaseMgr, err) + return nil, err + } + resp, err := getByColumns(generateWhereQuery([]string{"exchange_name_id", "exchange_id"}, []string{exch.String(), id}, 1)) if err != nil { return nil, err } @@ -245,7 +259,12 @@ func GetEventsByDate(exchange string, start, end time.Time, limit int) ([]*withd if exchange == "" { return getByColumns(betweenQuery) } - return getByColumns(append(generateWhereQuery([]string{"exchange"}, []string{exchange}, 0), betweenQuery...)) + exch, err := exchangeDB.UUIDByName(exchange) + if err != nil { + log.Error(log.DatabaseMgr, err) + return nil, err + } + return getByColumns(append(generateWhereQuery([]string{"exchange_name_id"}, []string{exch.String()}, 0), betweenQuery...)) } func generateWhereQuery(columns, id []string, limit int) []qm.QueryMod { @@ -284,7 +303,6 @@ func getByColumns(q []qm.QueryMod) ([]*withdraw.Response, error) { tempResp.ID = newUUID tempResp.Exchange = new(withdraw.ExchangeResponse) tempResp.Exchange.ID = v[x].ExchangeID - tempResp.Exchange.Name = v[x].Exchange tempResp.Exchange.Status = v[x].Status tempResp.RequestDetails = new(withdraw.Request) tempResp.RequestDetails = &withdraw.Request{ @@ -294,6 +312,19 @@ func getByColumns(q []qm.QueryMod) ([]*withdraw.Response, error) { Type: withdraw.RequestType(v[x].WithdrawType), } + exchangeName, err := v[x].ExchangeName().One(ctx, database.DB.SQL) + if err != nil { + log.Errorf(log.DatabaseMgr, "Unable to get exchange name") + tempUUID, errUUID := uuid.FromString(v[x].ExchangeNameID) + if errUUID != nil { + log.Errorf(log.DatabaseMgr, "invalid exchange name UUID for record %v", v[x].ID) + } else { + tempResp.Exchange.UUID = tempUUID + } + } else { + tempResp.Exchange.Name = exchangeName.Name + } + createdAtTime, err := time.Parse(time.RFC3339, v[x].CreatedAt) if err != nil { log.Errorf(log.DatabaseMgr, "record: %v has an incorrect time format ( %v ) - defaulting to empty time: %v", tempResp.ID, v[x].CreatedAt, err) @@ -346,7 +377,6 @@ func getByColumns(q []qm.QueryMod) ([]*withdraw.Response, error) { tempResp.ID = newUUID tempResp.Exchange = new(withdraw.ExchangeResponse) tempResp.Exchange.ID = v[x].ExchangeID - tempResp.Exchange.Name = v[x].Exchange tempResp.Exchange.Status = v[x].Status tempResp.RequestDetails = new(withdraw.Request) tempResp.RequestDetails = &withdraw.Request{ @@ -358,6 +388,19 @@ func getByColumns(q []qm.QueryMod) ([]*withdraw.Response, error) { tempResp.CreatedAt = v[x].CreatedAt tempResp.UpdatedAt = v[x].UpdatedAt + exchangeName, err := v[x].ExchangeName().One(ctx, database.DB.SQL) + if err != nil { + log.Errorf(log.DatabaseMgr, "Unable to get exchange name") + tempUUID, errUUID := uuid.FromString(v[x].ExchangeNameID) + if errUUID != nil { + log.Errorf(log.DatabaseMgr, "invalid exchange name UUID for record %v", v[x].ID) + } else { + tempResp.Exchange.UUID = tempUUID + } + } else { + tempResp.Exchange.Name = exchangeName.Name + } + if withdraw.RequestType(v[x].WithdrawType) == withdraw.Crypto { tempResp.RequestDetails.Crypto = new(withdraw.CryptoRequest) x, err := v[x].WithdrawalCryptoWithdrawalCryptos().One(ctx, database.DB.SQL) diff --git a/database/repository/withdraw/withdraw_test.go b/database/repository/withdraw/withdraw_test.go index 33e3f6a7..35a0be4e 100644 --- a/database/repository/withdraw/withdraw_test.go +++ b/database/repository/withdraw/withdraw_test.go @@ -6,22 +6,32 @@ import ( "io/ioutil" "math/rand" "os" - "path/filepath" - "sync" "testing" "time" "github.com/thrasher-corp/gocryptotrader/currency" "github.com/thrasher-corp/gocryptotrader/database" "github.com/thrasher-corp/gocryptotrader/database/drivers" - "github.com/thrasher-corp/gocryptotrader/database/repository" + "github.com/thrasher-corp/gocryptotrader/database/repository/exchange" "github.com/thrasher-corp/gocryptotrader/database/testhelpers" "github.com/thrasher-corp/gocryptotrader/portfolio/banking" "github.com/thrasher-corp/gocryptotrader/portfolio/withdraw" - "github.com/thrasher-corp/goose" +) + +var ( + verbose = false + testExchanges = []exchange.Details{ + { + Name: "one", + }, + } ) func TestMain(m *testing.M) { + if verbose { + testhelpers.EnableVerboseTestOutput() + } + var err error testhelpers.PostgresTestDatabase = testhelpers.GetConnectionDetails() testhelpers.TempDir, err = ioutil.TempDir("", "gct-temp") @@ -79,10 +89,9 @@ func TestWithdraw(t *testing.T) { t.Fatal(err) } - path := filepath.Join("..", "..", "migrations") - err = goose.Run("up", dbConn.SQL, repository.GetSQLDialect(), path, "") + err = exchange.InsertMany(testExchanges) if err != nil { - t.Fatalf("failed to run migrations %v", err) + t.Fatal(err) } if test.runner != nil { @@ -99,45 +108,42 @@ func TestWithdraw(t *testing.T) { } } -func withdrawHelper(t *testing.T) { - t.Helper() - var wg sync.WaitGroup +func seedWithdrawData() { for x := 0; x < 20; x++ { - wg.Add(1) - go func(x int) { - defer wg.Done() - test := fmt.Sprintf("test-%v", x) - resp := &withdraw.Response{ - Exchange: &withdraw.ExchangeResponse{ - Name: test, - ID: test, - Status: test, - }, - RequestDetails: &withdraw.Request{ - Exchange: test, - Description: test, - Amount: 1.0, - }, - } - rnd := rand.Intn(2) - if rnd == 0 { - resp.RequestDetails.Currency = currency.AUD - resp.RequestDetails.Type = 1 - resp.RequestDetails.Fiat = new(withdraw.FiatRequest) - resp.RequestDetails.Fiat.Bank = new(banking.Account) - } else { - resp.RequestDetails.Currency = currency.BTC - resp.RequestDetails.Type = 0 - resp.RequestDetails.Crypto = new(withdraw.CryptoRequest) - resp.RequestDetails.Crypto.Address = test - resp.RequestDetails.Crypto.FeeAmount = 0 - resp.RequestDetails.Crypto.AddressTag = test - } - Event(resp) - }(x) + test := fmt.Sprintf("test-%v", x) + resp := &withdraw.Response{ + Exchange: &withdraw.ExchangeResponse{ + Name: testExchanges[0].Name, + ID: test, + Status: test, + }, + RequestDetails: &withdraw.Request{ + Exchange: testExchanges[0].Name, + Description: test, + Amount: 1.0, + }, + } + rnd := rand.Intn(2) + if rnd == 0 { + resp.RequestDetails.Currency = currency.AUD + resp.RequestDetails.Type = 1 + resp.RequestDetails.Fiat = new(withdraw.FiatRequest) + resp.RequestDetails.Fiat.Bank = new(banking.Account) + } else { + resp.RequestDetails.Currency = currency.BTC + resp.RequestDetails.Type = 0 + resp.RequestDetails.Crypto = new(withdraw.CryptoRequest) + resp.RequestDetails.Crypto.Address = test + resp.RequestDetails.Crypto.FeeAmount = 0 + resp.RequestDetails.Crypto.AddressTag = test + } + exchange.ResetExchangeCache() + Event(resp) } +} +func withdrawHelper(t *testing.T) { + seedWithdrawData() - wg.Wait() _, err := GetEventByUUID(withdraw.DryRunID.String()) if err != nil { if !errors.Is(err, ErrNoResults) { @@ -145,27 +151,31 @@ func withdrawHelper(t *testing.T) { } } - v, err := GetEventsByExchange("test-1", 10) + v, err := GetEventsByExchange(testExchanges[0].Name, 10) if err != nil { - t.Fatal(err) + t.Error(err) } - _, err = GetEventByExchangeID("test-1", "test-1") + if v[0].Exchange.Name != testExchanges[0].Name { + t.Fatalf("expected name to be translated to valid string instead received: %v", v[0].Exchange.Name) + } + + _, err = GetEventByExchangeID(testExchanges[0].Name, "test-1") if err != nil { - t.Fatal(err) + t.Error(err) } if len(v) > 0 { _, err = GetEventByUUID(v[0].ID.String()) if err != nil { if !errors.Is(err, ErrNoResults) { - t.Fatal(err) + t.Error(err) } } } - _, err = GetEventsByDate("test-1", time.Now().UTC().Add(-time.Minute), time.Now().UTC(), 5) + _, err = GetEventsByDate(testExchanges[0].Name, time.Now().UTC().Add(-time.Minute), time.Now().UTC(), 5) if err != nil { - t.Fatal(err) + t.Error(err) } } diff --git a/database/testhelpers/test_helpers.go b/database/testhelpers/test_helpers.go index 43e7439d..ea617f3a 100644 --- a/database/testhelpers/test_helpers.go +++ b/database/testhelpers/test_helpers.go @@ -1,13 +1,19 @@ package testhelpers import ( + "database/sql" "os" + "path/filepath" "reflect" "github.com/thrasher-corp/gocryptotrader/database" "github.com/thrasher-corp/gocryptotrader/database/drivers" psqlConn "github.com/thrasher-corp/gocryptotrader/database/drivers/postgres" sqliteConn "github.com/thrasher-corp/gocryptotrader/database/drivers/sqlite3" + "github.com/thrasher-corp/gocryptotrader/database/repository" + "github.com/thrasher-corp/gocryptotrader/log" + "github.com/thrasher-corp/goose" + "github.com/thrasher-corp/sqlboiler/boil" ) var ( @@ -15,6 +21,8 @@ var ( TempDir string // PostgresTestDatabase postgresql database config details PostgresTestDatabase *database.Config + // MigrationDir default folder for migration's + MigrationDir = filepath.Join("..", "..", "migrations") ) // GetConnectionDetails returns connection details for CI or test db instances @@ -68,7 +76,6 @@ func GetConnectionDetails() *database.Config { // ConnectToDatabase opens connection to database and returns pointer to instance of database.DB func ConnectToDatabase(conn *database.Config) (dbConn *database.Instance, err error) { database.DB.Config = conn - if conn.Driver == database.DBPostgreSQL { dbConn, err = psqlConn.Connect() if err != nil { @@ -77,12 +84,16 @@ func ConnectToDatabase(conn *database.Config) (dbConn *database.Instance, err er } else if conn.Driver == database.DBSQLite3 || conn.Driver == database.DBSQLite { database.DB.DataPath = TempDir dbConn, err = sqliteConn.Connect() - if err != nil { return nil, err } } - database.DB.Connected = true + + err = migrateDB(database.DB.SQL) + if err != nil { + return nil, err + } + return } @@ -98,3 +109,18 @@ func CloseDatabase(conn *database.Instance) (err error) { func CheckValidConfig(config *drivers.ConnectionDetails) bool { return !reflect.DeepEqual(drivers.ConnectionDetails{}, *config) } + +func migrateDB(db *sql.DB) error { + return goose.Run("up", db, repository.GetSQLDialect(), MigrationDir, "") +} + +// EnableVerboseTestOutput enables debug output for SQL queries +func EnableVerboseTestOutput() { + c := log.GenDefaultSettings() + log.GlobalLogConfig = &c + log.SetupGlobalLogger() + + DBLogger := database.Logger{} + boil.DebugMode = true + boil.DebugWriter = DBLogger +} diff --git a/database/testhelpers/test_helpers_test.go b/database/testhelpers/test_helpers_test.go index ff404ca5..02723a6c 100644 --- a/database/testhelpers/test_helpers_test.go +++ b/database/testhelpers/test_helpers_test.go @@ -4,6 +4,7 @@ import ( "fmt" "io/ioutil" "os" + "path/filepath" "testing" "github.com/thrasher-corp/gocryptotrader/database" @@ -19,6 +20,7 @@ func TestMain(m *testing.M) { os.Exit(1) } + MigrationDir = filepath.Join("..", "migrations") t := m.Run() err = os.RemoveAll(TempDir) @@ -63,8 +65,8 @@ func TestDatabaseConnect(t *testing.T) { }, } - for _, tests := range testCases { - test := tests + for x := range testCases { + test := testCases[x] t.Run(test.name, func(t *testing.T) { if !CheckValidConfig(&test.config.ConnectionDetails) { t.Skip("database not configured skipping test") diff --git a/docs/OHLCV.md b/docs/OHLCV.md index 49f40d62..fb3cdad8 100644 --- a/docs/OHLCV.md +++ b/docs/OHLCV.md @@ -58,6 +58,10 @@ type Candle struct { } ``` +### DBSeed helper + +A helper tool [cmd/dbseed](../cmd/dbseed/README.md) has been created for assisting with candle data migration + ## Exchange status | Exchange | Supported | |----------------|-------------| diff --git a/engine/rpcserver.go b/engine/rpcserver.go index c66b8b2f..c1afc752 100644 --- a/engine/rpcserver.go +++ b/engine/rpcserver.go @@ -27,6 +27,7 @@ import ( "github.com/thrasher-corp/gocryptotrader/database/models/postgres" "github.com/thrasher-corp/gocryptotrader/database/models/sqlite3" "github.com/thrasher-corp/gocryptotrader/database/repository/audit" + exchangeDB "github.com/thrasher-corp/gocryptotrader/database/repository/exchange" "github.com/thrasher-corp/gocryptotrader/exchanges/account" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" "github.com/thrasher-corp/gocryptotrader/exchanges/kline" @@ -1607,47 +1608,58 @@ func (s *RPCServer) GetHistoricCandles(_ context.Context, req *gctrpc.GetHistori return nil, errors.New(errCurrencyPairUnset) } - exchange := GetExchangeByName(req.Exchange) - if exchange == nil { - return nil, errors.New("Exchange " + req.Exchange + " not found") - } - var candles kline.Item var err error - if req.ExRequest { - candles, err = exchange.GetHistoricCandlesExtended(currency.Pair{ - Delimiter: req.Pair.Delimiter, - Base: currency.NewCode(req.Pair.Base), - Quote: currency.NewCode(req.Pair.Quote), - }, - asset.Item(strings.ToLower(req.AssetType)), - time.Unix(req.Start, 0), - time.Unix(req.End, 0), - kline.Interval(req.TimeInterval)) - if err != nil { - return nil, err - } - } else { - candles, err = exchange.GetHistoricCandles(currency.Pair{ - Delimiter: req.Pair.Delimiter, - Base: currency.NewCode(req.Pair.Base), - Quote: currency.NewCode(req.Pair.Quote), - }, - asset.Item(strings.ToLower(req.AssetType)), - time.Unix(req.Start, 0), - time.Unix(req.End, 0), - kline.Interval(req.TimeInterval)) - if err != nil { - return nil, err - } - } resp := gctrpc.GetHistoricCandlesResponse{ - Exchange: exchange.GetName(), Interval: kline.Interval(req.TimeInterval).Short(), + Pair: req.Pair, Start: req.Start, End: req.End, } + if req.UseDb { + candles, err = kline.LoadFromDatabase(req.Exchange, + currency.Pair{ + Delimiter: req.Pair.Delimiter, + Base: currency.NewCode(req.Pair.Base), + Quote: currency.NewCode(req.Pair.Quote), + }, + asset.Item(strings.ToLower(req.AssetType)), + kline.Interval(req.TimeInterval), + time.Unix(req.Start, 0), + time.Unix(req.End, 0), + ) + } else { + exchangeEngine := GetExchangeByName(req.Exchange) + if exchangeEngine == nil { + return nil, errors.New("Exchange " + req.Exchange + " not found") + } + if req.ExRequest { + candles, err = exchangeEngine.GetHistoricCandlesExtended(currency.Pair{ + Delimiter: req.Pair.Delimiter, + Base: currency.NewCode(req.Pair.Base), + Quote: currency.NewCode(req.Pair.Quote), + }, + asset.Item(strings.ToLower(req.AssetType)), + time.Unix(req.Start, 0), + time.Unix(req.End, 0), + kline.Interval(req.TimeInterval)) + } else { + candles, err = exchangeEngine.GetHistoricCandles(currency.Pair{ + Delimiter: req.Pair.Delimiter, + Base: currency.NewCode(req.Pair.Base), + Quote: currency.NewCode(req.Pair.Quote), + }, + asset.Item(strings.ToLower(req.AssetType)), + time.Unix(req.Start, 0), + time.Unix(req.End, 0), + kline.Interval(req.TimeInterval)) + } + } + if err != nil { + return nil, err + } + resp.Exchange = candles.Exchange for i := range candles.Candles { resp.Candle = append(resp.Candle, &gctrpc.Candle{ Time: candles.Candles[i].Time.Unix(), @@ -1658,6 +1670,16 @@ func (s *RPCServer) GetHistoricCandles(_ context.Context, req *gctrpc.GetHistori Volume: candles.Candles[i].Volume, }) } + + if req.Sync && !req.UseDb { + _, err = kline.StoreInDatabase(&candles) + if err != nil { + if errors.Is(err, exchangeDB.ErrNoExchangeFound) { + return nil, errors.New("exchange was not found in database, you can seed existing data or insert a new exchange via the dbseed") + } + return nil, err + } + } return &resp, nil } diff --git a/engine/withdraw.go b/engine/withdraw.go index 40c3ffb8..3f5c6063 100644 --- a/engine/withdraw.go +++ b/engine/withdraw.go @@ -120,7 +120,7 @@ func parseMultipleEvents(ret []*withdraw.Response) *gctrpc.WithdrawalEventsByExc Id: ret[x].ID.String(), Exchange: &gctrpc.WithdrawlExchangeEvent{ Name: ret[x].Exchange.Name, - Id: ret[x].Exchange.Name, + Id: ret[x].Exchange.ID, Status: ret[x].Exchange.Status, }, Request: &gctrpc.WithdrawalRequestEvent{ diff --git a/exchanges/binance/binance_test.go b/exchanges/binance/binance_test.go index 6fa58ab7..449eeb73 100644 --- a/exchanges/binance/binance_test.go +++ b/exchanges/binance/binance_test.go @@ -905,7 +905,7 @@ func TestExecutionTypeToOrderStatus(t *testing.T) { } func TestGetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSDT") + currencyPair, err := currency.NewPairFromString("BTC-USDT") if err != nil { t.Fatal(err) } @@ -923,7 +923,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSDT") + currencyPair, err := currency.NewPairFromString("BTC-USDT") if err != nil { t.Fatal(err) } diff --git a/exchanges/binance/binance_wrapper.go b/exchanges/binance/binance_wrapper.go index ce6e5891..8fd4b59a 100644 --- a/exchanges/binance/binance_wrapper.go +++ b/exchanges/binance/binance_wrapper.go @@ -761,10 +761,8 @@ func (b *Binance) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (b *Binance) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } if kline.TotalCandlesPerInterval(start, end, interval) > b.Features.Enabled.Kline.ResultLimit { @@ -812,10 +810,8 @@ func (b *Binance) GetHistoricCandles(pair currency.Pair, a asset.Item, start, en // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (b *Binance) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ diff --git a/exchanges/bitfinex/bitfinex_test.go b/exchanges/bitfinex/bitfinex_test.go index 139ebe08..997933da 100644 --- a/exchanges/bitfinex/bitfinex_test.go +++ b/exchanges/bitfinex/bitfinex_test.go @@ -1253,7 +1253,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("TBTCUSD") + currencyPair, err := currency.NewPairFromString("BTCUSD") if err != nil { t.Fatal(err) } diff --git a/exchanges/bitfinex/bitfinex_wrapper.go b/exchanges/bitfinex/bitfinex_wrapper.go index f31a94ec..eb21b618 100644 --- a/exchanges/bitfinex/bitfinex_wrapper.go +++ b/exchanges/bitfinex/bitfinex_wrapper.go @@ -821,10 +821,8 @@ func (b *Bitfinex) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (b *Bitfinex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } if kline.TotalCandlesPerInterval(start, end, interval) > b.Features.Enabled.Kline.ResultLimit { @@ -866,10 +864,8 @@ func (b *Bitfinex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, e // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (b *Bitfinex) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ diff --git a/exchanges/bithumb/bithumb_test.go b/exchanges/bithumb/bithumb_test.go index e763fc93..c2bc7177 100644 --- a/exchanges/bithumb/bithumb_test.go +++ b/exchanges/bithumb/bithumb_test.go @@ -552,7 +552,7 @@ func TestGetCandleStick(t *testing.T) { } func TestGetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTC_KRW") + currencyPair, err := currency.NewPairFromString("BTCKRW") if err != nil { t.Fatal(err) } @@ -564,7 +564,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTC_KRW") + currencyPair, err := currency.NewPairFromString("BTCKRW") if err != nil { t.Fatal(err) } diff --git a/exchanges/bithumb/bithumb_wrapper.go b/exchanges/bithumb/bithumb_wrapper.go index 32701678..ad3b47b4 100644 --- a/exchanges/bithumb/bithumb_wrapper.go +++ b/exchanges/bithumb/bithumb_wrapper.go @@ -606,10 +606,8 @@ func (b *Bithumb) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (b *Bithumb) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := b.FormatExchangeCurrency(pair, a) diff --git a/exchanges/bitstamp/bitstamp_test.go b/exchanges/bitstamp/bitstamp_test.go index b8bfd573..9ee03721 100644 --- a/exchanges/bitstamp/bitstamp_test.go +++ b/exchanges/bitstamp/bitstamp_test.go @@ -678,7 +678,7 @@ func TestBitstamp_OHLC(t *testing.T) { } func TestBitstamp_GetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("btcusd") + currencyPair, err := currency.NewPairFromString("BTCUSD") if err != nil { t.Fatal(err) } @@ -692,7 +692,7 @@ func TestBitstamp_GetHistoricCandles(t *testing.T) { } func TestBitstamp_GetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("btcusd") + currencyPair, err := currency.NewPairFromString("BTCUSD") if err != nil { t.Fatal(err) } diff --git a/exchanges/bitstamp/bitstamp_wrapper.go b/exchanges/bitstamp/bitstamp_wrapper.go index 1ab4624c..20f84a46 100644 --- a/exchanges/bitstamp/bitstamp_wrapper.go +++ b/exchanges/bitstamp/bitstamp_wrapper.go @@ -674,10 +674,8 @@ func (b *Bitstamp) ValidateCredentials() error { // GetHistoricCandles returns candles between a time period for a set time interval func (b *Bitstamp) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ @@ -725,10 +723,8 @@ func (b *Bitstamp) GetHistoricCandles(pair currency.Pair, a asset.Item, start, e // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (b *Bitstamp) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ diff --git a/exchanges/btcmarkets/btcmarkets_test.go b/exchanges/btcmarkets/btcmarkets_test.go index 46acc76d..0a44710a 100644 --- a/exchanges/btcmarkets/btcmarkets_test.go +++ b/exchanges/btcmarkets/btcmarkets_test.go @@ -1,7 +1,6 @@ package btcmarkets import ( - "errors" "fmt" "log" "os" @@ -729,7 +728,7 @@ func TestBTCMarkets_GetHistoricCandles(t *testing.T) { } _, err = b.GetHistoricCandles(p, asset.Spot, time.Now().Add(-time.Hour*24).UTC(), time.Now().UTC(), kline.FifteenMin) if err != nil { - if !errors.As(err, &kline.ErrorKline{}) { + if err.Error() != "interval not supported" { t.Fatal(err) } } diff --git a/exchanges/btcmarkets/btcmarkets_wrapper.go b/exchanges/btcmarkets/btcmarkets_wrapper.go index d37372a6..55eff7cd 100644 --- a/exchanges/btcmarkets/btcmarkets_wrapper.go +++ b/exchanges/btcmarkets/btcmarkets_wrapper.go @@ -800,10 +800,8 @@ func (b *BTCMarkets) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (b *BTCMarkets) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } if kline.TotalCandlesPerInterval(start, end, interval) > b.Features.Enabled.Kline.ResultLimit { @@ -870,10 +868,8 @@ func (b *BTCMarkets) GetHistoricCandles(pair currency.Pair, a asset.Item, start, // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (b *BTCMarkets) GetHistoricCandlesExtended(p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !b.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := b.ValidateKline(p, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ diff --git a/exchanges/coinbasepro/coinbasepro_test.go b/exchanges/coinbasepro/coinbasepro_test.go index d3dd077b..e3c330ae 100644 --- a/exchanges/coinbasepro/coinbasepro_test.go +++ b/exchanges/coinbasepro/coinbasepro_test.go @@ -81,7 +81,7 @@ func TestGetTrades(t *testing.T) { func TestGetHistoricRatesGranularityCheck(t *testing.T) { end := time.Now() start := end.Add(-time.Hour * 2) - p := currency.NewPair(currency.BTC, currency.USD) + p := currency.NewPairWithDelimiter("BTC", "USD", "-") _, err := c.GetHistoricCandles(p, asset.Spot, start, end, kline.OneHour) if err != nil { t.Fatal(err) @@ -92,7 +92,7 @@ func TestCoinbasePro_GetHistoricCandlesExtended(t *testing.T) { start := time.Unix(1546300800, 0) end := time.Unix(1577836799, 0) - p := currency.NewPair(currency.BTC, currency.USD) + p := currency.NewPairWithDelimiter("BTC", "USD", "-") _, err := c.GetHistoricCandlesExtended(p, asset.Spot, start, end, kline.OneDay) if err != nil { t.Fatal(err) diff --git a/exchanges/coinbasepro/coinbasepro_wrapper.go b/exchanges/coinbasepro/coinbasepro_wrapper.go index b707fb98..2825e0d7 100644 --- a/exchanges/coinbasepro/coinbasepro_wrapper.go +++ b/exchanges/coinbasepro/coinbasepro_wrapper.go @@ -762,10 +762,8 @@ func checkInterval(i time.Duration) (int64, error) { // GetHistoricCandles returns a set of candle between two time periods for a // designated time period func (c *CoinbasePro) GetHistoricCandles(p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !c.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := c.ValidateKline(p, a, interval); err != nil { + return kline.Item{}, err } if kline.TotalCandlesPerInterval(start, end, interval) > c.Features.Enabled.Kline.ResultLimit { @@ -814,10 +812,8 @@ func (c *CoinbasePro) GetHistoricCandles(p currency.Pair, a asset.Item, start, e // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (c *CoinbasePro) GetHistoricCandlesExtended(p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !c.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := c.ValidateKline(p, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ diff --git a/exchanges/coinbene/coinbene_test.go b/exchanges/coinbene/coinbene_test.go index 01baac97..cdae5bae 100644 --- a/exchanges/coinbene/coinbene_test.go +++ b/exchanges/coinbene/coinbene_test.go @@ -708,7 +708,7 @@ func TestGetHistoricCandles(t *testing.T) { t.Fatal(err) } - currencyPairSwap, err := currency.NewPairFromString(swapTestPair) + currencyPairSwap, err := currency.NewPairFromString(spotTestPair) if err != nil { t.Fatal(err) } diff --git a/exchanges/coinbene/coinbene_wrapper.go b/exchanges/coinbene/coinbene_wrapper.go index d4a931bd..73e22c6b 100644 --- a/exchanges/coinbene/coinbene_wrapper.go +++ b/exchanges/coinbene/coinbene_wrapper.go @@ -776,10 +776,8 @@ func (c *Coinbene) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (c *Coinbene) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !c.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := c.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := c.FormatExchangeCurrency(pair, asset.PerpetualSwap) @@ -805,6 +803,7 @@ func (c *Coinbene) GetHistoricCandles(pair currency.Pair, a asset.Item, start, e Exchange: c.Name, Pair: pair, Interval: interval, + Asset: a, } for x := range candles.Data { diff --git a/exchanges/exchange.go b/exchanges/exchange.go index 454caf31..7fb9be1e 100644 --- a/exchanges/exchange.go +++ b/exchanges/exchange.go @@ -1063,7 +1063,7 @@ func (e *Base) AuthenticateWebsocket() error { } // KlineIntervalEnabled returns if requested interval is enabled on exchange -func (e *Base) KlineIntervalEnabled(in kline.Interval) bool { +func (e *Base) klineIntervalEnabled(in kline.Interval) bool { return e.Features.Enabled.Kline.Intervals[in.Word()] } @@ -1072,3 +1072,28 @@ func (e *Base) KlineIntervalEnabled(in kline.Interval) bool { func (e *Base) FormatExchangeKlineInterval(in kline.Interval) string { return strconv.FormatFloat(in.Duration().Seconds(), 'f', 0, 64) } + +// ValidateKline confirms that the requested pair, asset & interval are supported and/or enabled by the requested exchange +func (e *Base) ValidateKline(pair currency.Pair, a asset.Item, interval kline.Interval) error { + var errorList []string + var err kline.ErrorKline + if e.CurrencyPairs.IsAssetEnabled(a) != nil { + err.Asset = a + errorList = append(errorList, "asset not enabled") + } else if !e.CurrencyPairs.Pairs[a].Enabled.Contains(pair, true) { + err.Pair = pair + errorList = append(errorList, "pair not enabled") + } + + if !e.klineIntervalEnabled(interval) { + err.Interval = interval + errorList = append(errorList, "interval not supported") + } + + if len(errorList) > 0 { + err.Err = errors.New(strings.Join(errorList, ",")) + return &err + } + + return nil +} diff --git a/exchanges/exchange_test.go b/exchanges/exchange_test.go index ed9fdd40..48ac54b1 100644 --- a/exchanges/exchange_test.go +++ b/exchanges/exchange_test.go @@ -1872,6 +1872,54 @@ func Test_FormatExchangeKlineInterval(t *testing.T) { } } +func TestBase_ValidateKline(t *testing.T) { + pairs := currency.Pairs{ + currency.Pair{Base: currency.BTC, Quote: currency.USDT}, + } + + availablePairs := currency.Pairs{ + currency.Pair{Base: currency.BTC, Quote: currency.USDT}, + currency.Pair{Base: currency.BTC, Quote: currency.AUD}, + } + + b := Base{ + Name: "TESTNAME", + CurrencyPairs: currency.PairsManager{ + Pairs: map[asset.Item]*currency.PairStore{ + asset.Spot: { + AssetEnabled: convert.BoolPtr(true), + Enabled: pairs, + Available: availablePairs, + }, + }, + }, + Features: Features{ + Enabled: FeaturesEnabled{ + Kline: kline.ExchangeCapabilitiesEnabled{ + Intervals: map[string]bool{ + kline.OneMin.Word(): true, + }, + }, + }, + }, + } + + err := b.ValidateKline(availablePairs[0], asset.Spot, kline.OneMin) + if err != nil { + t.Fatalf("expected validation to pass received error: %v", err) + } + + err = b.ValidateKline(availablePairs[1], asset.Spot, kline.OneYear) + if err == nil { + t.Fatal("expected validation to fail") + } + + err = b.ValidateKline(availablePairs[1], asset.Index, kline.OneYear) + if err == nil { + t.Fatal("expected validation to fail") + } +} + func TestCheckTransientError(t *testing.T) { b := Base{} err := b.CheckTransientError(nil) @@ -1993,7 +2041,7 @@ func TestAuthenticateWebsocket(t *testing.T) { func TestKlineIntervalEnabled(t *testing.T) { b := Base{} - if b.KlineIntervalEnabled(kline.EightHour) { + if b.klineIntervalEnabled(kline.EightHour) { t.Fatal("unexpected value") } } diff --git a/exchanges/ftx/ftx_test.go b/exchanges/ftx/ftx_test.go index 22ae4db4..e2b67c0f 100644 --- a/exchanges/ftx/ftx_test.go +++ b/exchanges/ftx/ftx_test.go @@ -855,7 +855,7 @@ func TestGetFundingHistory(t *testing.T) { func TestGetHistoricCandles(t *testing.T) { t.Parallel() - currencyPair, err := currency.NewPairFromString(spotPair) + currencyPair, err := currency.NewPairFromString("BTC/USD") if err != nil { t.Fatal(err) } @@ -869,7 +869,7 @@ func TestGetHistoricCandles(t *testing.T) { func TestGetHistoricCandlesExtended(t *testing.T) { t.Parallel() - currencyPair, err := currency.NewPairFromString(spotPair) + currencyPair, err := currency.NewPairFromString("BTC/USD") if err != nil { t.Fatal(err) } diff --git a/exchanges/ftx/ftx_wrapper.go b/exchanges/ftx/ftx_wrapper.go index 89591206..8f9d3047 100644 --- a/exchanges/ftx/ftx_wrapper.go +++ b/exchanges/ftx/ftx_wrapper.go @@ -931,10 +931,8 @@ func (f *FTX) ValidateCredentials() error { // GetHistoricCandles returns candles between a time period for a set time interval func (f *FTX) GetHistoricCandles(p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !f.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := f.ValidateKline(p, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := f.FormatExchangeCurrency(p, a) @@ -972,10 +970,8 @@ func (f *FTX) GetHistoricCandles(p currency.Pair, a asset.Item, start, end time. // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (f *FTX) GetHistoricCandlesExtended(p currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !f.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := f.ValidateKline(p, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ diff --git a/exchanges/gateio/gateio_wrapper.go b/exchanges/gateio/gateio_wrapper.go index 60e59104..a3d59e45 100644 --- a/exchanges/gateio/gateio_wrapper.go +++ b/exchanges/gateio/gateio_wrapper.go @@ -733,10 +733,8 @@ func (g *Gateio) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (g *Gateio) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !g.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := g.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } hours := end.Sub(start).Hours() diff --git a/exchanges/hitbtc/hitbtc_test.go b/exchanges/hitbtc/hitbtc_test.go index f2835502..bec1428e 100644 --- a/exchanges/hitbtc/hitbtc_test.go +++ b/exchanges/hitbtc/hitbtc_test.go @@ -76,7 +76,7 @@ func TestGetChartCandles(t *testing.T) { } func TestGetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSD") + currencyPair, err := currency.NewPairFromString("BTC-USD") if err != nil { t.Fatal(err) } @@ -94,7 +94,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSD") + currencyPair, err := currency.NewPairFromString("BTC-USD") if err != nil { t.Fatal(err) } diff --git a/exchanges/hitbtc/hitbtc_wrapper.go b/exchanges/hitbtc/hitbtc_wrapper.go index f23872d2..7206fa32 100644 --- a/exchanges/hitbtc/hitbtc_wrapper.go +++ b/exchanges/hitbtc/hitbtc_wrapper.go @@ -700,10 +700,8 @@ func (h *HitBTC) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (h *HitBTC) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !h.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := h.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := h.FormatExchangeCurrency(pair, a) @@ -742,12 +740,9 @@ func (h *HitBTC) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (h *HitBTC) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !h.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := h.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } - ret := kline.Item{ Exchange: h.Name, Pair: pair, diff --git a/exchanges/huobi/huobi_test.go b/exchanges/huobi/huobi_test.go index 03d692c1..4c76a4e2 100644 --- a/exchanges/huobi/huobi_test.go +++ b/exchanges/huobi/huobi_test.go @@ -90,7 +90,7 @@ func TestGetSpotKline(t *testing.T) { } func TestGetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSDT") + currencyPair, err := currency.NewPairFromString("BTC-USDT") if err != nil { t.Fatal(err) } @@ -112,7 +112,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSDT") + currencyPair, err := currency.NewPairFromString("BTC-USDT") if err != nil { t.Fatal(err) } diff --git a/exchanges/huobi/huobi_wrapper.go b/exchanges/huobi/huobi_wrapper.go index 65a1a825..85181a70 100644 --- a/exchanges/huobi/huobi_wrapper.go +++ b/exchanges/huobi/huobi_wrapper.go @@ -988,10 +988,8 @@ func (h *HUOBI) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (h *HUOBI) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !h.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := h.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := h.FormatExchangeCurrency(pair, a) diff --git a/exchanges/kline/kline.go b/exchanges/kline/kline.go index f638b5ec..89711fc7 100644 --- a/exchanges/kline/kline.go +++ b/exchanges/kline/kline.go @@ -104,7 +104,7 @@ func CreateKline(trades []order.TradeHistory, interval Interval, p currency.Pair return candles, nil } -// validatData checks for zero values on data and sorts before turning +// validateData checks for zero values on data and sorts before turning // converting into OHLC func validateData(trades []order.TradeHistory) error { if len(trades) < 2 { @@ -281,7 +281,7 @@ func CalcDateRanges(start, end time.Time, interval Interval, limit uint32) (out } y++ } - if allDateIntervals != nil { + if allDateIntervals != nil && lastNum+1 < len(allDateIntervals) { out = append(out, DateRange{ Start: allDateIntervals[lastNum+1], End: allDateIntervals[len(allDateIntervals)-1], @@ -299,3 +299,10 @@ func (k *Item) SortCandlesByTimestamp(asc bool) { return k.Candles[i].Time.Before(k.Candles[j].Time) }) } + +// FormatDates converts all date to UTC time +func (k *Item) FormatDates() { + for x := range k.Candles { + k.Candles[x].Time = k.Candles[x].Time.UTC() + } +} diff --git a/exchanges/kline/kline_datastorage.go b/exchanges/kline/kline_datastorage.go new file mode 100644 index 00000000..95ae6491 --- /dev/null +++ b/exchanges/kline/kline_datastorage.go @@ -0,0 +1,155 @@ +package kline + +import ( + "encoding/csv" + "errors" + "fmt" + "io" + "os" + "strconv" + "time" + + "github.com/thrasher-corp/gocryptotrader/currency" + "github.com/thrasher-corp/gocryptotrader/database/repository/candle" + "github.com/thrasher-corp/gocryptotrader/database/repository/exchange" + "github.com/thrasher-corp/gocryptotrader/exchanges/asset" + "github.com/thrasher-corp/gocryptotrader/log" +) + +// LoadFromDatabase returns Item from database seeded data +func LoadFromDatabase(exchange string, pair currency.Pair, a asset.Item, interval Interval, start, end time.Time) (Item, error) { + retCandle, err := candle.Series(exchange, + pair.Base.String(), pair.Quote.String(), + int64(interval.Duration().Seconds()), a.String(), start, end) + if err != nil { + return Item{}, err + } + + ret := Item{ + Exchange: exchange, + Pair: pair, + Interval: interval, + } + + for x := range retCandle.Candles { + ret.Candles = append(ret.Candles, Candle{ + Time: retCandle.Candles[x].Timestamp, + Open: retCandle.Candles[x].Open, + High: retCandle.Candles[x].High, + Low: retCandle.Candles[x].Low, + Close: retCandle.Candles[x].Close, + Volume: retCandle.Candles[x].Volume, + }) + } + return ret, nil +} + +// StoreInDatabase returns Item from database seeded data +func StoreInDatabase(in *Item) (uint64, error) { + if in.Exchange == "" { + return 0, errors.New("name cannot be blank") + } + + if (in.Pair == currency.Pair{}) { + return 0, errors.New("currency pair cannot be empty") + } + + if in.Asset == "" { + return 0, errors.New("asset cannot be blank") + } + + if len(in.Candles) < 1 { + return 0, errors.New("candle data is empty") + } + + exchangeUUID, err := exchange.UUIDByName(in.Exchange) + if err != nil { + return 0, err + } + + databaseCandles := candle.Item{ + ExchangeID: exchangeUUID.String(), + Base: in.Pair.Base.Upper().String(), + Quote: in.Pair.Quote.Upper().String(), + Interval: int64(in.Interval.Duration().Seconds()), + Asset: in.Asset.String(), + } + + for x := range in.Candles { + databaseCandles.Candles = append(databaseCandles.Candles, candle.Candle{ + Timestamp: in.Candles[x].Time, + Open: in.Candles[x].Open, + High: in.Candles[x].High, + Low: in.Candles[x].Low, + Close: in.Candles[x].Close, + Volume: in.Candles[x].Volume, + }) + } + return candle.Insert(&databaseCandles) +} + +// LoadFromGCTScriptCSV loads kline data from a CSV file +func LoadFromGCTScriptCSV(file string) (out []Candle, errRet error) { + csvFile, err := os.Open(file) + if err != nil { + return out, err + } + + defer func() { + err = csvFile.Close() + if err != nil { + log.Errorln(log.Global, err) + } + }() + + csvData := csv.NewReader(csvFile) + + for { + row, errCSV := csvData.Read() + if errCSV != nil { + if errCSV == io.EOF { + break + } + return out, errCSV + } + + tempCandle := Candle{} + v, errParse := strconv.ParseInt(row[0], 10, 32) + if errParse != nil { + err = errParse + break + } + tempCandle.Time = time.Unix(v, 0).UTC() + if tempCandle.Time.IsZero() { + err = fmt.Errorf("invalid timestamp received on row %v", row) + break + } + + tempCandle.Volume, err = strconv.ParseFloat(row[1], 64) + if err != nil { + break + } + + tempCandle.Open, err = strconv.ParseFloat(row[2], 64) + if err != nil { + break + } + + tempCandle.High, err = strconv.ParseFloat(row[3], 64) + if err != nil { + break + } + + tempCandle.Low, err = strconv.ParseFloat(row[4], 64) + if err != nil { + break + } + + tempCandle.Close, err = strconv.ParseFloat(row[5], 64) + if err != nil { + break + } + out = append(out, tempCandle) + } + return out, err +} diff --git a/exchanges/kline/kline_test.go b/exchanges/kline/kline_test.go index ae401c35..e507f79c 100644 --- a/exchanges/kline/kline_test.go +++ b/exchanges/kline/kline_test.go @@ -1,17 +1,35 @@ package kline import ( + "errors" + "io/ioutil" "math/rand" + "os" + "path/filepath" "strings" "testing" "time" "github.com/thrasher-corp/gocryptotrader/common/crypto" "github.com/thrasher-corp/gocryptotrader/currency" + "github.com/thrasher-corp/gocryptotrader/database" + "github.com/thrasher-corp/gocryptotrader/database/drivers" + "github.com/thrasher-corp/gocryptotrader/database/repository/candle" + "github.com/thrasher-corp/gocryptotrader/database/repository/exchange" + "github.com/thrasher-corp/gocryptotrader/database/testhelpers" "github.com/thrasher-corp/gocryptotrader/exchanges/asset" "github.com/thrasher-corp/gocryptotrader/exchanges/order" ) +var ( + verbose = false + testExchanges = []exchange.Details{ + { + Name: "one", + }, + } +) + func TestValidateData(t *testing.T) { err := validateData(nil) if err == nil { @@ -86,7 +104,7 @@ func TestCreateKline(t *testing.T) { trades = append(trades, order.TradeHistory{ Timestamp: time.Now().Add((time.Duration(rand.Intn(10)) * time.Minute) + (time.Duration(rand.Intn(10)) * time.Second)), - TID: crypto.HexEncodeToString([]byte(string(i))), + TID: crypto.HexEncodeToString([]byte(string(rune(i)))), Amount: float64(rand.Intn(20)) + 1, Price: 1000 + float64(rand.Intn(1000)), }) @@ -237,14 +255,24 @@ func TestDurationToWord(t *testing.T) { func TestKlineErrors(t *testing.T) { v := ErrorKline{ Interval: OneYear, + Pair: currency.NewPair(currency.BTC, currency.AUD), + Err: errors.New("hello world"), } - if v.Error() != "oneyear interval unsupported by exchange" { - t.Fatal("unexpected error returned") + if v.Interval != OneYear { + t.Fatalf("expected OneYear received %v:", v.Interval) } - if v.Unwrap().Error() != "8760h0m0s interval unsupported by exchange" { - t.Fatal("unexpected error returned") + if v.Pair != currency.NewPair(currency.BTC, currency.AUD) { + t.Fatalf("expected OneYear received %v:", v.Pair) + } + + if v.Error() != "hello world" { + t.Fatal("expected error return received empty value") + } + + if v.Unwrap().Error() != "hello world" { + t.Fatal("expected error return received empty value") } } @@ -381,7 +409,7 @@ func TestCalcDateRanges(t *testing.T) { v = CalcDateRanges(time.Now(), time.Now().AddDate(0, 0, 1), OneDay, 100) if len(v) != 1 { - t.Fatal("expected CalcDateRanges() with a Candle count lower than limit to return 1 result") + t.Fatal("expected CalcDateRanges() with a Item count lower than limit to return 1 result") } } @@ -394,7 +422,7 @@ func TestItem_SortCandlesByTimestamp(t *testing.T) { } for x := 0; x < 100; x++ { - y := rand.Float64() + y := rand.Float64() // nolint gosec: used for generating test data no need to import crypo/rand tempKline.Candles = append(tempKline.Candles, Candle{ Time: time.Now().AddDate(0, 0, -x), @@ -416,3 +444,240 @@ func TestItem_SortCandlesByTimestamp(t *testing.T) { t.Fatal("expected kline.Candles to be in ascending order") } } + +func setupTest(t *testing.T) { + if verbose { + testhelpers.EnableVerboseTestOutput() + } + + var err error + testhelpers.MigrationDir = filepath.Join("..", "..", "database", "migrations") + testhelpers.PostgresTestDatabase = testhelpers.GetConnectionDetails() + testhelpers.TempDir, err = ioutil.TempDir("", "gct-temp") + if err != nil { + t.Fatalf("failed to create temp file: %v", err) + } +} + +func TestStoreInDatabase(t *testing.T) { + setupTest(t) + + testCases := []struct { + name string + config *database.Config + seedDB func(bool) error + runner func(t *testing.T) + closer func(dbConn *database.Instance) error + }{ + { + name: "postgresql", + config: testhelpers.PostgresTestDatabase, + seedDB: seedDB, + }, + { + name: "SQLite", + config: &database.Config{ + Driver: database.DBSQLite3, + ConnectionDetails: drivers.ConnectionDetails{Database: "./testdb"}, + }, + seedDB: seedDB, + }, + } + + for x := range testCases { + test := testCases[x] + + t.Run(test.name, func(t *testing.T) { + if !testhelpers.CheckValidConfig(&test.config.ConnectionDetails) { + t.Skip("database not configured skipping test") + } + + dbConn, err := testhelpers.ConnectToDatabase(test.config) + if err != nil { + t.Fatal(err) + } + + if test.seedDB != nil { + err = test.seedDB(false) + if err != nil { + t.Error(err) + } + } + + _, ohlcvData, err := genOHCLVData() + if err != nil { + t.Fatal(err) + } + r, err := StoreInDatabase(&ohlcvData) + if err != nil { + t.Fatal(err) + } + + if r != 365 { + t.Fatalf("unexpected number inserted: %v", r) + } + + err = testhelpers.CloseDatabase(dbConn) + if err != nil { + t.Error(err) + } + }) + } + + err := os.RemoveAll(testhelpers.TempDir) + if err != nil { + t.Fatalf("Failed to remove temp db file: %v", err) + } +} + +func TestLoadFromDatabase(t *testing.T) { + setupTest(t) + + testCases := []struct { + name string + config *database.Config + seedDB func(bool) error + runner func(t *testing.T) + closer func(dbConn *database.Instance) error + }{ + { + name: "postgresql", + config: testhelpers.PostgresTestDatabase, + seedDB: seedDB, + }, + { + name: "SQLite", + config: &database.Config{ + Driver: database.DBSQLite3, + ConnectionDetails: drivers.ConnectionDetails{Database: "./testdb"}, + }, + seedDB: seedDB, + }, + } + + for x := range testCases { + test := testCases[x] + + t.Run(test.name, func(t *testing.T) { + if !testhelpers.CheckValidConfig(&test.config.ConnectionDetails) { + t.Skip("database not configured skipping test") + } + + dbConn, err := testhelpers.ConnectToDatabase(test.config) + if err != nil { + t.Fatal(err) + } + + if test.seedDB != nil { + err = test.seedDB(true) + if err != nil { + t.Error(err) + } + } + + p, err := currency.NewPairFromString("BTCUSDT") + if err != nil { + t.Fatal(err) + } + start := time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC) + end := start.AddDate(1, 0, 0) + ret, err := LoadFromDatabase(testExchanges[0].Name, p, asset.Spot, OneDay, start, end) + if err != nil { + t.Fatal(err) + } + if ret.Exchange != testExchanges[0].Name { + t.Fatalf("uncorrect data returned: %v", ret.Exchange) + } + + err = testhelpers.CloseDatabase(dbConn) + if err != nil { + t.Error(err) + } + }) + } + + err := os.RemoveAll(testhelpers.TempDir) + if err != nil { + t.Fatalf("Failed to remove temp db file: %v", err) + } +} + +// TODO: find a better way to handle this to remove duplication between candle test +func seedDB(includeOHLCVData bool) error { + err := exchange.InsertMany(testExchanges) + if err != nil { + return err + } + + if includeOHLCVData { + data, _, err := genOHCLVData() + if err != nil { + return err + } + _, err = candle.Insert(&data) + return err + } + return nil +} + +func genOHCLVData() (out candle.Item, outItem Item, err error) { + exchangeUUID, err := exchange.UUIDByName(testExchanges[0].Name) + if err != nil { + return + } + + out.ExchangeID = exchangeUUID.String() + out.Base = currency.BTC.String() + out.Quote = currency.USDT.String() + out.Interval = 86400 + out.Asset = "spot" + + start := time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC) + for x := 0; x < 365; x++ { + out.Candles = append(out.Candles, candle.Candle{ + Timestamp: start.Add(time.Hour * 24 * time.Duration(x)), + Open: 1000, + High: 1000, + Low: 1000, + Close: 1000, + Volume: 1000, + }) + } + + outItem.Interval = OneDay + outItem.Asset = asset.Spot + outItem.Pair = currency.NewPair(currency.BTC, currency.USDT) + outItem.Exchange = testExchanges[0].Name + + for x := 0; x < 365; x++ { + outItem.Candles = append(outItem.Candles, Candle{ + Time: start.Add(time.Hour * 24 * time.Duration(x)), + Open: 1000, + High: 1000, + Low: 1000, + Close: 1000, + Volume: 1000, + }) + } + + return out, outItem, nil +} + +func TestLoadCSV(t *testing.T) { + v, err := LoadFromGCTScriptCSV(filepath.Join("..", "..", "testdata", "binance_BTCUSDT_24h_2019_01_01_2020_01_01.csv")) + if err != nil { + t.Fatal(err) + } + + if v[0].Time.UTC() != time.Unix(1546300800, 0).UTC() { + t.Fatalf("unexpected value received: %v", v[0].Time) + } + + if v[269].Close != 8177.91 { + t.Fatalf("unexpected value received: %v", v[269].Close) + } + + if v[364].Open != 7246 { + t.Fatalf("unexpected value received: %v", v[364].Open) + } +} diff --git a/exchanges/kline/kline_types.go b/exchanges/kline/kline_types.go index 56783c06..20a39a9b 100644 --- a/exchanges/kline/kline_types.go +++ b/exchanges/kline/kline_types.go @@ -1,7 +1,6 @@ package kline import ( - "fmt" "time" "github.com/thrasher-corp/gocryptotrader/currency" @@ -34,8 +33,6 @@ const ( ) const ( - // ErrUnsupportedInterval locale for an unsupported interval - ErrUnsupportedInterval = "%s interval unsupported by exchange" // ErrRequestExceedsExchangeLimits locale for exceeding rate limits message ErrRequestExceedsExchangeLimits = "requested data would exceed exchange limits please lower range or use GetHistoricCandlesEx" ) @@ -76,17 +73,20 @@ type Interval time.Duration // ErrorKline struct to hold kline interval errors type ErrorKline struct { + Asset asset.Item + Pair currency.Pair Interval Interval + Err error } // Error returns short interval unsupported message -func (k ErrorKline) Error() string { - return fmt.Sprintf(ErrUnsupportedInterval, k.Interval.Word()) +func (k *ErrorKline) Error() string { + return k.Err.Error() } // Unwrap returns interval unsupported message func (k *ErrorKline) Unwrap() error { - return fmt.Errorf(ErrUnsupportedInterval, k.Interval) + return k.Err } // DateRange holds a start and end date for kline usage diff --git a/exchanges/kraken/kraken_test.go b/exchanges/kraken/kraken_test.go index 9ae3ca07..f29eb285 100644 --- a/exchanges/kraken/kraken_test.go +++ b/exchanges/kraken/kraken_test.go @@ -1410,7 +1410,7 @@ func TestParseTime(t *testing.T) { } func TestGetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("XBTUSD") + currencyPair, err := currency.NewPairFromString("XBT-USD") if err != nil { t.Fatal(err) } @@ -1426,7 +1426,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("XBTUSD") + currencyPair, err := currency.NewPairFromString("XBT-USD") if err != nil { t.Fatal(err) } diff --git a/exchanges/kraken/kraken_wrapper.go b/exchanges/kraken/kraken_wrapper.go index c55af9fc..174fae05 100644 --- a/exchanges/kraken/kraken_wrapper.go +++ b/exchanges/kraken/kraken_wrapper.go @@ -863,10 +863,8 @@ func (k *Kraken) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (k *Kraken) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !k.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := k.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ @@ -909,12 +907,9 @@ func (k *Kraken) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (k *Kraken) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !k.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := k.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } - ret := kline.Item{ Exchange: k.Name, Pair: pair, diff --git a/exchanges/lbank/lbank_test.go b/exchanges/lbank/lbank_test.go index 47c6a4e2..13e2902a 100644 --- a/exchanges/lbank/lbank_test.go +++ b/exchanges/lbank/lbank_test.go @@ -410,7 +410,7 @@ func TestGetOrderHistory(t *testing.T) { func TestGetHistoricCandles(t *testing.T) { t.Parallel() - pair, err := currency.NewPairFromString(testCurrencyPair) + pair, err := currency.NewPairFromString("eth_btc") if err != nil { t.Fatal(err) } @@ -430,7 +430,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) { startTime := time.Now().Add(-time.Hour) end := time.Now() - pair, err := currency.NewPairFromString(testCurrencyPair) + pair, err := currency.NewPairFromString("eth_btc") if err != nil { t.Fatal(err) } diff --git a/exchanges/lbank/lbank_wrapper.go b/exchanges/lbank/lbank_wrapper.go index 53dea512..708a540c 100644 --- a/exchanges/lbank/lbank_wrapper.go +++ b/exchanges/lbank/lbank_wrapper.go @@ -772,10 +772,8 @@ func (l *Lbank) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (l *Lbank) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !l.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := l.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := l.FormatExchangeCurrency(pair, a) @@ -815,11 +813,10 @@ func (l *Lbank) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (l *Lbank) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !l.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := l.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } + ret := kline.Item{ Exchange: l.Name, Pair: pair, diff --git a/exchanges/okcoin/okcoin_test.go b/exchanges/okcoin/okcoin_test.go index 9669a609..9c9b831f 100644 --- a/exchanges/okcoin/okcoin_test.go +++ b/exchanges/okcoin/okcoin_test.go @@ -1090,7 +1090,7 @@ func TestGetOrderbook(t *testing.T) { } func TestGetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSDT") + currencyPair, err := currency.NewPairFromString("BTC-USD") if err != nil { t.Fatal(err) } @@ -1102,7 +1102,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSDT") + currencyPair, err := currency.NewPairFromString("BTC-USD") if err != nil { t.Fatal(err) } diff --git a/exchanges/okcoin/okcoin_wrapper.go b/exchanges/okcoin/okcoin_wrapper.go index a65fe8a9..f27d0922 100644 --- a/exchanges/okcoin/okcoin_wrapper.go +++ b/exchanges/okcoin/okcoin_wrapper.go @@ -316,10 +316,8 @@ func (o *OKCoin) FetchTicker(p currency.Pair, assetType asset.Item) (tickerData // GetHistoricCandles returns candles between a time period for a set time interval func (o *OKCoin) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !o.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := o.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := o.FormatExchangeCurrency(pair, a) @@ -389,10 +387,8 @@ func (o *OKCoin) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (o *OKCoin) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !o.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := o.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ diff --git a/exchanges/okex/okex_test.go b/exchanges/okex/okex_test.go index 9985f346..e31984c3 100644 --- a/exchanges/okex/okex_test.go +++ b/exchanges/okex/okex_test.go @@ -529,7 +529,7 @@ func TestGetSpotMarketData(t *testing.T) { } func TestGetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSDT") + currencyPair, err := currency.NewPairFromString("EOS-USDT") if err != nil { t.Fatal(err) } @@ -549,7 +549,7 @@ func TestGetHistoricCandles(t *testing.T) { t.Fatal("unexpected result") } - swapPair, err := currency.NewPairFromString("BTC-USD_SWAP") + swapPair, err := currency.NewPairFromString("EOS-USD_SWAP") if err != nil { t.Fatal(err) } @@ -560,7 +560,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCUSDT") + currencyPair, err := currency.NewPairFromString("EOS-USDT") if err != nil { t.Fatal(err) } diff --git a/exchanges/okex/okex_wrapper.go b/exchanges/okex/okex_wrapper.go index 989dee68..3d7c34a5 100644 --- a/exchanges/okex/okex_wrapper.go +++ b/exchanges/okex/okex_wrapper.go @@ -543,10 +543,8 @@ func (o *OKEX) FetchTicker(p currency.Pair, assetType asset.Item) (tickerData *t // GetHistoricCandles returns candles between a time period for a set time interval func (o *OKEX) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !o.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := o.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := o.FormatExchangeCurrency(pair, a) @@ -617,10 +615,8 @@ func (o *OKEX) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end t // GetHistoricCandlesExtended returns candles between a time period for a set time interval func (o *OKEX) GetHistoricCandlesExtended(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !o.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := o.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } ret := kline.Item{ diff --git a/exchanges/poloniex/poloniex_test.go b/exchanges/poloniex/poloniex_test.go index 25e74ee4..13bd1ef4 100644 --- a/exchanges/poloniex/poloniex_test.go +++ b/exchanges/poloniex/poloniex_test.go @@ -525,7 +525,7 @@ func TestWsHandleAccountData(t *testing.T) { } func TestGetHistoricCandles(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCLTC") + currencyPair, err := currency.NewPairFromString("BTC_LTC") if err != nil { t.Fatal(err) } @@ -546,7 +546,7 @@ func TestGetHistoricCandles(t *testing.T) { } func TestGetHistoricCandlesExtended(t *testing.T) { - currencyPair, err := currency.NewPairFromString("BTCLTC") + currencyPair, err := currency.NewPairFromString("BTC_LTC") if err != nil { t.Fatal(err) } diff --git a/exchanges/poloniex/poloniex_wrapper.go b/exchanges/poloniex/poloniex_wrapper.go index fa6a02c4..5e3f7875 100644 --- a/exchanges/poloniex/poloniex_wrapper.go +++ b/exchanges/poloniex/poloniex_wrapper.go @@ -663,10 +663,8 @@ func (p *Poloniex) ValidateCredentials() error { // GetHistoricCandles returns candles between a time period for a set time interval func (p *Poloniex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !p.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := p.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := p.FormatExchangeCurrency(pair, a) @@ -674,8 +672,11 @@ func (p *Poloniex) GetHistoricCandles(pair currency.Pair, a asset.Item, start, e return kline.Item{}, err } + // we use Truncate here to round star to the nearest even number that matches the requested interval + // example 10:17 with an interval of 15 minutes will go down 10:15 + // this is due to poloniex returning a non-complete candle if the time does not match candles, err := p.GetChartData(formattedPair.String(), - start, end, + start.Truncate(interval.Duration()), end, p.FormatExchangeKlineInterval(interval)) if err != nil { return kline.Item{}, err diff --git a/exchanges/zb/zb_test.go b/exchanges/zb/zb_test.go index e0667bc6..7c7098b4 100644 --- a/exchanges/zb/zb_test.go +++ b/exchanges/zb/zb_test.go @@ -840,7 +840,6 @@ func TestGetHistoricCandles(t *testing.T) { if err != nil { t.Fatal(err) } - _, err = z.GetHistoricCandles(currencyPair, asset.Spot, startTime, time.Now(), kline.Interval(time.Hour*7)) if err == nil { t.Fatal("unexpected result") diff --git a/exchanges/zb/zb_wrapper.go b/exchanges/zb/zb_wrapper.go index f4778160..42f71428 100644 --- a/exchanges/zb/zb_wrapper.go +++ b/exchanges/zb/zb_wrapper.go @@ -749,10 +749,8 @@ func (z *ZB) FormatExchangeKlineInterval(in kline.Interval) string { // GetHistoricCandles returns candles between a time period for a set time interval func (z *ZB) GetHistoricCandles(pair currency.Pair, a asset.Item, start, end time.Time, interval kline.Interval) (kline.Item, error) { - if !z.KlineIntervalEnabled(interval) { - return kline.Item{}, kline.ErrorKline{ - Interval: interval, - } + if err := z.ValidateKline(pair, a, interval); err != nil { + return kline.Item{}, err } formattedPair, err := z.FormatExchangeCurrency(pair, a) diff --git a/gctrpc/rpc.pb.go b/gctrpc/rpc.pb.go index d926f207..fc40b360 100644 --- a/gctrpc/rpc.pb.go +++ b/gctrpc/rpc.pb.go @@ -1,63 +1,79 @@ // Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.25.0 +// protoc v3.12.4 // source: rpc.proto package gctrpc import ( context "context" - fmt "fmt" proto "github.com/golang/protobuf/proto" timestamp "github.com/golang/protobuf/ptypes/timestamp" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" - math "math" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package +// This is a compile-time assertion that a sufficiently up-to-date version +// of the legacy proto package is being used. +const _ = proto.ProtoPackageIsVersion4 type GetInfoRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetInfoRequest) Reset() { *m = GetInfoRequest{} } -func (m *GetInfoRequest) String() string { return proto.CompactTextString(m) } -func (*GetInfoRequest) ProtoMessage() {} +func (x *GetInfoRequest) Reset() { + *x = GetInfoRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetInfoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetInfoRequest) ProtoMessage() {} + +func (x *GetInfoRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[0] + 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 GetInfoRequest.ProtoReflect.Descriptor instead. func (*GetInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{0} + return file_rpc_proto_rawDescGZIP(), []int{0} } -func (m *GetInfoRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetInfoRequest.Unmarshal(m, b) -} -func (m *GetInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetInfoRequest.Marshal(b, m, deterministic) -} -func (m *GetInfoRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetInfoRequest.Merge(m, src) -} -func (m *GetInfoRequest) XXX_Size() int { - return xxx_messageInfo_GetInfoRequest.Size(m) -} -func (m *GetInfoRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetInfoRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetInfoRequest proto.InternalMessageInfo - type GetInfoResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + Uptime string `protobuf:"bytes,1,opt,name=uptime,proto3" json:"uptime,omitempty"` AvailableExchanges int64 `protobuf:"varint,2,opt,name=available_exchanges,json=availableExchanges,proto3" json:"available_exchanges,omitempty"` EnabledExchanges int64 `protobuf:"varint,3,opt,name=enabled_exchanges,json=enabledExchanges,proto3" json:"enabled_exchanges,omitempty"` @@ -65,7559 +81,11627 @@ type GetInfoResponse struct { DefaultFiatCurrency string `protobuf:"bytes,5,opt,name=default_fiat_currency,json=defaultFiatCurrency,proto3" json:"default_fiat_currency,omitempty"` SubsystemStatus map[string]bool `protobuf:"bytes,6,rep,name=subsystem_status,json=subsystemStatus,proto3" json:"subsystem_status,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` RpcEndpoints map[string]*RPCEndpoint `protobuf:"bytes,7,rep,name=rpc_endpoints,json=rpcEndpoints,proto3" json:"rpc_endpoints,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` } -func (m *GetInfoResponse) Reset() { *m = GetInfoResponse{} } -func (m *GetInfoResponse) String() string { return proto.CompactTextString(m) } -func (*GetInfoResponse) ProtoMessage() {} +func (x *GetInfoResponse) Reset() { + *x = GetInfoResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetInfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetInfoResponse) ProtoMessage() {} + +func (x *GetInfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[1] + 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 GetInfoResponse.ProtoReflect.Descriptor instead. func (*GetInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{1} + return file_rpc_proto_rawDescGZIP(), []int{1} } -func (m *GetInfoResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetInfoResponse.Unmarshal(m, b) -} -func (m *GetInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetInfoResponse.Marshal(b, m, deterministic) -} -func (m *GetInfoResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetInfoResponse.Merge(m, src) -} -func (m *GetInfoResponse) XXX_Size() int { - return xxx_messageInfo_GetInfoResponse.Size(m) -} -func (m *GetInfoResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetInfoResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetInfoResponse proto.InternalMessageInfo - -func (m *GetInfoResponse) GetUptime() string { - if m != nil { - return m.Uptime +func (x *GetInfoResponse) GetUptime() string { + if x != nil { + return x.Uptime } return "" } -func (m *GetInfoResponse) GetAvailableExchanges() int64 { - if m != nil { - return m.AvailableExchanges +func (x *GetInfoResponse) GetAvailableExchanges() int64 { + if x != nil { + return x.AvailableExchanges } return 0 } -func (m *GetInfoResponse) GetEnabledExchanges() int64 { - if m != nil { - return m.EnabledExchanges +func (x *GetInfoResponse) GetEnabledExchanges() int64 { + if x != nil { + return x.EnabledExchanges } return 0 } -func (m *GetInfoResponse) GetDefaultForexProvider() string { - if m != nil { - return m.DefaultForexProvider +func (x *GetInfoResponse) GetDefaultForexProvider() string { + if x != nil { + return x.DefaultForexProvider } return "" } -func (m *GetInfoResponse) GetDefaultFiatCurrency() string { - if m != nil { - return m.DefaultFiatCurrency +func (x *GetInfoResponse) GetDefaultFiatCurrency() string { + if x != nil { + return x.DefaultFiatCurrency } return "" } -func (m *GetInfoResponse) GetSubsystemStatus() map[string]bool { - if m != nil { - return m.SubsystemStatus +func (x *GetInfoResponse) GetSubsystemStatus() map[string]bool { + if x != nil { + return x.SubsystemStatus } return nil } -func (m *GetInfoResponse) GetRpcEndpoints() map[string]*RPCEndpoint { - if m != nil { - return m.RpcEndpoints +func (x *GetInfoResponse) GetRpcEndpoints() map[string]*RPCEndpoint { + if x != nil { + return x.RpcEndpoints } return nil } type GetCommunicationRelayersRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetCommunicationRelayersRequest) Reset() { *m = GetCommunicationRelayersRequest{} } -func (m *GetCommunicationRelayersRequest) String() string { return proto.CompactTextString(m) } -func (*GetCommunicationRelayersRequest) ProtoMessage() {} +func (x *GetCommunicationRelayersRequest) Reset() { + *x = GetCommunicationRelayersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetCommunicationRelayersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCommunicationRelayersRequest) ProtoMessage() {} + +func (x *GetCommunicationRelayersRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[2] + 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 GetCommunicationRelayersRequest.ProtoReflect.Descriptor instead. func (*GetCommunicationRelayersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{2} + return file_rpc_proto_rawDescGZIP(), []int{2} } -func (m *GetCommunicationRelayersRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetCommunicationRelayersRequest.Unmarshal(m, b) -} -func (m *GetCommunicationRelayersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetCommunicationRelayersRequest.Marshal(b, m, deterministic) -} -func (m *GetCommunicationRelayersRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetCommunicationRelayersRequest.Merge(m, src) -} -func (m *GetCommunicationRelayersRequest) XXX_Size() int { - return xxx_messageInfo_GetCommunicationRelayersRequest.Size(m) -} -func (m *GetCommunicationRelayersRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetCommunicationRelayersRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetCommunicationRelayersRequest proto.InternalMessageInfo - type CommunicationRelayer struct { - Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"` - Connected bool `protobuf:"varint,2,opt,name=connected,proto3" json:"connected,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"` + Connected bool `protobuf:"varint,2,opt,name=connected,proto3" json:"connected,omitempty"` } -func (m *CommunicationRelayer) Reset() { *m = CommunicationRelayer{} } -func (m *CommunicationRelayer) String() string { return proto.CompactTextString(m) } -func (*CommunicationRelayer) ProtoMessage() {} +func (x *CommunicationRelayer) Reset() { + *x = CommunicationRelayer{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CommunicationRelayer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommunicationRelayer) ProtoMessage() {} + +func (x *CommunicationRelayer) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[3] + 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 CommunicationRelayer.ProtoReflect.Descriptor instead. func (*CommunicationRelayer) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{3} + return file_rpc_proto_rawDescGZIP(), []int{3} } -func (m *CommunicationRelayer) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_CommunicationRelayer.Unmarshal(m, b) -} -func (m *CommunicationRelayer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_CommunicationRelayer.Marshal(b, m, deterministic) -} -func (m *CommunicationRelayer) XXX_Merge(src proto.Message) { - xxx_messageInfo_CommunicationRelayer.Merge(m, src) -} -func (m *CommunicationRelayer) XXX_Size() int { - return xxx_messageInfo_CommunicationRelayer.Size(m) -} -func (m *CommunicationRelayer) XXX_DiscardUnknown() { - xxx_messageInfo_CommunicationRelayer.DiscardUnknown(m) -} - -var xxx_messageInfo_CommunicationRelayer proto.InternalMessageInfo - -func (m *CommunicationRelayer) GetEnabled() bool { - if m != nil { - return m.Enabled +func (x *CommunicationRelayer) GetEnabled() bool { + if x != nil { + return x.Enabled } return false } -func (m *CommunicationRelayer) GetConnected() bool { - if m != nil { - return m.Connected +func (x *CommunicationRelayer) GetConnected() bool { + if x != nil { + return x.Connected } return false } type GetCommunicationRelayersResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + CommunicationRelayers map[string]*CommunicationRelayer `protobuf:"bytes,1,rep,name=communication_relayers,json=communicationRelayers,proto3" json:"communication_relayers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` } -func (m *GetCommunicationRelayersResponse) Reset() { *m = GetCommunicationRelayersResponse{} } -func (m *GetCommunicationRelayersResponse) String() string { return proto.CompactTextString(m) } -func (*GetCommunicationRelayersResponse) ProtoMessage() {} +func (x *GetCommunicationRelayersResponse) Reset() { + *x = GetCommunicationRelayersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetCommunicationRelayersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCommunicationRelayersResponse) ProtoMessage() {} + +func (x *GetCommunicationRelayersResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[4] + 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 GetCommunicationRelayersResponse.ProtoReflect.Descriptor instead. func (*GetCommunicationRelayersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{4} + return file_rpc_proto_rawDescGZIP(), []int{4} } -func (m *GetCommunicationRelayersResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetCommunicationRelayersResponse.Unmarshal(m, b) -} -func (m *GetCommunicationRelayersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetCommunicationRelayersResponse.Marshal(b, m, deterministic) -} -func (m *GetCommunicationRelayersResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetCommunicationRelayersResponse.Merge(m, src) -} -func (m *GetCommunicationRelayersResponse) XXX_Size() int { - return xxx_messageInfo_GetCommunicationRelayersResponse.Size(m) -} -func (m *GetCommunicationRelayersResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetCommunicationRelayersResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetCommunicationRelayersResponse proto.InternalMessageInfo - -func (m *GetCommunicationRelayersResponse) GetCommunicationRelayers() map[string]*CommunicationRelayer { - if m != nil { - return m.CommunicationRelayers +func (x *GetCommunicationRelayersResponse) GetCommunicationRelayers() map[string]*CommunicationRelayer { + if x != nil { + return x.CommunicationRelayers } return nil } type GenericSubsystemRequest struct { - Subsystem string `protobuf:"bytes,1,opt,name=subsystem,proto3" json:"subsystem,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Subsystem string `protobuf:"bytes,1,opt,name=subsystem,proto3" json:"subsystem,omitempty"` } -func (m *GenericSubsystemRequest) Reset() { *m = GenericSubsystemRequest{} } -func (m *GenericSubsystemRequest) String() string { return proto.CompactTextString(m) } -func (*GenericSubsystemRequest) ProtoMessage() {} +func (x *GenericSubsystemRequest) Reset() { + *x = GenericSubsystemRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenericSubsystemRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenericSubsystemRequest) ProtoMessage() {} + +func (x *GenericSubsystemRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[5] + 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 GenericSubsystemRequest.ProtoReflect.Descriptor instead. func (*GenericSubsystemRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{5} + return file_rpc_proto_rawDescGZIP(), []int{5} } -func (m *GenericSubsystemRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GenericSubsystemRequest.Unmarshal(m, b) -} -func (m *GenericSubsystemRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GenericSubsystemRequest.Marshal(b, m, deterministic) -} -func (m *GenericSubsystemRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenericSubsystemRequest.Merge(m, src) -} -func (m *GenericSubsystemRequest) XXX_Size() int { - return xxx_messageInfo_GenericSubsystemRequest.Size(m) -} -func (m *GenericSubsystemRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GenericSubsystemRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GenericSubsystemRequest proto.InternalMessageInfo - -func (m *GenericSubsystemRequest) GetSubsystem() string { - if m != nil { - return m.Subsystem +func (x *GenericSubsystemRequest) GetSubsystem() string { + if x != nil { + return x.Subsystem } return "" } type GetSubsystemsRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetSubsystemsRequest) Reset() { *m = GetSubsystemsRequest{} } -func (m *GetSubsystemsRequest) String() string { return proto.CompactTextString(m) } -func (*GetSubsystemsRequest) ProtoMessage() {} +func (x *GetSubsystemsRequest) Reset() { + *x = GetSubsystemsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSubsystemsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSubsystemsRequest) ProtoMessage() {} + +func (x *GetSubsystemsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[6] + 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 GetSubsystemsRequest.ProtoReflect.Descriptor instead. func (*GetSubsystemsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{6} + return file_rpc_proto_rawDescGZIP(), []int{6} } -func (m *GetSubsystemsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetSubsystemsRequest.Unmarshal(m, b) -} -func (m *GetSubsystemsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetSubsystemsRequest.Marshal(b, m, deterministic) -} -func (m *GetSubsystemsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetSubsystemsRequest.Merge(m, src) -} -func (m *GetSubsystemsRequest) XXX_Size() int { - return xxx_messageInfo_GetSubsystemsRequest.Size(m) -} -func (m *GetSubsystemsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetSubsystemsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetSubsystemsRequest proto.InternalMessageInfo - type GetSusbsytemsResponse struct { - SubsystemsStatus map[string]bool `protobuf:"bytes,1,rep,name=subsystems_status,json=subsystemsStatus,proto3" json:"subsystems_status,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SubsystemsStatus map[string]bool `protobuf:"bytes,1,rep,name=subsystems_status,json=subsystemsStatus,proto3" json:"subsystems_status,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` } -func (m *GetSusbsytemsResponse) Reset() { *m = GetSusbsytemsResponse{} } -func (m *GetSusbsytemsResponse) String() string { return proto.CompactTextString(m) } -func (*GetSusbsytemsResponse) ProtoMessage() {} +func (x *GetSusbsytemsResponse) Reset() { + *x = GetSusbsytemsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetSusbsytemsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSusbsytemsResponse) ProtoMessage() {} + +func (x *GetSusbsytemsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[7] + 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 GetSusbsytemsResponse.ProtoReflect.Descriptor instead. func (*GetSusbsytemsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{7} + return file_rpc_proto_rawDescGZIP(), []int{7} } -func (m *GetSusbsytemsResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetSusbsytemsResponse.Unmarshal(m, b) -} -func (m *GetSusbsytemsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetSusbsytemsResponse.Marshal(b, m, deterministic) -} -func (m *GetSusbsytemsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetSusbsytemsResponse.Merge(m, src) -} -func (m *GetSusbsytemsResponse) XXX_Size() int { - return xxx_messageInfo_GetSusbsytemsResponse.Size(m) -} -func (m *GetSusbsytemsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetSusbsytemsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetSusbsytemsResponse proto.InternalMessageInfo - -func (m *GetSusbsytemsResponse) GetSubsystemsStatus() map[string]bool { - if m != nil { - return m.SubsystemsStatus +func (x *GetSusbsytemsResponse) GetSubsystemsStatus() map[string]bool { + if x != nil { + return x.SubsystemsStatus } return nil } type GetRPCEndpointsRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetRPCEndpointsRequest) Reset() { *m = GetRPCEndpointsRequest{} } -func (m *GetRPCEndpointsRequest) String() string { return proto.CompactTextString(m) } -func (*GetRPCEndpointsRequest) ProtoMessage() {} +func (x *GetRPCEndpointsRequest) Reset() { + *x = GetRPCEndpointsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRPCEndpointsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRPCEndpointsRequest) ProtoMessage() {} + +func (x *GetRPCEndpointsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[8] + 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 GetRPCEndpointsRequest.ProtoReflect.Descriptor instead. func (*GetRPCEndpointsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{8} + return file_rpc_proto_rawDescGZIP(), []int{8} } -func (m *GetRPCEndpointsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetRPCEndpointsRequest.Unmarshal(m, b) -} -func (m *GetRPCEndpointsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetRPCEndpointsRequest.Marshal(b, m, deterministic) -} -func (m *GetRPCEndpointsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetRPCEndpointsRequest.Merge(m, src) -} -func (m *GetRPCEndpointsRequest) XXX_Size() int { - return xxx_messageInfo_GetRPCEndpointsRequest.Size(m) -} -func (m *GetRPCEndpointsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetRPCEndpointsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetRPCEndpointsRequest proto.InternalMessageInfo - type RPCEndpoint struct { - Started bool `protobuf:"varint,1,opt,name=started,proto3" json:"started,omitempty"` - ListenAddress string `protobuf:"bytes,2,opt,name=listen_address,json=listenAddress,proto3" json:"listen_address,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Started bool `protobuf:"varint,1,opt,name=started,proto3" json:"started,omitempty"` + ListenAddress string `protobuf:"bytes,2,opt,name=listen_address,json=listenAddress,proto3" json:"listen_address,omitempty"` } -func (m *RPCEndpoint) Reset() { *m = RPCEndpoint{} } -func (m *RPCEndpoint) String() string { return proto.CompactTextString(m) } -func (*RPCEndpoint) ProtoMessage() {} +func (x *RPCEndpoint) Reset() { + *x = RPCEndpoint{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RPCEndpoint) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RPCEndpoint) ProtoMessage() {} + +func (x *RPCEndpoint) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[9] + 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 RPCEndpoint.ProtoReflect.Descriptor instead. func (*RPCEndpoint) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{9} + return file_rpc_proto_rawDescGZIP(), []int{9} } -func (m *RPCEndpoint) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_RPCEndpoint.Unmarshal(m, b) -} -func (m *RPCEndpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_RPCEndpoint.Marshal(b, m, deterministic) -} -func (m *RPCEndpoint) XXX_Merge(src proto.Message) { - xxx_messageInfo_RPCEndpoint.Merge(m, src) -} -func (m *RPCEndpoint) XXX_Size() int { - return xxx_messageInfo_RPCEndpoint.Size(m) -} -func (m *RPCEndpoint) XXX_DiscardUnknown() { - xxx_messageInfo_RPCEndpoint.DiscardUnknown(m) -} - -var xxx_messageInfo_RPCEndpoint proto.InternalMessageInfo - -func (m *RPCEndpoint) GetStarted() bool { - if m != nil { - return m.Started +func (x *RPCEndpoint) GetStarted() bool { + if x != nil { + return x.Started } return false } -func (m *RPCEndpoint) GetListenAddress() string { - if m != nil { - return m.ListenAddress +func (x *RPCEndpoint) GetListenAddress() string { + if x != nil { + return x.ListenAddress } return "" } type GetRPCEndpointsResponse struct { - Endpoints map[string]*RPCEndpoint `protobuf:"bytes,1,rep,name=endpoints,proto3" json:"endpoints,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Endpoints map[string]*RPCEndpoint `protobuf:"bytes,1,rep,name=endpoints,proto3" json:"endpoints,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } -func (m *GetRPCEndpointsResponse) Reset() { *m = GetRPCEndpointsResponse{} } -func (m *GetRPCEndpointsResponse) String() string { return proto.CompactTextString(m) } -func (*GetRPCEndpointsResponse) ProtoMessage() {} +func (x *GetRPCEndpointsResponse) Reset() { + *x = GetRPCEndpointsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRPCEndpointsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRPCEndpointsResponse) ProtoMessage() {} + +func (x *GetRPCEndpointsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[10] + 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 GetRPCEndpointsResponse.ProtoReflect.Descriptor instead. func (*GetRPCEndpointsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{10} + return file_rpc_proto_rawDescGZIP(), []int{10} } -func (m *GetRPCEndpointsResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetRPCEndpointsResponse.Unmarshal(m, b) -} -func (m *GetRPCEndpointsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetRPCEndpointsResponse.Marshal(b, m, deterministic) -} -func (m *GetRPCEndpointsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetRPCEndpointsResponse.Merge(m, src) -} -func (m *GetRPCEndpointsResponse) XXX_Size() int { - return xxx_messageInfo_GetRPCEndpointsResponse.Size(m) -} -func (m *GetRPCEndpointsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetRPCEndpointsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetRPCEndpointsResponse proto.InternalMessageInfo - -func (m *GetRPCEndpointsResponse) GetEndpoints() map[string]*RPCEndpoint { - if m != nil { - return m.Endpoints +func (x *GetRPCEndpointsResponse) GetEndpoints() map[string]*RPCEndpoint { + if x != nil { + return x.Endpoints } return nil } type GenericExchangeNameRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *GenericExchangeNameRequest) Reset() { *m = GenericExchangeNameRequest{} } -func (m *GenericExchangeNameRequest) String() string { return proto.CompactTextString(m) } -func (*GenericExchangeNameRequest) ProtoMessage() {} +func (x *GenericExchangeNameRequest) Reset() { + *x = GenericExchangeNameRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenericExchangeNameRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenericExchangeNameRequest) ProtoMessage() {} + +func (x *GenericExchangeNameRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[11] + 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 GenericExchangeNameRequest.ProtoReflect.Descriptor instead. func (*GenericExchangeNameRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{11} + return file_rpc_proto_rawDescGZIP(), []int{11} } -func (m *GenericExchangeNameRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GenericExchangeNameRequest.Unmarshal(m, b) -} -func (m *GenericExchangeNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GenericExchangeNameRequest.Marshal(b, m, deterministic) -} -func (m *GenericExchangeNameRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenericExchangeNameRequest.Merge(m, src) -} -func (m *GenericExchangeNameRequest) XXX_Size() int { - return xxx_messageInfo_GenericExchangeNameRequest.Size(m) -} -func (m *GenericExchangeNameRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GenericExchangeNameRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GenericExchangeNameRequest proto.InternalMessageInfo - -func (m *GenericExchangeNameRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GenericExchangeNameRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type GetExchangesRequest struct { - Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"` } -func (m *GetExchangesRequest) Reset() { *m = GetExchangesRequest{} } -func (m *GetExchangesRequest) String() string { return proto.CompactTextString(m) } -func (*GetExchangesRequest) ProtoMessage() {} +func (x *GetExchangesRequest) Reset() { + *x = GetExchangesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangesRequest) ProtoMessage() {} + +func (x *GetExchangesRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[12] + 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 GetExchangesRequest.ProtoReflect.Descriptor instead. func (*GetExchangesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{12} + return file_rpc_proto_rawDescGZIP(), []int{12} } -func (m *GetExchangesRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangesRequest.Unmarshal(m, b) -} -func (m *GetExchangesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangesRequest.Marshal(b, m, deterministic) -} -func (m *GetExchangesRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangesRequest.Merge(m, src) -} -func (m *GetExchangesRequest) XXX_Size() int { - return xxx_messageInfo_GetExchangesRequest.Size(m) -} -func (m *GetExchangesRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangesRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangesRequest proto.InternalMessageInfo - -func (m *GetExchangesRequest) GetEnabled() bool { - if m != nil { - return m.Enabled +func (x *GetExchangesRequest) GetEnabled() bool { + if x != nil { + return x.Enabled } return false } type GetExchangesResponse struct { - Exchanges string `protobuf:"bytes,1,opt,name=exchanges,proto3" json:"exchanges,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchanges string `protobuf:"bytes,1,opt,name=exchanges,proto3" json:"exchanges,omitempty"` } -func (m *GetExchangesResponse) Reset() { *m = GetExchangesResponse{} } -func (m *GetExchangesResponse) String() string { return proto.CompactTextString(m) } -func (*GetExchangesResponse) ProtoMessage() {} +func (x *GetExchangesResponse) Reset() { + *x = GetExchangesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangesResponse) ProtoMessage() {} + +func (x *GetExchangesResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[13] + 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 GetExchangesResponse.ProtoReflect.Descriptor instead. func (*GetExchangesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{13} + return file_rpc_proto_rawDescGZIP(), []int{13} } -func (m *GetExchangesResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangesResponse.Unmarshal(m, b) -} -func (m *GetExchangesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangesResponse.Marshal(b, m, deterministic) -} -func (m *GetExchangesResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangesResponse.Merge(m, src) -} -func (m *GetExchangesResponse) XXX_Size() int { - return xxx_messageInfo_GetExchangesResponse.Size(m) -} -func (m *GetExchangesResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangesResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangesResponse proto.InternalMessageInfo - -func (m *GetExchangesResponse) GetExchanges() string { - if m != nil { - return m.Exchanges +func (x *GetExchangesResponse) GetExchanges() string { + if x != nil { + return x.Exchanges } return "" } type GetExchangeOTPReponse struct { - OtpCode string `protobuf:"bytes,1,opt,name=otp_code,json=otpCode,proto3" json:"otp_code,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OtpCode string `protobuf:"bytes,1,opt,name=otp_code,json=otpCode,proto3" json:"otp_code,omitempty"` } -func (m *GetExchangeOTPReponse) Reset() { *m = GetExchangeOTPReponse{} } -func (m *GetExchangeOTPReponse) String() string { return proto.CompactTextString(m) } -func (*GetExchangeOTPReponse) ProtoMessage() {} +func (x *GetExchangeOTPReponse) Reset() { + *x = GetExchangeOTPReponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangeOTPReponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangeOTPReponse) ProtoMessage() {} + +func (x *GetExchangeOTPReponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[14] + 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 GetExchangeOTPReponse.ProtoReflect.Descriptor instead. func (*GetExchangeOTPReponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{14} + return file_rpc_proto_rawDescGZIP(), []int{14} } -func (m *GetExchangeOTPReponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangeOTPReponse.Unmarshal(m, b) -} -func (m *GetExchangeOTPReponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangeOTPReponse.Marshal(b, m, deterministic) -} -func (m *GetExchangeOTPReponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangeOTPReponse.Merge(m, src) -} -func (m *GetExchangeOTPReponse) XXX_Size() int { - return xxx_messageInfo_GetExchangeOTPReponse.Size(m) -} -func (m *GetExchangeOTPReponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangeOTPReponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangeOTPReponse proto.InternalMessageInfo - -func (m *GetExchangeOTPReponse) GetOtpCode() string { - if m != nil { - return m.OtpCode +func (x *GetExchangeOTPReponse) GetOtpCode() string { + if x != nil { + return x.OtpCode } return "" } type GetExchangeOTPsRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetExchangeOTPsRequest) Reset() { *m = GetExchangeOTPsRequest{} } -func (m *GetExchangeOTPsRequest) String() string { return proto.CompactTextString(m) } -func (*GetExchangeOTPsRequest) ProtoMessage() {} +func (x *GetExchangeOTPsRequest) Reset() { + *x = GetExchangeOTPsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangeOTPsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangeOTPsRequest) ProtoMessage() {} + +func (x *GetExchangeOTPsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[15] + 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 GetExchangeOTPsRequest.ProtoReflect.Descriptor instead. func (*GetExchangeOTPsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{15} + return file_rpc_proto_rawDescGZIP(), []int{15} } -func (m *GetExchangeOTPsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangeOTPsRequest.Unmarshal(m, b) -} -func (m *GetExchangeOTPsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangeOTPsRequest.Marshal(b, m, deterministic) -} -func (m *GetExchangeOTPsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangeOTPsRequest.Merge(m, src) -} -func (m *GetExchangeOTPsRequest) XXX_Size() int { - return xxx_messageInfo_GetExchangeOTPsRequest.Size(m) -} -func (m *GetExchangeOTPsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangeOTPsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangeOTPsRequest proto.InternalMessageInfo - type GetExchangeOTPsResponse struct { - OtpCodes map[string]string `protobuf:"bytes,1,rep,name=otp_codes,json=otpCodes,proto3" json:"otp_codes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OtpCodes map[string]string `protobuf:"bytes,1,rep,name=otp_codes,json=otpCodes,proto3" json:"otp_codes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } -func (m *GetExchangeOTPsResponse) Reset() { *m = GetExchangeOTPsResponse{} } -func (m *GetExchangeOTPsResponse) String() string { return proto.CompactTextString(m) } -func (*GetExchangeOTPsResponse) ProtoMessage() {} +func (x *GetExchangeOTPsResponse) Reset() { + *x = GetExchangeOTPsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangeOTPsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangeOTPsResponse) ProtoMessage() {} + +func (x *GetExchangeOTPsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[16] + 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 GetExchangeOTPsResponse.ProtoReflect.Descriptor instead. func (*GetExchangeOTPsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{16} + return file_rpc_proto_rawDescGZIP(), []int{16} } -func (m *GetExchangeOTPsResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangeOTPsResponse.Unmarshal(m, b) -} -func (m *GetExchangeOTPsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangeOTPsResponse.Marshal(b, m, deterministic) -} -func (m *GetExchangeOTPsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangeOTPsResponse.Merge(m, src) -} -func (m *GetExchangeOTPsResponse) XXX_Size() int { - return xxx_messageInfo_GetExchangeOTPsResponse.Size(m) -} -func (m *GetExchangeOTPsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangeOTPsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangeOTPsResponse proto.InternalMessageInfo - -func (m *GetExchangeOTPsResponse) GetOtpCodes() map[string]string { - if m != nil { - return m.OtpCodes +func (x *GetExchangeOTPsResponse) GetOtpCodes() map[string]string { + if x != nil { + return x.OtpCodes } return nil } type DisableExchangeRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *DisableExchangeRequest) Reset() { *m = DisableExchangeRequest{} } -func (m *DisableExchangeRequest) String() string { return proto.CompactTextString(m) } -func (*DisableExchangeRequest) ProtoMessage() {} +func (x *DisableExchangeRequest) Reset() { + *x = DisableExchangeRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DisableExchangeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DisableExchangeRequest) ProtoMessage() {} + +func (x *DisableExchangeRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[17] + 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 DisableExchangeRequest.ProtoReflect.Descriptor instead. func (*DisableExchangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{17} + return file_rpc_proto_rawDescGZIP(), []int{17} } -func (m *DisableExchangeRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DisableExchangeRequest.Unmarshal(m, b) -} -func (m *DisableExchangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DisableExchangeRequest.Marshal(b, m, deterministic) -} -func (m *DisableExchangeRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DisableExchangeRequest.Merge(m, src) -} -func (m *DisableExchangeRequest) XXX_Size() int { - return xxx_messageInfo_DisableExchangeRequest.Size(m) -} -func (m *DisableExchangeRequest) XXX_DiscardUnknown() { - xxx_messageInfo_DisableExchangeRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_DisableExchangeRequest proto.InternalMessageInfo - -func (m *DisableExchangeRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *DisableExchangeRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type PairsSupported struct { - AvailablePairs string `protobuf:"bytes,1,opt,name=available_pairs,json=availablePairs,proto3" json:"available_pairs,omitempty"` - EnabledPairs string `protobuf:"bytes,2,opt,name=enabled_pairs,json=enabledPairs,proto3" json:"enabled_pairs,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AvailablePairs string `protobuf:"bytes,1,opt,name=available_pairs,json=availablePairs,proto3" json:"available_pairs,omitempty"` + EnabledPairs string `protobuf:"bytes,2,opt,name=enabled_pairs,json=enabledPairs,proto3" json:"enabled_pairs,omitempty"` } -func (m *PairsSupported) Reset() { *m = PairsSupported{} } -func (m *PairsSupported) String() string { return proto.CompactTextString(m) } -func (*PairsSupported) ProtoMessage() {} +func (x *PairsSupported) Reset() { + *x = PairsSupported{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PairsSupported) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PairsSupported) ProtoMessage() {} + +func (x *PairsSupported) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[18] + 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 PairsSupported.ProtoReflect.Descriptor instead. func (*PairsSupported) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{18} + return file_rpc_proto_rawDescGZIP(), []int{18} } -func (m *PairsSupported) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PairsSupported.Unmarshal(m, b) -} -func (m *PairsSupported) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PairsSupported.Marshal(b, m, deterministic) -} -func (m *PairsSupported) XXX_Merge(src proto.Message) { - xxx_messageInfo_PairsSupported.Merge(m, src) -} -func (m *PairsSupported) XXX_Size() int { - return xxx_messageInfo_PairsSupported.Size(m) -} -func (m *PairsSupported) XXX_DiscardUnknown() { - xxx_messageInfo_PairsSupported.DiscardUnknown(m) -} - -var xxx_messageInfo_PairsSupported proto.InternalMessageInfo - -func (m *PairsSupported) GetAvailablePairs() string { - if m != nil { - return m.AvailablePairs +func (x *PairsSupported) GetAvailablePairs() string { + if x != nil { + return x.AvailablePairs } return "" } -func (m *PairsSupported) GetEnabledPairs() string { - if m != nil { - return m.EnabledPairs +func (x *PairsSupported) GetEnabledPairs() string { + if x != nil { + return x.EnabledPairs } return "" } type GetExchangeInfoResponse struct { - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Enabled bool `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"` - Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"` - UsingSandbox bool `protobuf:"varint,4,opt,name=using_sandbox,json=usingSandbox,proto3" json:"using_sandbox,omitempty"` - HttpTimeout string `protobuf:"bytes,5,opt,name=http_timeout,json=httpTimeout,proto3" json:"http_timeout,omitempty"` - HttpUseragent string `protobuf:"bytes,6,opt,name=http_useragent,json=httpUseragent,proto3" json:"http_useragent,omitempty"` - HttpProxy string `protobuf:"bytes,7,opt,name=http_proxy,json=httpProxy,proto3" json:"http_proxy,omitempty"` - BaseCurrencies string `protobuf:"bytes,8,opt,name=base_currencies,json=baseCurrencies,proto3" json:"base_currencies,omitempty"` - SupportedAssets map[string]*PairsSupported `protobuf:"bytes,9,rep,name=supported_assets,json=supportedAssets,proto3" json:"supported_assets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - AuthenticatedApi bool `protobuf:"varint,10,opt,name=authenticated_api,json=authenticatedApi,proto3" json:"authenticated_api,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Enabled bool `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"` + Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"` + UsingSandbox bool `protobuf:"varint,4,opt,name=using_sandbox,json=usingSandbox,proto3" json:"using_sandbox,omitempty"` + HttpTimeout string `protobuf:"bytes,5,opt,name=http_timeout,json=httpTimeout,proto3" json:"http_timeout,omitempty"` + HttpUseragent string `protobuf:"bytes,6,opt,name=http_useragent,json=httpUseragent,proto3" json:"http_useragent,omitempty"` + HttpProxy string `protobuf:"bytes,7,opt,name=http_proxy,json=httpProxy,proto3" json:"http_proxy,omitempty"` + BaseCurrencies string `protobuf:"bytes,8,opt,name=base_currencies,json=baseCurrencies,proto3" json:"base_currencies,omitempty"` + SupportedAssets map[string]*PairsSupported `protobuf:"bytes,9,rep,name=supported_assets,json=supportedAssets,proto3" json:"supported_assets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + AuthenticatedApi bool `protobuf:"varint,10,opt,name=authenticated_api,json=authenticatedApi,proto3" json:"authenticated_api,omitempty"` } -func (m *GetExchangeInfoResponse) Reset() { *m = GetExchangeInfoResponse{} } -func (m *GetExchangeInfoResponse) String() string { return proto.CompactTextString(m) } -func (*GetExchangeInfoResponse) ProtoMessage() {} +func (x *GetExchangeInfoResponse) Reset() { + *x = GetExchangeInfoResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangeInfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangeInfoResponse) ProtoMessage() {} + +func (x *GetExchangeInfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[19] + 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 GetExchangeInfoResponse.ProtoReflect.Descriptor instead. func (*GetExchangeInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{19} + return file_rpc_proto_rawDescGZIP(), []int{19} } -func (m *GetExchangeInfoResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangeInfoResponse.Unmarshal(m, b) -} -func (m *GetExchangeInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangeInfoResponse.Marshal(b, m, deterministic) -} -func (m *GetExchangeInfoResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangeInfoResponse.Merge(m, src) -} -func (m *GetExchangeInfoResponse) XXX_Size() int { - return xxx_messageInfo_GetExchangeInfoResponse.Size(m) -} -func (m *GetExchangeInfoResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangeInfoResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangeInfoResponse proto.InternalMessageInfo - -func (m *GetExchangeInfoResponse) GetName() string { - if m != nil { - return m.Name +func (x *GetExchangeInfoResponse) GetName() string { + if x != nil { + return x.Name } return "" } -func (m *GetExchangeInfoResponse) GetEnabled() bool { - if m != nil { - return m.Enabled +func (x *GetExchangeInfoResponse) GetEnabled() bool { + if x != nil { + return x.Enabled } return false } -func (m *GetExchangeInfoResponse) GetVerbose() bool { - if m != nil { - return m.Verbose +func (x *GetExchangeInfoResponse) GetVerbose() bool { + if x != nil { + return x.Verbose } return false } -func (m *GetExchangeInfoResponse) GetUsingSandbox() bool { - if m != nil { - return m.UsingSandbox +func (x *GetExchangeInfoResponse) GetUsingSandbox() bool { + if x != nil { + return x.UsingSandbox } return false } -func (m *GetExchangeInfoResponse) GetHttpTimeout() string { - if m != nil { - return m.HttpTimeout +func (x *GetExchangeInfoResponse) GetHttpTimeout() string { + if x != nil { + return x.HttpTimeout } return "" } -func (m *GetExchangeInfoResponse) GetHttpUseragent() string { - if m != nil { - return m.HttpUseragent +func (x *GetExchangeInfoResponse) GetHttpUseragent() string { + if x != nil { + return x.HttpUseragent } return "" } -func (m *GetExchangeInfoResponse) GetHttpProxy() string { - if m != nil { - return m.HttpProxy +func (x *GetExchangeInfoResponse) GetHttpProxy() string { + if x != nil { + return x.HttpProxy } return "" } -func (m *GetExchangeInfoResponse) GetBaseCurrencies() string { - if m != nil { - return m.BaseCurrencies +func (x *GetExchangeInfoResponse) GetBaseCurrencies() string { + if x != nil { + return x.BaseCurrencies } return "" } -func (m *GetExchangeInfoResponse) GetSupportedAssets() map[string]*PairsSupported { - if m != nil { - return m.SupportedAssets +func (x *GetExchangeInfoResponse) GetSupportedAssets() map[string]*PairsSupported { + if x != nil { + return x.SupportedAssets } return nil } -func (m *GetExchangeInfoResponse) GetAuthenticatedApi() bool { - if m != nil { - return m.AuthenticatedApi +func (x *GetExchangeInfoResponse) GetAuthenticatedApi() bool { + if x != nil { + return x.AuthenticatedApi } return false } type GetTickerRequest struct { - 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"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` } -func (m *GetTickerRequest) Reset() { *m = GetTickerRequest{} } -func (m *GetTickerRequest) String() string { return proto.CompactTextString(m) } -func (*GetTickerRequest) ProtoMessage() {} +func (x *GetTickerRequest) Reset() { + *x = GetTickerRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTickerRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTickerRequest) ProtoMessage() {} + +func (x *GetTickerRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[20] + 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 GetTickerRequest.ProtoReflect.Descriptor instead. func (*GetTickerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{20} + return file_rpc_proto_rawDescGZIP(), []int{20} } -func (m *GetTickerRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetTickerRequest.Unmarshal(m, b) -} -func (m *GetTickerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetTickerRequest.Marshal(b, m, deterministic) -} -func (m *GetTickerRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetTickerRequest.Merge(m, src) -} -func (m *GetTickerRequest) XXX_Size() int { - return xxx_messageInfo_GetTickerRequest.Size(m) -} -func (m *GetTickerRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetTickerRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetTickerRequest proto.InternalMessageInfo - -func (m *GetTickerRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetTickerRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetTickerRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *GetTickerRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *GetTickerRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *GetTickerRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } type CurrencyPair struct { - Delimiter string `protobuf:"bytes,1,opt,name=delimiter,proto3" json:"delimiter,omitempty"` - Base string `protobuf:"bytes,2,opt,name=base,proto3" json:"base,omitempty"` - Quote string `protobuf:"bytes,3,opt,name=quote,proto3" json:"quote,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Delimiter string `protobuf:"bytes,1,opt,name=delimiter,proto3" json:"delimiter,omitempty"` + Base string `protobuf:"bytes,2,opt,name=base,proto3" json:"base,omitempty"` + Quote string `protobuf:"bytes,3,opt,name=quote,proto3" json:"quote,omitempty"` } -func (m *CurrencyPair) Reset() { *m = CurrencyPair{} } -func (m *CurrencyPair) String() string { return proto.CompactTextString(m) } -func (*CurrencyPair) ProtoMessage() {} +func (x *CurrencyPair) Reset() { + *x = CurrencyPair{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CurrencyPair) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CurrencyPair) ProtoMessage() {} + +func (x *CurrencyPair) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[21] + 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 CurrencyPair.ProtoReflect.Descriptor instead. func (*CurrencyPair) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{21} + return file_rpc_proto_rawDescGZIP(), []int{21} } -func (m *CurrencyPair) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_CurrencyPair.Unmarshal(m, b) -} -func (m *CurrencyPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_CurrencyPair.Marshal(b, m, deterministic) -} -func (m *CurrencyPair) XXX_Merge(src proto.Message) { - xxx_messageInfo_CurrencyPair.Merge(m, src) -} -func (m *CurrencyPair) XXX_Size() int { - return xxx_messageInfo_CurrencyPair.Size(m) -} -func (m *CurrencyPair) XXX_DiscardUnknown() { - xxx_messageInfo_CurrencyPair.DiscardUnknown(m) -} - -var xxx_messageInfo_CurrencyPair proto.InternalMessageInfo - -func (m *CurrencyPair) GetDelimiter() string { - if m != nil { - return m.Delimiter +func (x *CurrencyPair) GetDelimiter() string { + if x != nil { + return x.Delimiter } return "" } -func (m *CurrencyPair) GetBase() string { - if m != nil { - return m.Base +func (x *CurrencyPair) GetBase() string { + if x != nil { + return x.Base } return "" } -func (m *CurrencyPair) GetQuote() string { - if m != nil { - return m.Quote +func (x *CurrencyPair) GetQuote() string { + if x != nil { + return x.Quote } return "" } type TickerResponse struct { - Pair *CurrencyPair `protobuf:"bytes,1,opt,name=pair,proto3" json:"pair,omitempty"` - LastUpdated int64 `protobuf:"varint,2,opt,name=last_updated,json=lastUpdated,proto3" json:"last_updated,omitempty"` - CurrencyPair string `protobuf:"bytes,3,opt,name=currency_pair,json=currencyPair,proto3" json:"currency_pair,omitempty"` - Last float64 `protobuf:"fixed64,4,opt,name=last,proto3" json:"last,omitempty"` - High float64 `protobuf:"fixed64,5,opt,name=high,proto3" json:"high,omitempty"` - Low float64 `protobuf:"fixed64,6,opt,name=low,proto3" json:"low,omitempty"` - Bid float64 `protobuf:"fixed64,7,opt,name=bid,proto3" json:"bid,omitempty"` - Ask float64 `protobuf:"fixed64,8,opt,name=ask,proto3" json:"ask,omitempty"` - Volume float64 `protobuf:"fixed64,9,opt,name=volume,proto3" json:"volume,omitempty"` - PriceAth float64 `protobuf:"fixed64,10,opt,name=price_ath,json=priceAth,proto3" json:"price_ath,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pair *CurrencyPair `protobuf:"bytes,1,opt,name=pair,proto3" json:"pair,omitempty"` + LastUpdated int64 `protobuf:"varint,2,opt,name=last_updated,json=lastUpdated,proto3" json:"last_updated,omitempty"` + CurrencyPair string `protobuf:"bytes,3,opt,name=currency_pair,json=currencyPair,proto3" json:"currency_pair,omitempty"` + Last float64 `protobuf:"fixed64,4,opt,name=last,proto3" json:"last,omitempty"` + High float64 `protobuf:"fixed64,5,opt,name=high,proto3" json:"high,omitempty"` + Low float64 `protobuf:"fixed64,6,opt,name=low,proto3" json:"low,omitempty"` + Bid float64 `protobuf:"fixed64,7,opt,name=bid,proto3" json:"bid,omitempty"` + Ask float64 `protobuf:"fixed64,8,opt,name=ask,proto3" json:"ask,omitempty"` + Volume float64 `protobuf:"fixed64,9,opt,name=volume,proto3" json:"volume,omitempty"` + PriceAth float64 `protobuf:"fixed64,10,opt,name=price_ath,json=priceAth,proto3" json:"price_ath,omitempty"` } -func (m *TickerResponse) Reset() { *m = TickerResponse{} } -func (m *TickerResponse) String() string { return proto.CompactTextString(m) } -func (*TickerResponse) ProtoMessage() {} +func (x *TickerResponse) Reset() { + *x = TickerResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TickerResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TickerResponse) ProtoMessage() {} + +func (x *TickerResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[22] + 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 TickerResponse.ProtoReflect.Descriptor instead. func (*TickerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{22} + return file_rpc_proto_rawDescGZIP(), []int{22} } -func (m *TickerResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_TickerResponse.Unmarshal(m, b) -} -func (m *TickerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_TickerResponse.Marshal(b, m, deterministic) -} -func (m *TickerResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_TickerResponse.Merge(m, src) -} -func (m *TickerResponse) XXX_Size() int { - return xxx_messageInfo_TickerResponse.Size(m) -} -func (m *TickerResponse) XXX_DiscardUnknown() { - xxx_messageInfo_TickerResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_TickerResponse proto.InternalMessageInfo - -func (m *TickerResponse) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *TickerResponse) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *TickerResponse) GetLastUpdated() int64 { - if m != nil { - return m.LastUpdated +func (x *TickerResponse) GetLastUpdated() int64 { + if x != nil { + return x.LastUpdated } return 0 } -func (m *TickerResponse) GetCurrencyPair() string { - if m != nil { - return m.CurrencyPair +func (x *TickerResponse) GetCurrencyPair() string { + if x != nil { + return x.CurrencyPair } return "" } -func (m *TickerResponse) GetLast() float64 { - if m != nil { - return m.Last +func (x *TickerResponse) GetLast() float64 { + if x != nil { + return x.Last } return 0 } -func (m *TickerResponse) GetHigh() float64 { - if m != nil { - return m.High +func (x *TickerResponse) GetHigh() float64 { + if x != nil { + return x.High } return 0 } -func (m *TickerResponse) GetLow() float64 { - if m != nil { - return m.Low +func (x *TickerResponse) GetLow() float64 { + if x != nil { + return x.Low } return 0 } -func (m *TickerResponse) GetBid() float64 { - if m != nil { - return m.Bid +func (x *TickerResponse) GetBid() float64 { + if x != nil { + return x.Bid } return 0 } -func (m *TickerResponse) GetAsk() float64 { - if m != nil { - return m.Ask +func (x *TickerResponse) GetAsk() float64 { + if x != nil { + return x.Ask } return 0 } -func (m *TickerResponse) GetVolume() float64 { - if m != nil { - return m.Volume +func (x *TickerResponse) GetVolume() float64 { + if x != nil { + return x.Volume } return 0 } -func (m *TickerResponse) GetPriceAth() float64 { - if m != nil { - return m.PriceAth +func (x *TickerResponse) GetPriceAth() float64 { + if x != nil { + return x.PriceAth } return 0 } type GetTickersRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetTickersRequest) Reset() { *m = GetTickersRequest{} } -func (m *GetTickersRequest) String() string { return proto.CompactTextString(m) } -func (*GetTickersRequest) ProtoMessage() {} +func (x *GetTickersRequest) Reset() { + *x = GetTickersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTickersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTickersRequest) ProtoMessage() {} + +func (x *GetTickersRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[23] + 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 GetTickersRequest.ProtoReflect.Descriptor instead. func (*GetTickersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{23} + return file_rpc_proto_rawDescGZIP(), []int{23} } -func (m *GetTickersRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetTickersRequest.Unmarshal(m, b) -} -func (m *GetTickersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetTickersRequest.Marshal(b, m, deterministic) -} -func (m *GetTickersRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetTickersRequest.Merge(m, src) -} -func (m *GetTickersRequest) XXX_Size() int { - return xxx_messageInfo_GetTickersRequest.Size(m) -} -func (m *GetTickersRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetTickersRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetTickersRequest proto.InternalMessageInfo - type Tickers struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Tickers []*TickerResponse `protobuf:"bytes,2,rep,name=tickers,proto3" json:"tickers,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Tickers []*TickerResponse `protobuf:"bytes,2,rep,name=tickers,proto3" json:"tickers,omitempty"` } -func (m *Tickers) Reset() { *m = Tickers{} } -func (m *Tickers) String() string { return proto.CompactTextString(m) } -func (*Tickers) ProtoMessage() {} +func (x *Tickers) Reset() { + *x = Tickers{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Tickers) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Tickers) ProtoMessage() {} + +func (x *Tickers) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[24] + 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 Tickers.ProtoReflect.Descriptor instead. func (*Tickers) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{24} + return file_rpc_proto_rawDescGZIP(), []int{24} } -func (m *Tickers) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_Tickers.Unmarshal(m, b) -} -func (m *Tickers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_Tickers.Marshal(b, m, deterministic) -} -func (m *Tickers) XXX_Merge(src proto.Message) { - xxx_messageInfo_Tickers.Merge(m, src) -} -func (m *Tickers) XXX_Size() int { - return xxx_messageInfo_Tickers.Size(m) -} -func (m *Tickers) XXX_DiscardUnknown() { - xxx_messageInfo_Tickers.DiscardUnknown(m) -} - -var xxx_messageInfo_Tickers proto.InternalMessageInfo - -func (m *Tickers) GetExchange() string { - if m != nil { - return m.Exchange +func (x *Tickers) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *Tickers) GetTickers() []*TickerResponse { - if m != nil { - return m.Tickers +func (x *Tickers) GetTickers() []*TickerResponse { + if x != nil { + return x.Tickers } return nil } type GetTickersResponse struct { - Tickers []*Tickers `protobuf:"bytes,1,rep,name=tickers,proto3" json:"tickers,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Tickers []*Tickers `protobuf:"bytes,1,rep,name=tickers,proto3" json:"tickers,omitempty"` } -func (m *GetTickersResponse) Reset() { *m = GetTickersResponse{} } -func (m *GetTickersResponse) String() string { return proto.CompactTextString(m) } -func (*GetTickersResponse) ProtoMessage() {} +func (x *GetTickersResponse) Reset() { + *x = GetTickersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTickersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTickersResponse) ProtoMessage() {} + +func (x *GetTickersResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[25] + 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 GetTickersResponse.ProtoReflect.Descriptor instead. func (*GetTickersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{25} + return file_rpc_proto_rawDescGZIP(), []int{25} } -func (m *GetTickersResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetTickersResponse.Unmarshal(m, b) -} -func (m *GetTickersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetTickersResponse.Marshal(b, m, deterministic) -} -func (m *GetTickersResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetTickersResponse.Merge(m, src) -} -func (m *GetTickersResponse) XXX_Size() int { - return xxx_messageInfo_GetTickersResponse.Size(m) -} -func (m *GetTickersResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetTickersResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetTickersResponse proto.InternalMessageInfo - -func (m *GetTickersResponse) GetTickers() []*Tickers { - if m != nil { - return m.Tickers +func (x *GetTickersResponse) GetTickers() []*Tickers { + if x != nil { + return x.Tickers } return nil } type GetOrderbookRequest struct { - 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"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` } -func (m *GetOrderbookRequest) Reset() { *m = GetOrderbookRequest{} } -func (m *GetOrderbookRequest) String() string { return proto.CompactTextString(m) } -func (*GetOrderbookRequest) ProtoMessage() {} +func (x *GetOrderbookRequest) Reset() { + *x = GetOrderbookRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbookRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbookRequest) ProtoMessage() {} + +func (x *GetOrderbookRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[26] + 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 GetOrderbookRequest.ProtoReflect.Descriptor instead. func (*GetOrderbookRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{26} + return file_rpc_proto_rawDescGZIP(), []int{26} } -func (m *GetOrderbookRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetOrderbookRequest.Unmarshal(m, b) -} -func (m *GetOrderbookRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetOrderbookRequest.Marshal(b, m, deterministic) -} -func (m *GetOrderbookRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOrderbookRequest.Merge(m, src) -} -func (m *GetOrderbookRequest) XXX_Size() int { - return xxx_messageInfo_GetOrderbookRequest.Size(m) -} -func (m *GetOrderbookRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetOrderbookRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetOrderbookRequest proto.InternalMessageInfo - -func (m *GetOrderbookRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetOrderbookRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetOrderbookRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *GetOrderbookRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *GetOrderbookRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *GetOrderbookRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } type OrderbookItem struct { - Amount float64 `protobuf:"fixed64,1,opt,name=amount,proto3" json:"amount,omitempty"` - Price float64 `protobuf:"fixed64,2,opt,name=price,proto3" json:"price,omitempty"` - Id int64 `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Amount float64 `protobuf:"fixed64,1,opt,name=amount,proto3" json:"amount,omitempty"` + Price float64 `protobuf:"fixed64,2,opt,name=price,proto3" json:"price,omitempty"` + Id int64 `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"` } -func (m *OrderbookItem) Reset() { *m = OrderbookItem{} } -func (m *OrderbookItem) String() string { return proto.CompactTextString(m) } -func (*OrderbookItem) ProtoMessage() {} +func (x *OrderbookItem) Reset() { + *x = OrderbookItem{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OrderbookItem) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OrderbookItem) ProtoMessage() {} + +func (x *OrderbookItem) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[27] + 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 OrderbookItem.ProtoReflect.Descriptor instead. func (*OrderbookItem) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{27} + return file_rpc_proto_rawDescGZIP(), []int{27} } -func (m *OrderbookItem) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OrderbookItem.Unmarshal(m, b) -} -func (m *OrderbookItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OrderbookItem.Marshal(b, m, deterministic) -} -func (m *OrderbookItem) XXX_Merge(src proto.Message) { - xxx_messageInfo_OrderbookItem.Merge(m, src) -} -func (m *OrderbookItem) XXX_Size() int { - return xxx_messageInfo_OrderbookItem.Size(m) -} -func (m *OrderbookItem) XXX_DiscardUnknown() { - xxx_messageInfo_OrderbookItem.DiscardUnknown(m) -} - -var xxx_messageInfo_OrderbookItem proto.InternalMessageInfo - -func (m *OrderbookItem) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *OrderbookItem) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *OrderbookItem) GetPrice() float64 { - if m != nil { - return m.Price +func (x *OrderbookItem) GetPrice() float64 { + if x != nil { + return x.Price } return 0 } -func (m *OrderbookItem) GetId() int64 { - if m != nil { - return m.Id +func (x *OrderbookItem) GetId() int64 { + if x != nil { + return x.Id } return 0 } type OrderbookResponse struct { - Pair *CurrencyPair `protobuf:"bytes,1,opt,name=pair,proto3" json:"pair,omitempty"` - CurrencyPair string `protobuf:"bytes,2,opt,name=currency_pair,json=currencyPair,proto3" json:"currency_pair,omitempty"` - Bids []*OrderbookItem `protobuf:"bytes,3,rep,name=bids,proto3" json:"bids,omitempty"` - Asks []*OrderbookItem `protobuf:"bytes,4,rep,name=asks,proto3" json:"asks,omitempty"` - LastUpdated int64 `protobuf:"varint,5,opt,name=last_updated,json=lastUpdated,proto3" json:"last_updated,omitempty"` - AssetType string `protobuf:"bytes,6,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pair *CurrencyPair `protobuf:"bytes,1,opt,name=pair,proto3" json:"pair,omitempty"` + CurrencyPair string `protobuf:"bytes,2,opt,name=currency_pair,json=currencyPair,proto3" json:"currency_pair,omitempty"` + Bids []*OrderbookItem `protobuf:"bytes,3,rep,name=bids,proto3" json:"bids,omitempty"` + Asks []*OrderbookItem `protobuf:"bytes,4,rep,name=asks,proto3" json:"asks,omitempty"` + LastUpdated int64 `protobuf:"varint,5,opt,name=last_updated,json=lastUpdated,proto3" json:"last_updated,omitempty"` + AssetType string `protobuf:"bytes,6,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` } -func (m *OrderbookResponse) Reset() { *m = OrderbookResponse{} } -func (m *OrderbookResponse) String() string { return proto.CompactTextString(m) } -func (*OrderbookResponse) ProtoMessage() {} +func (x *OrderbookResponse) Reset() { + *x = OrderbookResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OrderbookResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OrderbookResponse) ProtoMessage() {} + +func (x *OrderbookResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[28] + 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 OrderbookResponse.ProtoReflect.Descriptor instead. func (*OrderbookResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{28} + return file_rpc_proto_rawDescGZIP(), []int{28} } -func (m *OrderbookResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OrderbookResponse.Unmarshal(m, b) -} -func (m *OrderbookResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OrderbookResponse.Marshal(b, m, deterministic) -} -func (m *OrderbookResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_OrderbookResponse.Merge(m, src) -} -func (m *OrderbookResponse) XXX_Size() int { - return xxx_messageInfo_OrderbookResponse.Size(m) -} -func (m *OrderbookResponse) XXX_DiscardUnknown() { - xxx_messageInfo_OrderbookResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_OrderbookResponse proto.InternalMessageInfo - -func (m *OrderbookResponse) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *OrderbookResponse) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *OrderbookResponse) GetCurrencyPair() string { - if m != nil { - return m.CurrencyPair +func (x *OrderbookResponse) GetCurrencyPair() string { + if x != nil { + return x.CurrencyPair } return "" } -func (m *OrderbookResponse) GetBids() []*OrderbookItem { - if m != nil { - return m.Bids +func (x *OrderbookResponse) GetBids() []*OrderbookItem { + if x != nil { + return x.Bids } return nil } -func (m *OrderbookResponse) GetAsks() []*OrderbookItem { - if m != nil { - return m.Asks +func (x *OrderbookResponse) GetAsks() []*OrderbookItem { + if x != nil { + return x.Asks } return nil } -func (m *OrderbookResponse) GetLastUpdated() int64 { - if m != nil { - return m.LastUpdated +func (x *OrderbookResponse) GetLastUpdated() int64 { + if x != nil { + return x.LastUpdated } return 0 } -func (m *OrderbookResponse) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *OrderbookResponse) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } type GetOrderbooksRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetOrderbooksRequest) Reset() { *m = GetOrderbooksRequest{} } -func (m *GetOrderbooksRequest) String() string { return proto.CompactTextString(m) } -func (*GetOrderbooksRequest) ProtoMessage() {} +func (x *GetOrderbooksRequest) Reset() { + *x = GetOrderbooksRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbooksRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbooksRequest) ProtoMessage() {} + +func (x *GetOrderbooksRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[29] + 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 GetOrderbooksRequest.ProtoReflect.Descriptor instead. func (*GetOrderbooksRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{29} + return file_rpc_proto_rawDescGZIP(), []int{29} } -func (m *GetOrderbooksRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetOrderbooksRequest.Unmarshal(m, b) -} -func (m *GetOrderbooksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetOrderbooksRequest.Marshal(b, m, deterministic) -} -func (m *GetOrderbooksRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOrderbooksRequest.Merge(m, src) -} -func (m *GetOrderbooksRequest) XXX_Size() int { - return xxx_messageInfo_GetOrderbooksRequest.Size(m) -} -func (m *GetOrderbooksRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetOrderbooksRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetOrderbooksRequest proto.InternalMessageInfo - type Orderbooks struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Orderbooks []*OrderbookResponse `protobuf:"bytes,2,rep,name=orderbooks,proto3" json:"orderbooks,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Orderbooks []*OrderbookResponse `protobuf:"bytes,2,rep,name=orderbooks,proto3" json:"orderbooks,omitempty"` } -func (m *Orderbooks) Reset() { *m = Orderbooks{} } -func (m *Orderbooks) String() string { return proto.CompactTextString(m) } -func (*Orderbooks) ProtoMessage() {} +func (x *Orderbooks) Reset() { + *x = Orderbooks{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Orderbooks) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Orderbooks) ProtoMessage() {} + +func (x *Orderbooks) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[30] + 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 Orderbooks.ProtoReflect.Descriptor instead. func (*Orderbooks) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{30} + return file_rpc_proto_rawDescGZIP(), []int{30} } -func (m *Orderbooks) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_Orderbooks.Unmarshal(m, b) -} -func (m *Orderbooks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_Orderbooks.Marshal(b, m, deterministic) -} -func (m *Orderbooks) XXX_Merge(src proto.Message) { - xxx_messageInfo_Orderbooks.Merge(m, src) -} -func (m *Orderbooks) XXX_Size() int { - return xxx_messageInfo_Orderbooks.Size(m) -} -func (m *Orderbooks) XXX_DiscardUnknown() { - xxx_messageInfo_Orderbooks.DiscardUnknown(m) -} - -var xxx_messageInfo_Orderbooks proto.InternalMessageInfo - -func (m *Orderbooks) GetExchange() string { - if m != nil { - return m.Exchange +func (x *Orderbooks) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *Orderbooks) GetOrderbooks() []*OrderbookResponse { - if m != nil { - return m.Orderbooks +func (x *Orderbooks) GetOrderbooks() []*OrderbookResponse { + if x != nil { + return x.Orderbooks } return nil } type GetOrderbooksResponse struct { - Orderbooks []*Orderbooks `protobuf:"bytes,1,rep,name=orderbooks,proto3" json:"orderbooks,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Orderbooks []*Orderbooks `protobuf:"bytes,1,rep,name=orderbooks,proto3" json:"orderbooks,omitempty"` } -func (m *GetOrderbooksResponse) Reset() { *m = GetOrderbooksResponse{} } -func (m *GetOrderbooksResponse) String() string { return proto.CompactTextString(m) } -func (*GetOrderbooksResponse) ProtoMessage() {} +func (x *GetOrderbooksResponse) Reset() { + *x = GetOrderbooksResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbooksResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbooksResponse) ProtoMessage() {} + +func (x *GetOrderbooksResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[31] + 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 GetOrderbooksResponse.ProtoReflect.Descriptor instead. func (*GetOrderbooksResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{31} + return file_rpc_proto_rawDescGZIP(), []int{31} } -func (m *GetOrderbooksResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetOrderbooksResponse.Unmarshal(m, b) -} -func (m *GetOrderbooksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetOrderbooksResponse.Marshal(b, m, deterministic) -} -func (m *GetOrderbooksResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOrderbooksResponse.Merge(m, src) -} -func (m *GetOrderbooksResponse) XXX_Size() int { - return xxx_messageInfo_GetOrderbooksResponse.Size(m) -} -func (m *GetOrderbooksResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetOrderbooksResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetOrderbooksResponse proto.InternalMessageInfo - -func (m *GetOrderbooksResponse) GetOrderbooks() []*Orderbooks { - if m != nil { - return m.Orderbooks +func (x *GetOrderbooksResponse) GetOrderbooks() []*Orderbooks { + if x != nil { + return x.Orderbooks } return nil } type GetAccountInfoRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *GetAccountInfoRequest) Reset() { *m = GetAccountInfoRequest{} } -func (m *GetAccountInfoRequest) String() string { return proto.CompactTextString(m) } -func (*GetAccountInfoRequest) ProtoMessage() {} +func (x *GetAccountInfoRequest) Reset() { + *x = GetAccountInfoRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAccountInfoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAccountInfoRequest) ProtoMessage() {} + +func (x *GetAccountInfoRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[32] + 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 GetAccountInfoRequest.ProtoReflect.Descriptor instead. func (*GetAccountInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{32} + return file_rpc_proto_rawDescGZIP(), []int{32} } -func (m *GetAccountInfoRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetAccountInfoRequest.Unmarshal(m, b) -} -func (m *GetAccountInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetAccountInfoRequest.Marshal(b, m, deterministic) -} -func (m *GetAccountInfoRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAccountInfoRequest.Merge(m, src) -} -func (m *GetAccountInfoRequest) XXX_Size() int { - return xxx_messageInfo_GetAccountInfoRequest.Size(m) -} -func (m *GetAccountInfoRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetAccountInfoRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetAccountInfoRequest proto.InternalMessageInfo - -func (m *GetAccountInfoRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetAccountInfoRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type Account struct { - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Currencies []*AccountCurrencyInfo `protobuf:"bytes,2,rep,name=currencies,proto3" json:"currencies,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Currencies []*AccountCurrencyInfo `protobuf:"bytes,2,rep,name=currencies,proto3" json:"currencies,omitempty"` } -func (m *Account) Reset() { *m = Account{} } -func (m *Account) String() string { return proto.CompactTextString(m) } -func (*Account) ProtoMessage() {} +func (x *Account) Reset() { + *x = Account{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Account) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Account) ProtoMessage() {} + +func (x *Account) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[33] + 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 Account.ProtoReflect.Descriptor instead. func (*Account) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{33} + return file_rpc_proto_rawDescGZIP(), []int{33} } -func (m *Account) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_Account.Unmarshal(m, b) -} -func (m *Account) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_Account.Marshal(b, m, deterministic) -} -func (m *Account) XXX_Merge(src proto.Message) { - xxx_messageInfo_Account.Merge(m, src) -} -func (m *Account) XXX_Size() int { - return xxx_messageInfo_Account.Size(m) -} -func (m *Account) XXX_DiscardUnknown() { - xxx_messageInfo_Account.DiscardUnknown(m) -} - -var xxx_messageInfo_Account proto.InternalMessageInfo - -func (m *Account) GetId() string { - if m != nil { - return m.Id +func (x *Account) GetId() string { + if x != nil { + return x.Id } return "" } -func (m *Account) GetCurrencies() []*AccountCurrencyInfo { - if m != nil { - return m.Currencies +func (x *Account) GetCurrencies() []*AccountCurrencyInfo { + if x != nil { + return x.Currencies } return nil } type AccountCurrencyInfo struct { - Currency string `protobuf:"bytes,1,opt,name=currency,proto3" json:"currency,omitempty"` - TotalValue float64 `protobuf:"fixed64,2,opt,name=total_value,json=totalValue,proto3" json:"total_value,omitempty"` - Hold float64 `protobuf:"fixed64,3,opt,name=hold,proto3" json:"hold,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Currency string `protobuf:"bytes,1,opt,name=currency,proto3" json:"currency,omitempty"` + TotalValue float64 `protobuf:"fixed64,2,opt,name=total_value,json=totalValue,proto3" json:"total_value,omitempty"` + Hold float64 `protobuf:"fixed64,3,opt,name=hold,proto3" json:"hold,omitempty"` } -func (m *AccountCurrencyInfo) Reset() { *m = AccountCurrencyInfo{} } -func (m *AccountCurrencyInfo) String() string { return proto.CompactTextString(m) } -func (*AccountCurrencyInfo) ProtoMessage() {} +func (x *AccountCurrencyInfo) Reset() { + *x = AccountCurrencyInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AccountCurrencyInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AccountCurrencyInfo) ProtoMessage() {} + +func (x *AccountCurrencyInfo) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[34] + 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 AccountCurrencyInfo.ProtoReflect.Descriptor instead. func (*AccountCurrencyInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{34} + return file_rpc_proto_rawDescGZIP(), []int{34} } -func (m *AccountCurrencyInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AccountCurrencyInfo.Unmarshal(m, b) -} -func (m *AccountCurrencyInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AccountCurrencyInfo.Marshal(b, m, deterministic) -} -func (m *AccountCurrencyInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_AccountCurrencyInfo.Merge(m, src) -} -func (m *AccountCurrencyInfo) XXX_Size() int { - return xxx_messageInfo_AccountCurrencyInfo.Size(m) -} -func (m *AccountCurrencyInfo) XXX_DiscardUnknown() { - xxx_messageInfo_AccountCurrencyInfo.DiscardUnknown(m) -} - -var xxx_messageInfo_AccountCurrencyInfo proto.InternalMessageInfo - -func (m *AccountCurrencyInfo) GetCurrency() string { - if m != nil { - return m.Currency +func (x *AccountCurrencyInfo) GetCurrency() string { + if x != nil { + return x.Currency } return "" } -func (m *AccountCurrencyInfo) GetTotalValue() float64 { - if m != nil { - return m.TotalValue +func (x *AccountCurrencyInfo) GetTotalValue() float64 { + if x != nil { + return x.TotalValue } return 0 } -func (m *AccountCurrencyInfo) GetHold() float64 { - if m != nil { - return m.Hold +func (x *AccountCurrencyInfo) GetHold() float64 { + if x != nil { + return x.Hold } return 0 } type GetAccountInfoResponse struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Accounts []*Account `protobuf:"bytes,2,rep,name=accounts,proto3" json:"accounts,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Accounts []*Account `protobuf:"bytes,2,rep,name=accounts,proto3" json:"accounts,omitempty"` } -func (m *GetAccountInfoResponse) Reset() { *m = GetAccountInfoResponse{} } -func (m *GetAccountInfoResponse) String() string { return proto.CompactTextString(m) } -func (*GetAccountInfoResponse) ProtoMessage() {} +func (x *GetAccountInfoResponse) Reset() { + *x = GetAccountInfoResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAccountInfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAccountInfoResponse) ProtoMessage() {} + +func (x *GetAccountInfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[35] + 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 GetAccountInfoResponse.ProtoReflect.Descriptor instead. func (*GetAccountInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{35} + return file_rpc_proto_rawDescGZIP(), []int{35} } -func (m *GetAccountInfoResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetAccountInfoResponse.Unmarshal(m, b) -} -func (m *GetAccountInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetAccountInfoResponse.Marshal(b, m, deterministic) -} -func (m *GetAccountInfoResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAccountInfoResponse.Merge(m, src) -} -func (m *GetAccountInfoResponse) XXX_Size() int { - return xxx_messageInfo_GetAccountInfoResponse.Size(m) -} -func (m *GetAccountInfoResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetAccountInfoResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetAccountInfoResponse proto.InternalMessageInfo - -func (m *GetAccountInfoResponse) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetAccountInfoResponse) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetAccountInfoResponse) GetAccounts() []*Account { - if m != nil { - return m.Accounts +func (x *GetAccountInfoResponse) GetAccounts() []*Account { + if x != nil { + return x.Accounts } return nil } type GetConfigRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetConfigRequest) Reset() { *m = GetConfigRequest{} } -func (m *GetConfigRequest) String() string { return proto.CompactTextString(m) } -func (*GetConfigRequest) ProtoMessage() {} +func (x *GetConfigRequest) Reset() { + *x = GetConfigRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetConfigRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetConfigRequest) ProtoMessage() {} + +func (x *GetConfigRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[36] + 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 GetConfigRequest.ProtoReflect.Descriptor instead. func (*GetConfigRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{36} + return file_rpc_proto_rawDescGZIP(), []int{36} } -func (m *GetConfigRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetConfigRequest.Unmarshal(m, b) -} -func (m *GetConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetConfigRequest.Marshal(b, m, deterministic) -} -func (m *GetConfigRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetConfigRequest.Merge(m, src) -} -func (m *GetConfigRequest) XXX_Size() int { - return xxx_messageInfo_GetConfigRequest.Size(m) -} -func (m *GetConfigRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetConfigRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetConfigRequest proto.InternalMessageInfo - type GetConfigResponse struct { - Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` } -func (m *GetConfigResponse) Reset() { *m = GetConfigResponse{} } -func (m *GetConfigResponse) String() string { return proto.CompactTextString(m) } -func (*GetConfigResponse) ProtoMessage() {} +func (x *GetConfigResponse) Reset() { + *x = GetConfigResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetConfigResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetConfigResponse) ProtoMessage() {} + +func (x *GetConfigResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[37] + 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 GetConfigResponse.ProtoReflect.Descriptor instead. func (*GetConfigResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{37} + return file_rpc_proto_rawDescGZIP(), []int{37} } -func (m *GetConfigResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetConfigResponse.Unmarshal(m, b) -} -func (m *GetConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetConfigResponse.Marshal(b, m, deterministic) -} -func (m *GetConfigResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetConfigResponse.Merge(m, src) -} -func (m *GetConfigResponse) XXX_Size() int { - return xxx_messageInfo_GetConfigResponse.Size(m) -} -func (m *GetConfigResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetConfigResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetConfigResponse proto.InternalMessageInfo - -func (m *GetConfigResponse) GetData() []byte { - if m != nil { - return m.Data +func (x *GetConfigResponse) GetData() []byte { + if x != nil { + return x.Data } return nil } type PortfolioAddress struct { - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - CoinType string `protobuf:"bytes,2,opt,name=coin_type,json=coinType,proto3" json:"coin_type,omitempty"` - Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` - Balance float64 `protobuf:"fixed64,4,opt,name=balance,proto3" json:"balance,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + CoinType string `protobuf:"bytes,2,opt,name=coin_type,json=coinType,proto3" json:"coin_type,omitempty"` + Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + Balance float64 `protobuf:"fixed64,4,opt,name=balance,proto3" json:"balance,omitempty"` } -func (m *PortfolioAddress) Reset() { *m = PortfolioAddress{} } -func (m *PortfolioAddress) String() string { return proto.CompactTextString(m) } -func (*PortfolioAddress) ProtoMessage() {} +func (x *PortfolioAddress) Reset() { + *x = PortfolioAddress{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PortfolioAddress) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PortfolioAddress) ProtoMessage() {} + +func (x *PortfolioAddress) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[38] + 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 PortfolioAddress.ProtoReflect.Descriptor instead. func (*PortfolioAddress) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{38} + return file_rpc_proto_rawDescGZIP(), []int{38} } -func (m *PortfolioAddress) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PortfolioAddress.Unmarshal(m, b) -} -func (m *PortfolioAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PortfolioAddress.Marshal(b, m, deterministic) -} -func (m *PortfolioAddress) XXX_Merge(src proto.Message) { - xxx_messageInfo_PortfolioAddress.Merge(m, src) -} -func (m *PortfolioAddress) XXX_Size() int { - return xxx_messageInfo_PortfolioAddress.Size(m) -} -func (m *PortfolioAddress) XXX_DiscardUnknown() { - xxx_messageInfo_PortfolioAddress.DiscardUnknown(m) -} - -var xxx_messageInfo_PortfolioAddress proto.InternalMessageInfo - -func (m *PortfolioAddress) GetAddress() string { - if m != nil { - return m.Address +func (x *PortfolioAddress) GetAddress() string { + if x != nil { + return x.Address } return "" } -func (m *PortfolioAddress) GetCoinType() string { - if m != nil { - return m.CoinType +func (x *PortfolioAddress) GetCoinType() string { + if x != nil { + return x.CoinType } return "" } -func (m *PortfolioAddress) GetDescription() string { - if m != nil { - return m.Description +func (x *PortfolioAddress) GetDescription() string { + if x != nil { + return x.Description } return "" } -func (m *PortfolioAddress) GetBalance() float64 { - if m != nil { - return m.Balance +func (x *PortfolioAddress) GetBalance() float64 { + if x != nil { + return x.Balance } return 0 } type GetPortfolioRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetPortfolioRequest) Reset() { *m = GetPortfolioRequest{} } -func (m *GetPortfolioRequest) String() string { return proto.CompactTextString(m) } -func (*GetPortfolioRequest) ProtoMessage() {} +func (x *GetPortfolioRequest) Reset() { + *x = GetPortfolioRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetPortfolioRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPortfolioRequest) ProtoMessage() {} + +func (x *GetPortfolioRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[39] + 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 GetPortfolioRequest.ProtoReflect.Descriptor instead. func (*GetPortfolioRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{39} + return file_rpc_proto_rawDescGZIP(), []int{39} } -func (m *GetPortfolioRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetPortfolioRequest.Unmarshal(m, b) -} -func (m *GetPortfolioRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetPortfolioRequest.Marshal(b, m, deterministic) -} -func (m *GetPortfolioRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetPortfolioRequest.Merge(m, src) -} -func (m *GetPortfolioRequest) XXX_Size() int { - return xxx_messageInfo_GetPortfolioRequest.Size(m) -} -func (m *GetPortfolioRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetPortfolioRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetPortfolioRequest proto.InternalMessageInfo - type GetPortfolioResponse struct { - Portfolio []*PortfolioAddress `protobuf:"bytes,1,rep,name=portfolio,proto3" json:"portfolio,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Portfolio []*PortfolioAddress `protobuf:"bytes,1,rep,name=portfolio,proto3" json:"portfolio,omitempty"` } -func (m *GetPortfolioResponse) Reset() { *m = GetPortfolioResponse{} } -func (m *GetPortfolioResponse) String() string { return proto.CompactTextString(m) } -func (*GetPortfolioResponse) ProtoMessage() {} +func (x *GetPortfolioResponse) Reset() { + *x = GetPortfolioResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetPortfolioResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPortfolioResponse) ProtoMessage() {} + +func (x *GetPortfolioResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[40] + 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 GetPortfolioResponse.ProtoReflect.Descriptor instead. func (*GetPortfolioResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{40} + return file_rpc_proto_rawDescGZIP(), []int{40} } -func (m *GetPortfolioResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetPortfolioResponse.Unmarshal(m, b) -} -func (m *GetPortfolioResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetPortfolioResponse.Marshal(b, m, deterministic) -} -func (m *GetPortfolioResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetPortfolioResponse.Merge(m, src) -} -func (m *GetPortfolioResponse) XXX_Size() int { - return xxx_messageInfo_GetPortfolioResponse.Size(m) -} -func (m *GetPortfolioResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetPortfolioResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetPortfolioResponse proto.InternalMessageInfo - -func (m *GetPortfolioResponse) GetPortfolio() []*PortfolioAddress { - if m != nil { - return m.Portfolio +func (x *GetPortfolioResponse) GetPortfolio() []*PortfolioAddress { + if x != nil { + return x.Portfolio } return nil } type GetPortfolioSummaryRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetPortfolioSummaryRequest) Reset() { *m = GetPortfolioSummaryRequest{} } -func (m *GetPortfolioSummaryRequest) String() string { return proto.CompactTextString(m) } -func (*GetPortfolioSummaryRequest) ProtoMessage() {} +func (x *GetPortfolioSummaryRequest) Reset() { + *x = GetPortfolioSummaryRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetPortfolioSummaryRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPortfolioSummaryRequest) ProtoMessage() {} + +func (x *GetPortfolioSummaryRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[41] + 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 GetPortfolioSummaryRequest.ProtoReflect.Descriptor instead. func (*GetPortfolioSummaryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{41} + return file_rpc_proto_rawDescGZIP(), []int{41} } -func (m *GetPortfolioSummaryRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetPortfolioSummaryRequest.Unmarshal(m, b) -} -func (m *GetPortfolioSummaryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetPortfolioSummaryRequest.Marshal(b, m, deterministic) -} -func (m *GetPortfolioSummaryRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetPortfolioSummaryRequest.Merge(m, src) -} -func (m *GetPortfolioSummaryRequest) XXX_Size() int { - return xxx_messageInfo_GetPortfolioSummaryRequest.Size(m) -} -func (m *GetPortfolioSummaryRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetPortfolioSummaryRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetPortfolioSummaryRequest proto.InternalMessageInfo - type Coin struct { - Coin string `protobuf:"bytes,1,opt,name=coin,proto3" json:"coin,omitempty"` - Balance float64 `protobuf:"fixed64,2,opt,name=balance,proto3" json:"balance,omitempty"` - Address string `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` - Percentage float64 `protobuf:"fixed64,4,opt,name=percentage,proto3" json:"percentage,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Coin string `protobuf:"bytes,1,opt,name=coin,proto3" json:"coin,omitempty"` + Balance float64 `protobuf:"fixed64,2,opt,name=balance,proto3" json:"balance,omitempty"` + Address string `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` + Percentage float64 `protobuf:"fixed64,4,opt,name=percentage,proto3" json:"percentage,omitempty"` } -func (m *Coin) Reset() { *m = Coin{} } -func (m *Coin) String() string { return proto.CompactTextString(m) } -func (*Coin) ProtoMessage() {} +func (x *Coin) Reset() { + *x = Coin{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Coin) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Coin) ProtoMessage() {} + +func (x *Coin) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[42] + 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 Coin.ProtoReflect.Descriptor instead. func (*Coin) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{42} + return file_rpc_proto_rawDescGZIP(), []int{42} } -func (m *Coin) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_Coin.Unmarshal(m, b) -} -func (m *Coin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_Coin.Marshal(b, m, deterministic) -} -func (m *Coin) XXX_Merge(src proto.Message) { - xxx_messageInfo_Coin.Merge(m, src) -} -func (m *Coin) XXX_Size() int { - return xxx_messageInfo_Coin.Size(m) -} -func (m *Coin) XXX_DiscardUnknown() { - xxx_messageInfo_Coin.DiscardUnknown(m) -} - -var xxx_messageInfo_Coin proto.InternalMessageInfo - -func (m *Coin) GetCoin() string { - if m != nil { - return m.Coin +func (x *Coin) GetCoin() string { + if x != nil { + return x.Coin } return "" } -func (m *Coin) GetBalance() float64 { - if m != nil { - return m.Balance +func (x *Coin) GetBalance() float64 { + if x != nil { + return x.Balance } return 0 } -func (m *Coin) GetAddress() string { - if m != nil { - return m.Address +func (x *Coin) GetAddress() string { + if x != nil { + return x.Address } return "" } -func (m *Coin) GetPercentage() float64 { - if m != nil { - return m.Percentage +func (x *Coin) GetPercentage() float64 { + if x != nil { + return x.Percentage } return 0 } type OfflineCoinSummary struct { - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - Balance float64 `protobuf:"fixed64,2,opt,name=balance,proto3" json:"balance,omitempty"` - Percentage float64 `protobuf:"fixed64,3,opt,name=percentage,proto3" json:"percentage,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Balance float64 `protobuf:"fixed64,2,opt,name=balance,proto3" json:"balance,omitempty"` + Percentage float64 `protobuf:"fixed64,3,opt,name=percentage,proto3" json:"percentage,omitempty"` } -func (m *OfflineCoinSummary) Reset() { *m = OfflineCoinSummary{} } -func (m *OfflineCoinSummary) String() string { return proto.CompactTextString(m) } -func (*OfflineCoinSummary) ProtoMessage() {} +func (x *OfflineCoinSummary) Reset() { + *x = OfflineCoinSummary{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OfflineCoinSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OfflineCoinSummary) ProtoMessage() {} + +func (x *OfflineCoinSummary) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[43] + 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 OfflineCoinSummary.ProtoReflect.Descriptor instead. func (*OfflineCoinSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{43} + return file_rpc_proto_rawDescGZIP(), []int{43} } -func (m *OfflineCoinSummary) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OfflineCoinSummary.Unmarshal(m, b) -} -func (m *OfflineCoinSummary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OfflineCoinSummary.Marshal(b, m, deterministic) -} -func (m *OfflineCoinSummary) XXX_Merge(src proto.Message) { - xxx_messageInfo_OfflineCoinSummary.Merge(m, src) -} -func (m *OfflineCoinSummary) XXX_Size() int { - return xxx_messageInfo_OfflineCoinSummary.Size(m) -} -func (m *OfflineCoinSummary) XXX_DiscardUnknown() { - xxx_messageInfo_OfflineCoinSummary.DiscardUnknown(m) -} - -var xxx_messageInfo_OfflineCoinSummary proto.InternalMessageInfo - -func (m *OfflineCoinSummary) GetAddress() string { - if m != nil { - return m.Address +func (x *OfflineCoinSummary) GetAddress() string { + if x != nil { + return x.Address } return "" } -func (m *OfflineCoinSummary) GetBalance() float64 { - if m != nil { - return m.Balance +func (x *OfflineCoinSummary) GetBalance() float64 { + if x != nil { + return x.Balance } return 0 } -func (m *OfflineCoinSummary) GetPercentage() float64 { - if m != nil { - return m.Percentage +func (x *OfflineCoinSummary) GetPercentage() float64 { + if x != nil { + return x.Percentage } return 0 } type OnlineCoinSummary struct { - Balance float64 `protobuf:"fixed64,1,opt,name=balance,proto3" json:"balance,omitempty"` - Percentage float64 `protobuf:"fixed64,2,opt,name=percentage,proto3" json:"percentage,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Balance float64 `protobuf:"fixed64,1,opt,name=balance,proto3" json:"balance,omitempty"` + Percentage float64 `protobuf:"fixed64,2,opt,name=percentage,proto3" json:"percentage,omitempty"` } -func (m *OnlineCoinSummary) Reset() { *m = OnlineCoinSummary{} } -func (m *OnlineCoinSummary) String() string { return proto.CompactTextString(m) } -func (*OnlineCoinSummary) ProtoMessage() {} +func (x *OnlineCoinSummary) Reset() { + *x = OnlineCoinSummary{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OnlineCoinSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OnlineCoinSummary) ProtoMessage() {} + +func (x *OnlineCoinSummary) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[44] + 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 OnlineCoinSummary.ProtoReflect.Descriptor instead. func (*OnlineCoinSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{44} + return file_rpc_proto_rawDescGZIP(), []int{44} } -func (m *OnlineCoinSummary) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OnlineCoinSummary.Unmarshal(m, b) -} -func (m *OnlineCoinSummary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OnlineCoinSummary.Marshal(b, m, deterministic) -} -func (m *OnlineCoinSummary) XXX_Merge(src proto.Message) { - xxx_messageInfo_OnlineCoinSummary.Merge(m, src) -} -func (m *OnlineCoinSummary) XXX_Size() int { - return xxx_messageInfo_OnlineCoinSummary.Size(m) -} -func (m *OnlineCoinSummary) XXX_DiscardUnknown() { - xxx_messageInfo_OnlineCoinSummary.DiscardUnknown(m) -} - -var xxx_messageInfo_OnlineCoinSummary proto.InternalMessageInfo - -func (m *OnlineCoinSummary) GetBalance() float64 { - if m != nil { - return m.Balance +func (x *OnlineCoinSummary) GetBalance() float64 { + if x != nil { + return x.Balance } return 0 } -func (m *OnlineCoinSummary) GetPercentage() float64 { - if m != nil { - return m.Percentage +func (x *OnlineCoinSummary) GetPercentage() float64 { + if x != nil { + return x.Percentage } return 0 } type OfflineCoins struct { - Addresses []*OfflineCoinSummary `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Addresses []*OfflineCoinSummary `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"` } -func (m *OfflineCoins) Reset() { *m = OfflineCoins{} } -func (m *OfflineCoins) String() string { return proto.CompactTextString(m) } -func (*OfflineCoins) ProtoMessage() {} +func (x *OfflineCoins) Reset() { + *x = OfflineCoins{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OfflineCoins) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OfflineCoins) ProtoMessage() {} + +func (x *OfflineCoins) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[45] + 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 OfflineCoins.ProtoReflect.Descriptor instead. func (*OfflineCoins) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{45} + return file_rpc_proto_rawDescGZIP(), []int{45} } -func (m *OfflineCoins) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OfflineCoins.Unmarshal(m, b) -} -func (m *OfflineCoins) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OfflineCoins.Marshal(b, m, deterministic) -} -func (m *OfflineCoins) XXX_Merge(src proto.Message) { - xxx_messageInfo_OfflineCoins.Merge(m, src) -} -func (m *OfflineCoins) XXX_Size() int { - return xxx_messageInfo_OfflineCoins.Size(m) -} -func (m *OfflineCoins) XXX_DiscardUnknown() { - xxx_messageInfo_OfflineCoins.DiscardUnknown(m) -} - -var xxx_messageInfo_OfflineCoins proto.InternalMessageInfo - -func (m *OfflineCoins) GetAddresses() []*OfflineCoinSummary { - if m != nil { - return m.Addresses +func (x *OfflineCoins) GetAddresses() []*OfflineCoinSummary { + if x != nil { + return x.Addresses } return nil } type OnlineCoins struct { - Coins map[string]*OnlineCoinSummary `protobuf:"bytes,1,rep,name=coins,proto3" json:"coins,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Coins map[string]*OnlineCoinSummary `protobuf:"bytes,1,rep,name=coins,proto3" json:"coins,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } -func (m *OnlineCoins) Reset() { *m = OnlineCoins{} } -func (m *OnlineCoins) String() string { return proto.CompactTextString(m) } -func (*OnlineCoins) ProtoMessage() {} +func (x *OnlineCoins) Reset() { + *x = OnlineCoins{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OnlineCoins) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OnlineCoins) ProtoMessage() {} + +func (x *OnlineCoins) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[46] + 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 OnlineCoins.ProtoReflect.Descriptor instead. func (*OnlineCoins) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{46} + return file_rpc_proto_rawDescGZIP(), []int{46} } -func (m *OnlineCoins) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OnlineCoins.Unmarshal(m, b) -} -func (m *OnlineCoins) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OnlineCoins.Marshal(b, m, deterministic) -} -func (m *OnlineCoins) XXX_Merge(src proto.Message) { - xxx_messageInfo_OnlineCoins.Merge(m, src) -} -func (m *OnlineCoins) XXX_Size() int { - return xxx_messageInfo_OnlineCoins.Size(m) -} -func (m *OnlineCoins) XXX_DiscardUnknown() { - xxx_messageInfo_OnlineCoins.DiscardUnknown(m) -} - -var xxx_messageInfo_OnlineCoins proto.InternalMessageInfo - -func (m *OnlineCoins) GetCoins() map[string]*OnlineCoinSummary { - if m != nil { - return m.Coins +func (x *OnlineCoins) GetCoins() map[string]*OnlineCoinSummary { + if x != nil { + return x.Coins } return nil } type GetPortfolioSummaryResponse struct { - CoinTotals []*Coin `protobuf:"bytes,1,rep,name=coin_totals,json=coinTotals,proto3" json:"coin_totals,omitempty"` - CoinsOffline []*Coin `protobuf:"bytes,2,rep,name=coins_offline,json=coinsOffline,proto3" json:"coins_offline,omitempty"` - CoinsOfflineSummary map[string]*OfflineCoins `protobuf:"bytes,3,rep,name=coins_offline_summary,json=coinsOfflineSummary,proto3" json:"coins_offline_summary,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - CoinsOnline []*Coin `protobuf:"bytes,4,rep,name=coins_online,json=coinsOnline,proto3" json:"coins_online,omitempty"` - CoinsOnlineSummary map[string]*OnlineCoins `protobuf:"bytes,5,rep,name=coins_online_summary,json=coinsOnlineSummary,proto3" json:"coins_online_summary,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CoinTotals []*Coin `protobuf:"bytes,1,rep,name=coin_totals,json=coinTotals,proto3" json:"coin_totals,omitempty"` + CoinsOffline []*Coin `protobuf:"bytes,2,rep,name=coins_offline,json=coinsOffline,proto3" json:"coins_offline,omitempty"` + CoinsOfflineSummary map[string]*OfflineCoins `protobuf:"bytes,3,rep,name=coins_offline_summary,json=coinsOfflineSummary,proto3" json:"coins_offline_summary,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + CoinsOnline []*Coin `protobuf:"bytes,4,rep,name=coins_online,json=coinsOnline,proto3" json:"coins_online,omitempty"` + CoinsOnlineSummary map[string]*OnlineCoins `protobuf:"bytes,5,rep,name=coins_online_summary,json=coinsOnlineSummary,proto3" json:"coins_online_summary,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } -func (m *GetPortfolioSummaryResponse) Reset() { *m = GetPortfolioSummaryResponse{} } -func (m *GetPortfolioSummaryResponse) String() string { return proto.CompactTextString(m) } -func (*GetPortfolioSummaryResponse) ProtoMessage() {} +func (x *GetPortfolioSummaryResponse) Reset() { + *x = GetPortfolioSummaryResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetPortfolioSummaryResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPortfolioSummaryResponse) ProtoMessage() {} + +func (x *GetPortfolioSummaryResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[47] + 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 GetPortfolioSummaryResponse.ProtoReflect.Descriptor instead. func (*GetPortfolioSummaryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{47} + return file_rpc_proto_rawDescGZIP(), []int{47} } -func (m *GetPortfolioSummaryResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetPortfolioSummaryResponse.Unmarshal(m, b) -} -func (m *GetPortfolioSummaryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetPortfolioSummaryResponse.Marshal(b, m, deterministic) -} -func (m *GetPortfolioSummaryResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetPortfolioSummaryResponse.Merge(m, src) -} -func (m *GetPortfolioSummaryResponse) XXX_Size() int { - return xxx_messageInfo_GetPortfolioSummaryResponse.Size(m) -} -func (m *GetPortfolioSummaryResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetPortfolioSummaryResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetPortfolioSummaryResponse proto.InternalMessageInfo - -func (m *GetPortfolioSummaryResponse) GetCoinTotals() []*Coin { - if m != nil { - return m.CoinTotals +func (x *GetPortfolioSummaryResponse) GetCoinTotals() []*Coin { + if x != nil { + return x.CoinTotals } return nil } -func (m *GetPortfolioSummaryResponse) GetCoinsOffline() []*Coin { - if m != nil { - return m.CoinsOffline +func (x *GetPortfolioSummaryResponse) GetCoinsOffline() []*Coin { + if x != nil { + return x.CoinsOffline } return nil } -func (m *GetPortfolioSummaryResponse) GetCoinsOfflineSummary() map[string]*OfflineCoins { - if m != nil { - return m.CoinsOfflineSummary +func (x *GetPortfolioSummaryResponse) GetCoinsOfflineSummary() map[string]*OfflineCoins { + if x != nil { + return x.CoinsOfflineSummary } return nil } -func (m *GetPortfolioSummaryResponse) GetCoinsOnline() []*Coin { - if m != nil { - return m.CoinsOnline +func (x *GetPortfolioSummaryResponse) GetCoinsOnline() []*Coin { + if x != nil { + return x.CoinsOnline } return nil } -func (m *GetPortfolioSummaryResponse) GetCoinsOnlineSummary() map[string]*OnlineCoins { - if m != nil { - return m.CoinsOnlineSummary +func (x *GetPortfolioSummaryResponse) GetCoinsOnlineSummary() map[string]*OnlineCoins { + if x != nil { + return x.CoinsOnlineSummary } return nil } type AddPortfolioAddressRequest struct { - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - CoinType string `protobuf:"bytes,2,opt,name=coin_type,json=coinType,proto3" json:"coin_type,omitempty"` - Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` - Balance float64 `protobuf:"fixed64,4,opt,name=balance,proto3" json:"balance,omitempty"` - SupportedExchanges string `protobuf:"bytes,5,opt,name=supported_exchanges,json=supportedExchanges,proto3" json:"supported_exchanges,omitempty"` - ColdStorage bool `protobuf:"varint,6,opt,name=cold_storage,json=coldStorage,proto3" json:"cold_storage,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + CoinType string `protobuf:"bytes,2,opt,name=coin_type,json=coinType,proto3" json:"coin_type,omitempty"` + Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + Balance float64 `protobuf:"fixed64,4,opt,name=balance,proto3" json:"balance,omitempty"` + SupportedExchanges string `protobuf:"bytes,5,opt,name=supported_exchanges,json=supportedExchanges,proto3" json:"supported_exchanges,omitempty"` + ColdStorage bool `protobuf:"varint,6,opt,name=cold_storage,json=coldStorage,proto3" json:"cold_storage,omitempty"` } -func (m *AddPortfolioAddressRequest) Reset() { *m = AddPortfolioAddressRequest{} } -func (m *AddPortfolioAddressRequest) String() string { return proto.CompactTextString(m) } -func (*AddPortfolioAddressRequest) ProtoMessage() {} +func (x *AddPortfolioAddressRequest) Reset() { + *x = AddPortfolioAddressRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddPortfolioAddressRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddPortfolioAddressRequest) ProtoMessage() {} + +func (x *AddPortfolioAddressRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[48] + 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 AddPortfolioAddressRequest.ProtoReflect.Descriptor instead. func (*AddPortfolioAddressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{48} + return file_rpc_proto_rawDescGZIP(), []int{48} } -func (m *AddPortfolioAddressRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AddPortfolioAddressRequest.Unmarshal(m, b) -} -func (m *AddPortfolioAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AddPortfolioAddressRequest.Marshal(b, m, deterministic) -} -func (m *AddPortfolioAddressRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddPortfolioAddressRequest.Merge(m, src) -} -func (m *AddPortfolioAddressRequest) XXX_Size() int { - return xxx_messageInfo_AddPortfolioAddressRequest.Size(m) -} -func (m *AddPortfolioAddressRequest) XXX_DiscardUnknown() { - xxx_messageInfo_AddPortfolioAddressRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_AddPortfolioAddressRequest proto.InternalMessageInfo - -func (m *AddPortfolioAddressRequest) GetAddress() string { - if m != nil { - return m.Address +func (x *AddPortfolioAddressRequest) GetAddress() string { + if x != nil { + return x.Address } return "" } -func (m *AddPortfolioAddressRequest) GetCoinType() string { - if m != nil { - return m.CoinType +func (x *AddPortfolioAddressRequest) GetCoinType() string { + if x != nil { + return x.CoinType } return "" } -func (m *AddPortfolioAddressRequest) GetDescription() string { - if m != nil { - return m.Description +func (x *AddPortfolioAddressRequest) GetDescription() string { + if x != nil { + return x.Description } return "" } -func (m *AddPortfolioAddressRequest) GetBalance() float64 { - if m != nil { - return m.Balance +func (x *AddPortfolioAddressRequest) GetBalance() float64 { + if x != nil { + return x.Balance } return 0 } -func (m *AddPortfolioAddressRequest) GetSupportedExchanges() string { - if m != nil { - return m.SupportedExchanges +func (x *AddPortfolioAddressRequest) GetSupportedExchanges() string { + if x != nil { + return x.SupportedExchanges } return "" } -func (m *AddPortfolioAddressRequest) GetColdStorage() bool { - if m != nil { - return m.ColdStorage +func (x *AddPortfolioAddressRequest) GetColdStorage() bool { + if x != nil { + return x.ColdStorage } return false } type RemovePortfolioAddressRequest struct { - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - CoinType string `protobuf:"bytes,2,opt,name=coin_type,json=coinType,proto3" json:"coin_type,omitempty"` - Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + CoinType string `protobuf:"bytes,2,opt,name=coin_type,json=coinType,proto3" json:"coin_type,omitempty"` + Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` } -func (m *RemovePortfolioAddressRequest) Reset() { *m = RemovePortfolioAddressRequest{} } -func (m *RemovePortfolioAddressRequest) String() string { return proto.CompactTextString(m) } -func (*RemovePortfolioAddressRequest) ProtoMessage() {} +func (x *RemovePortfolioAddressRequest) Reset() { + *x = RemovePortfolioAddressRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RemovePortfolioAddressRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RemovePortfolioAddressRequest) ProtoMessage() {} + +func (x *RemovePortfolioAddressRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[49] + 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 RemovePortfolioAddressRequest.ProtoReflect.Descriptor instead. func (*RemovePortfolioAddressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{49} + return file_rpc_proto_rawDescGZIP(), []int{49} } -func (m *RemovePortfolioAddressRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_RemovePortfolioAddressRequest.Unmarshal(m, b) -} -func (m *RemovePortfolioAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_RemovePortfolioAddressRequest.Marshal(b, m, deterministic) -} -func (m *RemovePortfolioAddressRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_RemovePortfolioAddressRequest.Merge(m, src) -} -func (m *RemovePortfolioAddressRequest) XXX_Size() int { - return xxx_messageInfo_RemovePortfolioAddressRequest.Size(m) -} -func (m *RemovePortfolioAddressRequest) XXX_DiscardUnknown() { - xxx_messageInfo_RemovePortfolioAddressRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_RemovePortfolioAddressRequest proto.InternalMessageInfo - -func (m *RemovePortfolioAddressRequest) GetAddress() string { - if m != nil { - return m.Address +func (x *RemovePortfolioAddressRequest) GetAddress() string { + if x != nil { + return x.Address } return "" } -func (m *RemovePortfolioAddressRequest) GetCoinType() string { - if m != nil { - return m.CoinType +func (x *RemovePortfolioAddressRequest) GetCoinType() string { + if x != nil { + return x.CoinType } return "" } -func (m *RemovePortfolioAddressRequest) GetDescription() string { - if m != nil { - return m.Description +func (x *RemovePortfolioAddressRequest) GetDescription() string { + if x != nil { + return x.Description } return "" } type GetForexProvidersRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetForexProvidersRequest) Reset() { *m = GetForexProvidersRequest{} } -func (m *GetForexProvidersRequest) String() string { return proto.CompactTextString(m) } -func (*GetForexProvidersRequest) ProtoMessage() {} +func (x *GetForexProvidersRequest) Reset() { + *x = GetForexProvidersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetForexProvidersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetForexProvidersRequest) ProtoMessage() {} + +func (x *GetForexProvidersRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[50] + 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 GetForexProvidersRequest.ProtoReflect.Descriptor instead. func (*GetForexProvidersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{50} + return file_rpc_proto_rawDescGZIP(), []int{50} } -func (m *GetForexProvidersRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetForexProvidersRequest.Unmarshal(m, b) -} -func (m *GetForexProvidersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetForexProvidersRequest.Marshal(b, m, deterministic) -} -func (m *GetForexProvidersRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetForexProvidersRequest.Merge(m, src) -} -func (m *GetForexProvidersRequest) XXX_Size() int { - return xxx_messageInfo_GetForexProvidersRequest.Size(m) -} -func (m *GetForexProvidersRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetForexProvidersRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetForexProvidersRequest proto.InternalMessageInfo - type ForexProvider struct { - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Enabled bool `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"` - Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"` - RestPollingDelay string `protobuf:"bytes,4,opt,name=rest_polling_delay,json=restPollingDelay,proto3" json:"rest_polling_delay,omitempty"` - ApiKey string `protobuf:"bytes,5,opt,name=api_key,json=apiKey,proto3" json:"api_key,omitempty"` - ApiKeyLevel int64 `protobuf:"varint,6,opt,name=api_key_level,json=apiKeyLevel,proto3" json:"api_key_level,omitempty"` - PrimaryProvider bool `protobuf:"varint,7,opt,name=primary_provider,json=primaryProvider,proto3" json:"primary_provider,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Enabled bool `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"` + Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"` + RestPollingDelay string `protobuf:"bytes,4,opt,name=rest_polling_delay,json=restPollingDelay,proto3" json:"rest_polling_delay,omitempty"` + ApiKey string `protobuf:"bytes,5,opt,name=api_key,json=apiKey,proto3" json:"api_key,omitempty"` + ApiKeyLevel int64 `protobuf:"varint,6,opt,name=api_key_level,json=apiKeyLevel,proto3" json:"api_key_level,omitempty"` + PrimaryProvider bool `protobuf:"varint,7,opt,name=primary_provider,json=primaryProvider,proto3" json:"primary_provider,omitempty"` } -func (m *ForexProvider) Reset() { *m = ForexProvider{} } -func (m *ForexProvider) String() string { return proto.CompactTextString(m) } -func (*ForexProvider) ProtoMessage() {} +func (x *ForexProvider) Reset() { + *x = ForexProvider{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[51] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ForexProvider) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ForexProvider) ProtoMessage() {} + +func (x *ForexProvider) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[51] + 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 ForexProvider.ProtoReflect.Descriptor instead. func (*ForexProvider) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{51} + return file_rpc_proto_rawDescGZIP(), []int{51} } -func (m *ForexProvider) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ForexProvider.Unmarshal(m, b) -} -func (m *ForexProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ForexProvider.Marshal(b, m, deterministic) -} -func (m *ForexProvider) XXX_Merge(src proto.Message) { - xxx_messageInfo_ForexProvider.Merge(m, src) -} -func (m *ForexProvider) XXX_Size() int { - return xxx_messageInfo_ForexProvider.Size(m) -} -func (m *ForexProvider) XXX_DiscardUnknown() { - xxx_messageInfo_ForexProvider.DiscardUnknown(m) -} - -var xxx_messageInfo_ForexProvider proto.InternalMessageInfo - -func (m *ForexProvider) GetName() string { - if m != nil { - return m.Name +func (x *ForexProvider) GetName() string { + if x != nil { + return x.Name } return "" } -func (m *ForexProvider) GetEnabled() bool { - if m != nil { - return m.Enabled +func (x *ForexProvider) GetEnabled() bool { + if x != nil { + return x.Enabled } return false } -func (m *ForexProvider) GetVerbose() bool { - if m != nil { - return m.Verbose +func (x *ForexProvider) GetVerbose() bool { + if x != nil { + return x.Verbose } return false } -func (m *ForexProvider) GetRestPollingDelay() string { - if m != nil { - return m.RestPollingDelay +func (x *ForexProvider) GetRestPollingDelay() string { + if x != nil { + return x.RestPollingDelay } return "" } -func (m *ForexProvider) GetApiKey() string { - if m != nil { - return m.ApiKey +func (x *ForexProvider) GetApiKey() string { + if x != nil { + return x.ApiKey } return "" } -func (m *ForexProvider) GetApiKeyLevel() int64 { - if m != nil { - return m.ApiKeyLevel +func (x *ForexProvider) GetApiKeyLevel() int64 { + if x != nil { + return x.ApiKeyLevel } return 0 } -func (m *ForexProvider) GetPrimaryProvider() bool { - if m != nil { - return m.PrimaryProvider +func (x *ForexProvider) GetPrimaryProvider() bool { + if x != nil { + return x.PrimaryProvider } return false } type GetForexProvidersResponse struct { - ForexProviders []*ForexProvider `protobuf:"bytes,1,rep,name=forex_providers,json=forexProviders,proto3" json:"forex_providers,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ForexProviders []*ForexProvider `protobuf:"bytes,1,rep,name=forex_providers,json=forexProviders,proto3" json:"forex_providers,omitempty"` } -func (m *GetForexProvidersResponse) Reset() { *m = GetForexProvidersResponse{} } -func (m *GetForexProvidersResponse) String() string { return proto.CompactTextString(m) } -func (*GetForexProvidersResponse) ProtoMessage() {} +func (x *GetForexProvidersResponse) Reset() { + *x = GetForexProvidersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[52] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetForexProvidersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetForexProvidersResponse) ProtoMessage() {} + +func (x *GetForexProvidersResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[52] + 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 GetForexProvidersResponse.ProtoReflect.Descriptor instead. func (*GetForexProvidersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{52} + return file_rpc_proto_rawDescGZIP(), []int{52} } -func (m *GetForexProvidersResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetForexProvidersResponse.Unmarshal(m, b) -} -func (m *GetForexProvidersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetForexProvidersResponse.Marshal(b, m, deterministic) -} -func (m *GetForexProvidersResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetForexProvidersResponse.Merge(m, src) -} -func (m *GetForexProvidersResponse) XXX_Size() int { - return xxx_messageInfo_GetForexProvidersResponse.Size(m) -} -func (m *GetForexProvidersResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetForexProvidersResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetForexProvidersResponse proto.InternalMessageInfo - -func (m *GetForexProvidersResponse) GetForexProviders() []*ForexProvider { - if m != nil { - return m.ForexProviders +func (x *GetForexProvidersResponse) GetForexProviders() []*ForexProvider { + if x != nil { + return x.ForexProviders } return nil } type GetForexRatesRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetForexRatesRequest) Reset() { *m = GetForexRatesRequest{} } -func (m *GetForexRatesRequest) String() string { return proto.CompactTextString(m) } -func (*GetForexRatesRequest) ProtoMessage() {} +func (x *GetForexRatesRequest) Reset() { + *x = GetForexRatesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[53] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetForexRatesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetForexRatesRequest) ProtoMessage() {} + +func (x *GetForexRatesRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[53] + 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 GetForexRatesRequest.ProtoReflect.Descriptor instead. func (*GetForexRatesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{53} + return file_rpc_proto_rawDescGZIP(), []int{53} } -func (m *GetForexRatesRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetForexRatesRequest.Unmarshal(m, b) -} -func (m *GetForexRatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetForexRatesRequest.Marshal(b, m, deterministic) -} -func (m *GetForexRatesRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetForexRatesRequest.Merge(m, src) -} -func (m *GetForexRatesRequest) XXX_Size() int { - return xxx_messageInfo_GetForexRatesRequest.Size(m) -} -func (m *GetForexRatesRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetForexRatesRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetForexRatesRequest proto.InternalMessageInfo - type ForexRatesConversion struct { - From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"` - To string `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"` - Rate float64 `protobuf:"fixed64,3,opt,name=rate,proto3" json:"rate,omitempty"` - InverseRate float64 `protobuf:"fixed64,4,opt,name=inverse_rate,json=inverseRate,proto3" json:"inverse_rate,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"` + To string `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"` + Rate float64 `protobuf:"fixed64,3,opt,name=rate,proto3" json:"rate,omitempty"` + InverseRate float64 `protobuf:"fixed64,4,opt,name=inverse_rate,json=inverseRate,proto3" json:"inverse_rate,omitempty"` } -func (m *ForexRatesConversion) Reset() { *m = ForexRatesConversion{} } -func (m *ForexRatesConversion) String() string { return proto.CompactTextString(m) } -func (*ForexRatesConversion) ProtoMessage() {} +func (x *ForexRatesConversion) Reset() { + *x = ForexRatesConversion{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[54] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ForexRatesConversion) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ForexRatesConversion) ProtoMessage() {} + +func (x *ForexRatesConversion) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[54] + 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 ForexRatesConversion.ProtoReflect.Descriptor instead. func (*ForexRatesConversion) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{54} + return file_rpc_proto_rawDescGZIP(), []int{54} } -func (m *ForexRatesConversion) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ForexRatesConversion.Unmarshal(m, b) -} -func (m *ForexRatesConversion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ForexRatesConversion.Marshal(b, m, deterministic) -} -func (m *ForexRatesConversion) XXX_Merge(src proto.Message) { - xxx_messageInfo_ForexRatesConversion.Merge(m, src) -} -func (m *ForexRatesConversion) XXX_Size() int { - return xxx_messageInfo_ForexRatesConversion.Size(m) -} -func (m *ForexRatesConversion) XXX_DiscardUnknown() { - xxx_messageInfo_ForexRatesConversion.DiscardUnknown(m) -} - -var xxx_messageInfo_ForexRatesConversion proto.InternalMessageInfo - -func (m *ForexRatesConversion) GetFrom() string { - if m != nil { - return m.From +func (x *ForexRatesConversion) GetFrom() string { + if x != nil { + return x.From } return "" } -func (m *ForexRatesConversion) GetTo() string { - if m != nil { - return m.To +func (x *ForexRatesConversion) GetTo() string { + if x != nil { + return x.To } return "" } -func (m *ForexRatesConversion) GetRate() float64 { - if m != nil { - return m.Rate +func (x *ForexRatesConversion) GetRate() float64 { + if x != nil { + return x.Rate } return 0 } -func (m *ForexRatesConversion) GetInverseRate() float64 { - if m != nil { - return m.InverseRate +func (x *ForexRatesConversion) GetInverseRate() float64 { + if x != nil { + return x.InverseRate } return 0 } type GetForexRatesResponse struct { - ForexRates []*ForexRatesConversion `protobuf:"bytes,1,rep,name=forex_rates,json=forexRates,proto3" json:"forex_rates,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ForexRates []*ForexRatesConversion `protobuf:"bytes,1,rep,name=forex_rates,json=forexRates,proto3" json:"forex_rates,omitempty"` } -func (m *GetForexRatesResponse) Reset() { *m = GetForexRatesResponse{} } -func (m *GetForexRatesResponse) String() string { return proto.CompactTextString(m) } -func (*GetForexRatesResponse) ProtoMessage() {} +func (x *GetForexRatesResponse) Reset() { + *x = GetForexRatesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[55] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetForexRatesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetForexRatesResponse) ProtoMessage() {} + +func (x *GetForexRatesResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[55] + 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 GetForexRatesResponse.ProtoReflect.Descriptor instead. func (*GetForexRatesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{55} + return file_rpc_proto_rawDescGZIP(), []int{55} } -func (m *GetForexRatesResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetForexRatesResponse.Unmarshal(m, b) -} -func (m *GetForexRatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetForexRatesResponse.Marshal(b, m, deterministic) -} -func (m *GetForexRatesResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetForexRatesResponse.Merge(m, src) -} -func (m *GetForexRatesResponse) XXX_Size() int { - return xxx_messageInfo_GetForexRatesResponse.Size(m) -} -func (m *GetForexRatesResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetForexRatesResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetForexRatesResponse proto.InternalMessageInfo - -func (m *GetForexRatesResponse) GetForexRates() []*ForexRatesConversion { - if m != nil { - return m.ForexRates +func (x *GetForexRatesResponse) GetForexRates() []*ForexRatesConversion { + if x != nil { + return x.ForexRates } return nil } type OrderDetails struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` - BaseCurrency string `protobuf:"bytes,3,opt,name=base_currency,json=baseCurrency,proto3" json:"base_currency,omitempty"` - QuoteCurrency string `protobuf:"bytes,4,opt,name=quote_currency,json=quoteCurrency,proto3" json:"quote_currency,omitempty"` - AssetType string `protobuf:"bytes,5,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` - OrderSide string `protobuf:"bytes,6,opt,name=order_side,json=orderSide,proto3" json:"order_side,omitempty"` - OrderType string `protobuf:"bytes,7,opt,name=order_type,json=orderType,proto3" json:"order_type,omitempty"` - CreationTime int64 `protobuf:"varint,8,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"` - Status string `protobuf:"bytes,9,opt,name=status,proto3" json:"status,omitempty"` - Price float64 `protobuf:"fixed64,10,opt,name=price,proto3" json:"price,omitempty"` - Amount float64 `protobuf:"fixed64,11,opt,name=amount,proto3" json:"amount,omitempty"` - OpenVolume float64 `protobuf:"fixed64,12,opt,name=open_volume,json=openVolume,proto3" json:"open_volume,omitempty"` - Fee float64 `protobuf:"fixed64,13,opt,name=fee,proto3" json:"fee,omitempty"` - Trades []*TradeHistory `protobuf:"bytes,14,rep,name=trades,proto3" json:"trades,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + BaseCurrency string `protobuf:"bytes,3,opt,name=base_currency,json=baseCurrency,proto3" json:"base_currency,omitempty"` + QuoteCurrency string `protobuf:"bytes,4,opt,name=quote_currency,json=quoteCurrency,proto3" json:"quote_currency,omitempty"` + AssetType string `protobuf:"bytes,5,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + OrderSide string `protobuf:"bytes,6,opt,name=order_side,json=orderSide,proto3" json:"order_side,omitempty"` + OrderType string `protobuf:"bytes,7,opt,name=order_type,json=orderType,proto3" json:"order_type,omitempty"` + CreationTime int64 `protobuf:"varint,8,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"` + Status string `protobuf:"bytes,9,opt,name=status,proto3" json:"status,omitempty"` + Price float64 `protobuf:"fixed64,10,opt,name=price,proto3" json:"price,omitempty"` + Amount float64 `protobuf:"fixed64,11,opt,name=amount,proto3" json:"amount,omitempty"` + OpenVolume float64 `protobuf:"fixed64,12,opt,name=open_volume,json=openVolume,proto3" json:"open_volume,omitempty"` + Fee float64 `protobuf:"fixed64,13,opt,name=fee,proto3" json:"fee,omitempty"` + Trades []*TradeHistory `protobuf:"bytes,14,rep,name=trades,proto3" json:"trades,omitempty"` } -func (m *OrderDetails) Reset() { *m = OrderDetails{} } -func (m *OrderDetails) String() string { return proto.CompactTextString(m) } -func (*OrderDetails) ProtoMessage() {} +func (x *OrderDetails) Reset() { + *x = OrderDetails{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[56] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OrderDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OrderDetails) ProtoMessage() {} + +func (x *OrderDetails) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[56] + 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 OrderDetails.ProtoReflect.Descriptor instead. func (*OrderDetails) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{56} + return file_rpc_proto_rawDescGZIP(), []int{56} } -func (m *OrderDetails) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OrderDetails.Unmarshal(m, b) -} -func (m *OrderDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OrderDetails.Marshal(b, m, deterministic) -} -func (m *OrderDetails) XXX_Merge(src proto.Message) { - xxx_messageInfo_OrderDetails.Merge(m, src) -} -func (m *OrderDetails) XXX_Size() int { - return xxx_messageInfo_OrderDetails.Size(m) -} -func (m *OrderDetails) XXX_DiscardUnknown() { - xxx_messageInfo_OrderDetails.DiscardUnknown(m) -} - -var xxx_messageInfo_OrderDetails proto.InternalMessageInfo - -func (m *OrderDetails) GetExchange() string { - if m != nil { - return m.Exchange +func (x *OrderDetails) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *OrderDetails) GetId() string { - if m != nil { - return m.Id +func (x *OrderDetails) GetId() string { + if x != nil { + return x.Id } return "" } -func (m *OrderDetails) GetBaseCurrency() string { - if m != nil { - return m.BaseCurrency +func (x *OrderDetails) GetBaseCurrency() string { + if x != nil { + return x.BaseCurrency } return "" } -func (m *OrderDetails) GetQuoteCurrency() string { - if m != nil { - return m.QuoteCurrency +func (x *OrderDetails) GetQuoteCurrency() string { + if x != nil { + return x.QuoteCurrency } return "" } -func (m *OrderDetails) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *OrderDetails) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } -func (m *OrderDetails) GetOrderSide() string { - if m != nil { - return m.OrderSide +func (x *OrderDetails) GetOrderSide() string { + if x != nil { + return x.OrderSide } return "" } -func (m *OrderDetails) GetOrderType() string { - if m != nil { - return m.OrderType +func (x *OrderDetails) GetOrderType() string { + if x != nil { + return x.OrderType } return "" } -func (m *OrderDetails) GetCreationTime() int64 { - if m != nil { - return m.CreationTime +func (x *OrderDetails) GetCreationTime() int64 { + if x != nil { + return x.CreationTime } return 0 } -func (m *OrderDetails) GetStatus() string { - if m != nil { - return m.Status +func (x *OrderDetails) GetStatus() string { + if x != nil { + return x.Status } return "" } -func (m *OrderDetails) GetPrice() float64 { - if m != nil { - return m.Price +func (x *OrderDetails) GetPrice() float64 { + if x != nil { + return x.Price } return 0 } -func (m *OrderDetails) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *OrderDetails) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *OrderDetails) GetOpenVolume() float64 { - if m != nil { - return m.OpenVolume +func (x *OrderDetails) GetOpenVolume() float64 { + if x != nil { + return x.OpenVolume } return 0 } -func (m *OrderDetails) GetFee() float64 { - if m != nil { - return m.Fee +func (x *OrderDetails) GetFee() float64 { + if x != nil { + return x.Fee } return 0 } -func (m *OrderDetails) GetTrades() []*TradeHistory { - if m != nil { - return m.Trades +func (x *OrderDetails) GetTrades() []*TradeHistory { + if x != nil { + return x.Trades } return nil } type TradeHistory struct { - CreationTime int64 `protobuf:"varint,1,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"` - Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` - Price float64 `protobuf:"fixed64,3,opt,name=price,proto3" json:"price,omitempty"` - Amount float64 `protobuf:"fixed64,4,opt,name=amount,proto3" json:"amount,omitempty"` - Exchange string `protobuf:"bytes,5,opt,name=exchange,proto3" json:"exchange,omitempty"` - AssetType string `protobuf:"bytes,6,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` - OrderSide string `protobuf:"bytes,7,opt,name=order_side,json=orderSide,proto3" json:"order_side,omitempty"` - Fee float64 `protobuf:"fixed64,8,opt,name=fee,proto3" json:"fee,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CreationTime int64 `protobuf:"varint,1,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"` + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + Price float64 `protobuf:"fixed64,3,opt,name=price,proto3" json:"price,omitempty"` + Amount float64 `protobuf:"fixed64,4,opt,name=amount,proto3" json:"amount,omitempty"` + Exchange string `protobuf:"bytes,5,opt,name=exchange,proto3" json:"exchange,omitempty"` + AssetType string `protobuf:"bytes,6,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + OrderSide string `protobuf:"bytes,7,opt,name=order_side,json=orderSide,proto3" json:"order_side,omitempty"` + Fee float64 `protobuf:"fixed64,8,opt,name=fee,proto3" json:"fee,omitempty"` } -func (m *TradeHistory) Reset() { *m = TradeHistory{} } -func (m *TradeHistory) String() string { return proto.CompactTextString(m) } -func (*TradeHistory) ProtoMessage() {} +func (x *TradeHistory) Reset() { + *x = TradeHistory{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[57] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TradeHistory) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TradeHistory) ProtoMessage() {} + +func (x *TradeHistory) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[57] + 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 TradeHistory.ProtoReflect.Descriptor instead. func (*TradeHistory) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{57} + return file_rpc_proto_rawDescGZIP(), []int{57} } -func (m *TradeHistory) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_TradeHistory.Unmarshal(m, b) -} -func (m *TradeHistory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_TradeHistory.Marshal(b, m, deterministic) -} -func (m *TradeHistory) XXX_Merge(src proto.Message) { - xxx_messageInfo_TradeHistory.Merge(m, src) -} -func (m *TradeHistory) XXX_Size() int { - return xxx_messageInfo_TradeHistory.Size(m) -} -func (m *TradeHistory) XXX_DiscardUnknown() { - xxx_messageInfo_TradeHistory.DiscardUnknown(m) -} - -var xxx_messageInfo_TradeHistory proto.InternalMessageInfo - -func (m *TradeHistory) GetCreationTime() int64 { - if m != nil { - return m.CreationTime +func (x *TradeHistory) GetCreationTime() int64 { + if x != nil { + return x.CreationTime } return 0 } -func (m *TradeHistory) GetId() string { - if m != nil { - return m.Id +func (x *TradeHistory) GetId() string { + if x != nil { + return x.Id } return "" } -func (m *TradeHistory) GetPrice() float64 { - if m != nil { - return m.Price +func (x *TradeHistory) GetPrice() float64 { + if x != nil { + return x.Price } return 0 } -func (m *TradeHistory) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *TradeHistory) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *TradeHistory) GetExchange() string { - if m != nil { - return m.Exchange +func (x *TradeHistory) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *TradeHistory) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *TradeHistory) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } -func (m *TradeHistory) GetOrderSide() string { - if m != nil { - return m.OrderSide +func (x *TradeHistory) GetOrderSide() string { + if x != nil { + return x.OrderSide } return "" } -func (m *TradeHistory) GetFee() float64 { - if m != nil { - return m.Fee +func (x *TradeHistory) GetFee() float64 { + if x != nil { + return x.Fee } return 0 } type GetOrdersRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - AssetType string `protobuf:"bytes,2,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + AssetType string `protobuf:"bytes,2,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,3,opt,name=pair,proto3" json:"pair,omitempty"` } -func (m *GetOrdersRequest) Reset() { *m = GetOrdersRequest{} } -func (m *GetOrdersRequest) String() string { return proto.CompactTextString(m) } -func (*GetOrdersRequest) ProtoMessage() {} +func (x *GetOrdersRequest) Reset() { + *x = GetOrdersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[58] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrdersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrdersRequest) ProtoMessage() {} + +func (x *GetOrdersRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[58] + 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 GetOrdersRequest.ProtoReflect.Descriptor instead. func (*GetOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{58} + return file_rpc_proto_rawDescGZIP(), []int{58} } -func (m *GetOrdersRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetOrdersRequest.Unmarshal(m, b) -} -func (m *GetOrdersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetOrdersRequest.Marshal(b, m, deterministic) -} -func (m *GetOrdersRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOrdersRequest.Merge(m, src) -} -func (m *GetOrdersRequest) XXX_Size() int { - return xxx_messageInfo_GetOrdersRequest.Size(m) -} -func (m *GetOrdersRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetOrdersRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetOrdersRequest proto.InternalMessageInfo - -func (m *GetOrdersRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetOrdersRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetOrdersRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *GetOrdersRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } -func (m *GetOrdersRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *GetOrdersRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } type GetOrdersResponse struct { - Orders []*OrderDetails `protobuf:"bytes,1,rep,name=orders,proto3" json:"orders,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Orders []*OrderDetails `protobuf:"bytes,1,rep,name=orders,proto3" json:"orders,omitempty"` } -func (m *GetOrdersResponse) Reset() { *m = GetOrdersResponse{} } -func (m *GetOrdersResponse) String() string { return proto.CompactTextString(m) } -func (*GetOrdersResponse) ProtoMessage() {} +func (x *GetOrdersResponse) Reset() { + *x = GetOrdersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[59] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrdersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrdersResponse) ProtoMessage() {} + +func (x *GetOrdersResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[59] + 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 GetOrdersResponse.ProtoReflect.Descriptor instead. func (*GetOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{59} + return file_rpc_proto_rawDescGZIP(), []int{59} } -func (m *GetOrdersResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetOrdersResponse.Unmarshal(m, b) -} -func (m *GetOrdersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetOrdersResponse.Marshal(b, m, deterministic) -} -func (m *GetOrdersResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOrdersResponse.Merge(m, src) -} -func (m *GetOrdersResponse) XXX_Size() int { - return xxx_messageInfo_GetOrdersResponse.Size(m) -} -func (m *GetOrdersResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetOrdersResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetOrdersResponse proto.InternalMessageInfo - -func (m *GetOrdersResponse) GetOrders() []*OrderDetails { - if m != nil { - return m.Orders +func (x *GetOrdersResponse) GetOrders() []*OrderDetails { + if x != nil { + return x.Orders } return nil } type GetOrderRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - OrderId string `protobuf:"bytes,2,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + OrderId string `protobuf:"bytes,2,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` } -func (m *GetOrderRequest) Reset() { *m = GetOrderRequest{} } -func (m *GetOrderRequest) String() string { return proto.CompactTextString(m) } -func (*GetOrderRequest) ProtoMessage() {} +func (x *GetOrderRequest) Reset() { + *x = GetOrderRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[60] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderRequest) ProtoMessage() {} + +func (x *GetOrderRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[60] + 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 GetOrderRequest.ProtoReflect.Descriptor instead. func (*GetOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{60} + return file_rpc_proto_rawDescGZIP(), []int{60} } -func (m *GetOrderRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetOrderRequest.Unmarshal(m, b) -} -func (m *GetOrderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetOrderRequest.Marshal(b, m, deterministic) -} -func (m *GetOrderRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOrderRequest.Merge(m, src) -} -func (m *GetOrderRequest) XXX_Size() int { - return xxx_messageInfo_GetOrderRequest.Size(m) -} -func (m *GetOrderRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetOrderRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetOrderRequest proto.InternalMessageInfo - -func (m *GetOrderRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetOrderRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetOrderRequest) GetOrderId() string { - if m != nil { - return m.OrderId +func (x *GetOrderRequest) GetOrderId() string { + if x != nil { + return x.OrderId } return "" } type SubmitOrderRequest struct { - 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"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` + 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"` } -func (m *SubmitOrderRequest) Reset() { *m = SubmitOrderRequest{} } -func (m *SubmitOrderRequest) String() string { return proto.CompactTextString(m) } -func (*SubmitOrderRequest) ProtoMessage() {} +func (x *SubmitOrderRequest) Reset() { + *x = SubmitOrderRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[61] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SubmitOrderRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubmitOrderRequest) ProtoMessage() {} + +func (x *SubmitOrderRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[61] + 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 SubmitOrderRequest.ProtoReflect.Descriptor instead. func (*SubmitOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{61} + return file_rpc_proto_rawDescGZIP(), []int{61} } -func (m *SubmitOrderRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SubmitOrderRequest.Unmarshal(m, b) -} -func (m *SubmitOrderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SubmitOrderRequest.Marshal(b, m, deterministic) -} -func (m *SubmitOrderRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SubmitOrderRequest.Merge(m, src) -} -func (m *SubmitOrderRequest) XXX_Size() int { - return xxx_messageInfo_SubmitOrderRequest.Size(m) -} -func (m *SubmitOrderRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SubmitOrderRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_SubmitOrderRequest proto.InternalMessageInfo - -func (m *SubmitOrderRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *SubmitOrderRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *SubmitOrderRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *SubmitOrderRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *SubmitOrderRequest) GetSide() string { - if m != nil { - return m.Side +func (x *SubmitOrderRequest) GetSide() string { + if x != nil { + return x.Side } return "" } -func (m *SubmitOrderRequest) GetOrderType() string { - if m != nil { - return m.OrderType +func (x *SubmitOrderRequest) GetOrderType() string { + if x != nil { + return x.OrderType } return "" } -func (m *SubmitOrderRequest) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *SubmitOrderRequest) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *SubmitOrderRequest) GetPrice() float64 { - if m != nil { - return m.Price +func (x *SubmitOrderRequest) GetPrice() float64 { + if x != nil { + return x.Price } return 0 } -func (m *SubmitOrderRequest) GetClientId() string { - if m != nil { - return m.ClientId +func (x *SubmitOrderRequest) GetClientId() string { + if x != nil { + return x.ClientId } return "" } type SubmitOrderResponse struct { - OrderPlaced bool `protobuf:"varint,1,opt,name=order_placed,json=orderPlaced,proto3" json:"order_placed,omitempty"` - OrderId string `protobuf:"bytes,2,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OrderPlaced bool `protobuf:"varint,1,opt,name=order_placed,json=orderPlaced,proto3" json:"order_placed,omitempty"` + OrderId string `protobuf:"bytes,2,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` } -func (m *SubmitOrderResponse) Reset() { *m = SubmitOrderResponse{} } -func (m *SubmitOrderResponse) String() string { return proto.CompactTextString(m) } -func (*SubmitOrderResponse) ProtoMessage() {} +func (x *SubmitOrderResponse) Reset() { + *x = SubmitOrderResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[62] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SubmitOrderResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubmitOrderResponse) ProtoMessage() {} + +func (x *SubmitOrderResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[62] + 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 SubmitOrderResponse.ProtoReflect.Descriptor instead. func (*SubmitOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{62} + return file_rpc_proto_rawDescGZIP(), []int{62} } -func (m *SubmitOrderResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SubmitOrderResponse.Unmarshal(m, b) -} -func (m *SubmitOrderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SubmitOrderResponse.Marshal(b, m, deterministic) -} -func (m *SubmitOrderResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SubmitOrderResponse.Merge(m, src) -} -func (m *SubmitOrderResponse) XXX_Size() int { - return xxx_messageInfo_SubmitOrderResponse.Size(m) -} -func (m *SubmitOrderResponse) XXX_DiscardUnknown() { - xxx_messageInfo_SubmitOrderResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_SubmitOrderResponse proto.InternalMessageInfo - -func (m *SubmitOrderResponse) GetOrderPlaced() bool { - if m != nil { - return m.OrderPlaced +func (x *SubmitOrderResponse) GetOrderPlaced() bool { + if x != nil { + return x.OrderPlaced } return false } -func (m *SubmitOrderResponse) GetOrderId() string { - if m != nil { - return m.OrderId +func (x *SubmitOrderResponse) GetOrderId() string { + if x != nil { + return x.OrderId } return "" } type SimulateOrderRequest struct { - 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"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` + Amount float64 `protobuf:"fixed64,3,opt,name=amount,proto3" json:"amount,omitempty"` + Side string `protobuf:"bytes,4,opt,name=side,proto3" json:"side,omitempty"` } -func (m *SimulateOrderRequest) Reset() { *m = SimulateOrderRequest{} } -func (m *SimulateOrderRequest) String() string { return proto.CompactTextString(m) } -func (*SimulateOrderRequest) ProtoMessage() {} +func (x *SimulateOrderRequest) Reset() { + *x = SimulateOrderRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[63] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SimulateOrderRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SimulateOrderRequest) ProtoMessage() {} + +func (x *SimulateOrderRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[63] + 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 SimulateOrderRequest.ProtoReflect.Descriptor instead. func (*SimulateOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{63} + return file_rpc_proto_rawDescGZIP(), []int{63} } -func (m *SimulateOrderRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SimulateOrderRequest.Unmarshal(m, b) -} -func (m *SimulateOrderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SimulateOrderRequest.Marshal(b, m, deterministic) -} -func (m *SimulateOrderRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SimulateOrderRequest.Merge(m, src) -} -func (m *SimulateOrderRequest) XXX_Size() int { - return xxx_messageInfo_SimulateOrderRequest.Size(m) -} -func (m *SimulateOrderRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SimulateOrderRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_SimulateOrderRequest proto.InternalMessageInfo - -func (m *SimulateOrderRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *SimulateOrderRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *SimulateOrderRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *SimulateOrderRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *SimulateOrderRequest) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *SimulateOrderRequest) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *SimulateOrderRequest) GetSide() string { - if m != nil { - return m.Side +func (x *SimulateOrderRequest) GetSide() string { + if x != nil { + return x.Side } return "" } type SimulateOrderResponse struct { - Orders []*OrderbookItem `protobuf:"bytes,1,rep,name=orders,proto3" json:"orders,omitempty"` - Amount float64 `protobuf:"fixed64,2,opt,name=amount,proto3" json:"amount,omitempty"` - MinimumPrice float64 `protobuf:"fixed64,3,opt,name=minimum_price,json=minimumPrice,proto3" json:"minimum_price,omitempty"` - MaximumPrice float64 `protobuf:"fixed64,4,opt,name=maximum_price,json=maximumPrice,proto3" json:"maximum_price,omitempty"` - PercentageGainLoss float64 `protobuf:"fixed64,5,opt,name=percentage_gain_loss,json=percentageGainLoss,proto3" json:"percentage_gain_loss,omitempty"` - Status string `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Orders []*OrderbookItem `protobuf:"bytes,1,rep,name=orders,proto3" json:"orders,omitempty"` + Amount float64 `protobuf:"fixed64,2,opt,name=amount,proto3" json:"amount,omitempty"` + MinimumPrice float64 `protobuf:"fixed64,3,opt,name=minimum_price,json=minimumPrice,proto3" json:"minimum_price,omitempty"` + MaximumPrice float64 `protobuf:"fixed64,4,opt,name=maximum_price,json=maximumPrice,proto3" json:"maximum_price,omitempty"` + PercentageGainLoss float64 `protobuf:"fixed64,5,opt,name=percentage_gain_loss,json=percentageGainLoss,proto3" json:"percentage_gain_loss,omitempty"` + Status string `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"` } -func (m *SimulateOrderResponse) Reset() { *m = SimulateOrderResponse{} } -func (m *SimulateOrderResponse) String() string { return proto.CompactTextString(m) } -func (*SimulateOrderResponse) ProtoMessage() {} +func (x *SimulateOrderResponse) Reset() { + *x = SimulateOrderResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[64] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SimulateOrderResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SimulateOrderResponse) ProtoMessage() {} + +func (x *SimulateOrderResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[64] + 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 SimulateOrderResponse.ProtoReflect.Descriptor instead. func (*SimulateOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{64} + return file_rpc_proto_rawDescGZIP(), []int{64} } -func (m *SimulateOrderResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SimulateOrderResponse.Unmarshal(m, b) -} -func (m *SimulateOrderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SimulateOrderResponse.Marshal(b, m, deterministic) -} -func (m *SimulateOrderResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SimulateOrderResponse.Merge(m, src) -} -func (m *SimulateOrderResponse) XXX_Size() int { - return xxx_messageInfo_SimulateOrderResponse.Size(m) -} -func (m *SimulateOrderResponse) XXX_DiscardUnknown() { - xxx_messageInfo_SimulateOrderResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_SimulateOrderResponse proto.InternalMessageInfo - -func (m *SimulateOrderResponse) GetOrders() []*OrderbookItem { - if m != nil { - return m.Orders +func (x *SimulateOrderResponse) GetOrders() []*OrderbookItem { + if x != nil { + return x.Orders } return nil } -func (m *SimulateOrderResponse) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *SimulateOrderResponse) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *SimulateOrderResponse) GetMinimumPrice() float64 { - if m != nil { - return m.MinimumPrice +func (x *SimulateOrderResponse) GetMinimumPrice() float64 { + if x != nil { + return x.MinimumPrice } return 0 } -func (m *SimulateOrderResponse) GetMaximumPrice() float64 { - if m != nil { - return m.MaximumPrice +func (x *SimulateOrderResponse) GetMaximumPrice() float64 { + if x != nil { + return x.MaximumPrice } return 0 } -func (m *SimulateOrderResponse) GetPercentageGainLoss() float64 { - if m != nil { - return m.PercentageGainLoss +func (x *SimulateOrderResponse) GetPercentageGainLoss() float64 { + if x != nil { + return x.PercentageGainLoss } return 0 } -func (m *SimulateOrderResponse) GetStatus() string { - if m != nil { - return m.Status +func (x *SimulateOrderResponse) GetStatus() string { + if x != nil { + return x.Status } return "" } type WhaleBombRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` - PriceTarget float64 `protobuf:"fixed64,3,opt,name=price_target,json=priceTarget,proto3" json:"price_target,omitempty"` - Side string `protobuf:"bytes,4,opt,name=side,proto3" json:"side,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` + PriceTarget float64 `protobuf:"fixed64,3,opt,name=price_target,json=priceTarget,proto3" json:"price_target,omitempty"` + Side string `protobuf:"bytes,4,opt,name=side,proto3" json:"side,omitempty"` } -func (m *WhaleBombRequest) Reset() { *m = WhaleBombRequest{} } -func (m *WhaleBombRequest) String() string { return proto.CompactTextString(m) } -func (*WhaleBombRequest) ProtoMessage() {} +func (x *WhaleBombRequest) Reset() { + *x = WhaleBombRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[65] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WhaleBombRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WhaleBombRequest) ProtoMessage() {} + +func (x *WhaleBombRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[65] + 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 WhaleBombRequest.ProtoReflect.Descriptor instead. func (*WhaleBombRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{65} + return file_rpc_proto_rawDescGZIP(), []int{65} } -func (m *WhaleBombRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WhaleBombRequest.Unmarshal(m, b) -} -func (m *WhaleBombRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WhaleBombRequest.Marshal(b, m, deterministic) -} -func (m *WhaleBombRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WhaleBombRequest.Merge(m, src) -} -func (m *WhaleBombRequest) XXX_Size() int { - return xxx_messageInfo_WhaleBombRequest.Size(m) -} -func (m *WhaleBombRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WhaleBombRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WhaleBombRequest proto.InternalMessageInfo - -func (m *WhaleBombRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WhaleBombRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WhaleBombRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *WhaleBombRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *WhaleBombRequest) GetPriceTarget() float64 { - if m != nil { - return m.PriceTarget +func (x *WhaleBombRequest) GetPriceTarget() float64 { + if x != nil { + return x.PriceTarget } return 0 } -func (m *WhaleBombRequest) GetSide() string { - if m != nil { - return m.Side +func (x *WhaleBombRequest) GetSide() string { + if x != nil { + return x.Side } return "" } type CancelOrderRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - AccountId string `protobuf:"bytes,2,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"` - OrderId string `protobuf:"bytes,3,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,4,opt,name=pair,proto3" json:"pair,omitempty"` - AssetType string `protobuf:"bytes,5,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` - WalletAddress string `protobuf:"bytes,6,opt,name=wallet_address,json=walletAddress,proto3" json:"wallet_address,omitempty"` - Side string `protobuf:"bytes,7,opt,name=side,proto3" json:"side,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + AccountId string `protobuf:"bytes,2,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"` + OrderId string `protobuf:"bytes,3,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,4,opt,name=pair,proto3" json:"pair,omitempty"` + AssetType string `protobuf:"bytes,5,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + WalletAddress string `protobuf:"bytes,6,opt,name=wallet_address,json=walletAddress,proto3" json:"wallet_address,omitempty"` + Side string `protobuf:"bytes,7,opt,name=side,proto3" json:"side,omitempty"` } -func (m *CancelOrderRequest) Reset() { *m = CancelOrderRequest{} } -func (m *CancelOrderRequest) String() string { return proto.CompactTextString(m) } -func (*CancelOrderRequest) ProtoMessage() {} +func (x *CancelOrderRequest) Reset() { + *x = CancelOrderRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[66] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CancelOrderRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CancelOrderRequest) ProtoMessage() {} + +func (x *CancelOrderRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[66] + 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 CancelOrderRequest.ProtoReflect.Descriptor instead. func (*CancelOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{66} + return file_rpc_proto_rawDescGZIP(), []int{66} } -func (m *CancelOrderRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_CancelOrderRequest.Unmarshal(m, b) -} -func (m *CancelOrderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_CancelOrderRequest.Marshal(b, m, deterministic) -} -func (m *CancelOrderRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_CancelOrderRequest.Merge(m, src) -} -func (m *CancelOrderRequest) XXX_Size() int { - return xxx_messageInfo_CancelOrderRequest.Size(m) -} -func (m *CancelOrderRequest) XXX_DiscardUnknown() { - xxx_messageInfo_CancelOrderRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_CancelOrderRequest proto.InternalMessageInfo - -func (m *CancelOrderRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *CancelOrderRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *CancelOrderRequest) GetAccountId() string { - if m != nil { - return m.AccountId +func (x *CancelOrderRequest) GetAccountId() string { + if x != nil { + return x.AccountId } return "" } -func (m *CancelOrderRequest) GetOrderId() string { - if m != nil { - return m.OrderId +func (x *CancelOrderRequest) GetOrderId() string { + if x != nil { + return x.OrderId } return "" } -func (m *CancelOrderRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *CancelOrderRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *CancelOrderRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *CancelOrderRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } -func (m *CancelOrderRequest) GetWalletAddress() string { - if m != nil { - return m.WalletAddress +func (x *CancelOrderRequest) GetWalletAddress() string { + if x != nil { + return x.WalletAddress } return "" } -func (m *CancelOrderRequest) GetSide() string { - if m != nil { - return m.Side +func (x *CancelOrderRequest) GetSide() string { + if x != nil { + return x.Side } return "" } type CancelAllOrdersRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *CancelAllOrdersRequest) Reset() { *m = CancelAllOrdersRequest{} } -func (m *CancelAllOrdersRequest) String() string { return proto.CompactTextString(m) } -func (*CancelAllOrdersRequest) ProtoMessage() {} +func (x *CancelAllOrdersRequest) Reset() { + *x = CancelAllOrdersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[67] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CancelAllOrdersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CancelAllOrdersRequest) ProtoMessage() {} + +func (x *CancelAllOrdersRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[67] + 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 CancelAllOrdersRequest.ProtoReflect.Descriptor instead. func (*CancelAllOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{67} + return file_rpc_proto_rawDescGZIP(), []int{67} } -func (m *CancelAllOrdersRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_CancelAllOrdersRequest.Unmarshal(m, b) -} -func (m *CancelAllOrdersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_CancelAllOrdersRequest.Marshal(b, m, deterministic) -} -func (m *CancelAllOrdersRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_CancelAllOrdersRequest.Merge(m, src) -} -func (m *CancelAllOrdersRequest) XXX_Size() int { - return xxx_messageInfo_CancelAllOrdersRequest.Size(m) -} -func (m *CancelAllOrdersRequest) XXX_DiscardUnknown() { - xxx_messageInfo_CancelAllOrdersRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_CancelAllOrdersRequest proto.InternalMessageInfo - -func (m *CancelAllOrdersRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *CancelAllOrdersRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type CancelAllOrdersResponse struct { - Orders []*CancelAllOrdersResponse_Orders `protobuf:"bytes,1,rep,name=orders,proto3" json:"orders,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Orders []*CancelAllOrdersResponse_Orders `protobuf:"bytes,1,rep,name=orders,proto3" json:"orders,omitempty"` } -func (m *CancelAllOrdersResponse) Reset() { *m = CancelAllOrdersResponse{} } -func (m *CancelAllOrdersResponse) String() string { return proto.CompactTextString(m) } -func (*CancelAllOrdersResponse) ProtoMessage() {} +func (x *CancelAllOrdersResponse) Reset() { + *x = CancelAllOrdersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[68] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CancelAllOrdersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CancelAllOrdersResponse) ProtoMessage() {} + +func (x *CancelAllOrdersResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[68] + 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 CancelAllOrdersResponse.ProtoReflect.Descriptor instead. func (*CancelAllOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{68} + return file_rpc_proto_rawDescGZIP(), []int{68} } -func (m *CancelAllOrdersResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_CancelAllOrdersResponse.Unmarshal(m, b) -} -func (m *CancelAllOrdersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_CancelAllOrdersResponse.Marshal(b, m, deterministic) -} -func (m *CancelAllOrdersResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_CancelAllOrdersResponse.Merge(m, src) -} -func (m *CancelAllOrdersResponse) XXX_Size() int { - return xxx_messageInfo_CancelAllOrdersResponse.Size(m) -} -func (m *CancelAllOrdersResponse) XXX_DiscardUnknown() { - xxx_messageInfo_CancelAllOrdersResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_CancelAllOrdersResponse proto.InternalMessageInfo - -func (m *CancelAllOrdersResponse) GetOrders() []*CancelAllOrdersResponse_Orders { - if m != nil { - return m.Orders - } - return nil -} - -type CancelAllOrdersResponse_Orders struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - OrderStatus map[string]string `protobuf:"bytes,2,rep,name=order_status,json=orderStatus,proto3" json:"order_status,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *CancelAllOrdersResponse_Orders) Reset() { *m = CancelAllOrdersResponse_Orders{} } -func (m *CancelAllOrdersResponse_Orders) String() string { return proto.CompactTextString(m) } -func (*CancelAllOrdersResponse_Orders) ProtoMessage() {} -func (*CancelAllOrdersResponse_Orders) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{68, 0} -} - -func (m *CancelAllOrdersResponse_Orders) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_CancelAllOrdersResponse_Orders.Unmarshal(m, b) -} -func (m *CancelAllOrdersResponse_Orders) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_CancelAllOrdersResponse_Orders.Marshal(b, m, deterministic) -} -func (m *CancelAllOrdersResponse_Orders) XXX_Merge(src proto.Message) { - xxx_messageInfo_CancelAllOrdersResponse_Orders.Merge(m, src) -} -func (m *CancelAllOrdersResponse_Orders) XXX_Size() int { - return xxx_messageInfo_CancelAllOrdersResponse_Orders.Size(m) -} -func (m *CancelAllOrdersResponse_Orders) XXX_DiscardUnknown() { - xxx_messageInfo_CancelAllOrdersResponse_Orders.DiscardUnknown(m) -} - -var xxx_messageInfo_CancelAllOrdersResponse_Orders proto.InternalMessageInfo - -func (m *CancelAllOrdersResponse_Orders) GetExchange() string { - if m != nil { - return m.Exchange - } - return "" -} - -func (m *CancelAllOrdersResponse_Orders) GetOrderStatus() map[string]string { - if m != nil { - return m.OrderStatus +func (x *CancelAllOrdersResponse) GetOrders() []*CancelAllOrdersResponse_Orders { + if x != nil { + return x.Orders } return nil } type GetEventsRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetEventsRequest) Reset() { *m = GetEventsRequest{} } -func (m *GetEventsRequest) String() string { return proto.CompactTextString(m) } -func (*GetEventsRequest) ProtoMessage() {} +func (x *GetEventsRequest) Reset() { + *x = GetEventsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[69] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetEventsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetEventsRequest) ProtoMessage() {} + +func (x *GetEventsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[69] + 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 GetEventsRequest.ProtoReflect.Descriptor instead. func (*GetEventsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{69} + return file_rpc_proto_rawDescGZIP(), []int{69} } -func (m *GetEventsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetEventsRequest.Unmarshal(m, b) -} -func (m *GetEventsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetEventsRequest.Marshal(b, m, deterministic) -} -func (m *GetEventsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetEventsRequest.Merge(m, src) -} -func (m *GetEventsRequest) XXX_Size() int { - return xxx_messageInfo_GetEventsRequest.Size(m) -} -func (m *GetEventsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetEventsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetEventsRequest proto.InternalMessageInfo - type ConditionParams struct { - Condition string `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"` - Price float64 `protobuf:"fixed64,2,opt,name=price,proto3" json:"price,omitempty"` - CheckBids bool `protobuf:"varint,3,opt,name=check_bids,json=checkBids,proto3" json:"check_bids,omitempty"` - CheckBidsAndAsks bool `protobuf:"varint,4,opt,name=check_bids_and_asks,json=checkBidsAndAsks,proto3" json:"check_bids_and_asks,omitempty"` - OrderbookAmount float64 `protobuf:"fixed64,5,opt,name=orderbook_amount,json=orderbookAmount,proto3" json:"orderbook_amount,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Condition string `protobuf:"bytes,1,opt,name=condition,proto3" json:"condition,omitempty"` + Price float64 `protobuf:"fixed64,2,opt,name=price,proto3" json:"price,omitempty"` + CheckBids bool `protobuf:"varint,3,opt,name=check_bids,json=checkBids,proto3" json:"check_bids,omitempty"` + CheckBidsAndAsks bool `protobuf:"varint,4,opt,name=check_bids_and_asks,json=checkBidsAndAsks,proto3" json:"check_bids_and_asks,omitempty"` + OrderbookAmount float64 `protobuf:"fixed64,5,opt,name=orderbook_amount,json=orderbookAmount,proto3" json:"orderbook_amount,omitempty"` } -func (m *ConditionParams) Reset() { *m = ConditionParams{} } -func (m *ConditionParams) String() string { return proto.CompactTextString(m) } -func (*ConditionParams) ProtoMessage() {} +func (x *ConditionParams) Reset() { + *x = ConditionParams{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[70] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ConditionParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConditionParams) ProtoMessage() {} + +func (x *ConditionParams) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[70] + 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 ConditionParams.ProtoReflect.Descriptor instead. func (*ConditionParams) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{70} + return file_rpc_proto_rawDescGZIP(), []int{70} } -func (m *ConditionParams) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ConditionParams.Unmarshal(m, b) -} -func (m *ConditionParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ConditionParams.Marshal(b, m, deterministic) -} -func (m *ConditionParams) XXX_Merge(src proto.Message) { - xxx_messageInfo_ConditionParams.Merge(m, src) -} -func (m *ConditionParams) XXX_Size() int { - return xxx_messageInfo_ConditionParams.Size(m) -} -func (m *ConditionParams) XXX_DiscardUnknown() { - xxx_messageInfo_ConditionParams.DiscardUnknown(m) -} - -var xxx_messageInfo_ConditionParams proto.InternalMessageInfo - -func (m *ConditionParams) GetCondition() string { - if m != nil { - return m.Condition +func (x *ConditionParams) GetCondition() string { + if x != nil { + return x.Condition } return "" } -func (m *ConditionParams) GetPrice() float64 { - if m != nil { - return m.Price +func (x *ConditionParams) GetPrice() float64 { + if x != nil { + return x.Price } return 0 } -func (m *ConditionParams) GetCheckBids() bool { - if m != nil { - return m.CheckBids +func (x *ConditionParams) GetCheckBids() bool { + if x != nil { + return x.CheckBids } return false } -func (m *ConditionParams) GetCheckBidsAndAsks() bool { - if m != nil { - return m.CheckBidsAndAsks +func (x *ConditionParams) GetCheckBidsAndAsks() bool { + if x != nil { + return x.CheckBidsAndAsks } return false } -func (m *ConditionParams) GetOrderbookAmount() float64 { - if m != nil { - return m.OrderbookAmount +func (x *ConditionParams) GetOrderbookAmount() float64 { + if x != nil { + return x.OrderbookAmount } return 0 } type GetEventsResponse struct { - Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - Exchange string `protobuf:"bytes,2,opt,name=exchange,proto3" json:"exchange,omitempty"` - Item string `protobuf:"bytes,3,opt,name=item,proto3" json:"item,omitempty"` - ConditionParams *ConditionParams `protobuf:"bytes,4,opt,name=condition_params,json=conditionParams,proto3" json:"condition_params,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,5,opt,name=pair,proto3" json:"pair,omitempty"` - Action string `protobuf:"bytes,6,opt,name=action,proto3" json:"action,omitempty"` - Executed bool `protobuf:"varint,7,opt,name=executed,proto3" json:"executed,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Exchange string `protobuf:"bytes,2,opt,name=exchange,proto3" json:"exchange,omitempty"` + Item string `protobuf:"bytes,3,opt,name=item,proto3" json:"item,omitempty"` + ConditionParams *ConditionParams `protobuf:"bytes,4,opt,name=condition_params,json=conditionParams,proto3" json:"condition_params,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,5,opt,name=pair,proto3" json:"pair,omitempty"` + Action string `protobuf:"bytes,6,opt,name=action,proto3" json:"action,omitempty"` + Executed bool `protobuf:"varint,7,opt,name=executed,proto3" json:"executed,omitempty"` } -func (m *GetEventsResponse) Reset() { *m = GetEventsResponse{} } -func (m *GetEventsResponse) String() string { return proto.CompactTextString(m) } -func (*GetEventsResponse) ProtoMessage() {} +func (x *GetEventsResponse) Reset() { + *x = GetEventsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[71] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetEventsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetEventsResponse) ProtoMessage() {} + +func (x *GetEventsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[71] + 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 GetEventsResponse.ProtoReflect.Descriptor instead. func (*GetEventsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{71} + return file_rpc_proto_rawDescGZIP(), []int{71} } -func (m *GetEventsResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetEventsResponse.Unmarshal(m, b) -} -func (m *GetEventsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetEventsResponse.Marshal(b, m, deterministic) -} -func (m *GetEventsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetEventsResponse.Merge(m, src) -} -func (m *GetEventsResponse) XXX_Size() int { - return xxx_messageInfo_GetEventsResponse.Size(m) -} -func (m *GetEventsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetEventsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetEventsResponse proto.InternalMessageInfo - -func (m *GetEventsResponse) GetId() int64 { - if m != nil { - return m.Id +func (x *GetEventsResponse) GetId() int64 { + if x != nil { + return x.Id } return 0 } -func (m *GetEventsResponse) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetEventsResponse) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetEventsResponse) GetItem() string { - if m != nil { - return m.Item +func (x *GetEventsResponse) GetItem() string { + if x != nil { + return x.Item } return "" } -func (m *GetEventsResponse) GetConditionParams() *ConditionParams { - if m != nil { - return m.ConditionParams +func (x *GetEventsResponse) GetConditionParams() *ConditionParams { + if x != nil { + return x.ConditionParams } return nil } -func (m *GetEventsResponse) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *GetEventsResponse) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *GetEventsResponse) GetAction() string { - if m != nil { - return m.Action +func (x *GetEventsResponse) GetAction() string { + if x != nil { + return x.Action } return "" } -func (m *GetEventsResponse) GetExecuted() bool { - if m != nil { - return m.Executed +func (x *GetEventsResponse) GetExecuted() bool { + if x != nil { + return x.Executed } return false } type AddEventRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Item string `protobuf:"bytes,2,opt,name=item,proto3" json:"item,omitempty"` - ConditionParams *ConditionParams `protobuf:"bytes,3,opt,name=condition_params,json=conditionParams,proto3" json:"condition_params,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,4,opt,name=pair,proto3" json:"pair,omitempty"` - AssetType string `protobuf:"bytes,5,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` - Action string `protobuf:"bytes,6,opt,name=action,proto3" json:"action,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Item string `protobuf:"bytes,2,opt,name=item,proto3" json:"item,omitempty"` + ConditionParams *ConditionParams `protobuf:"bytes,3,opt,name=condition_params,json=conditionParams,proto3" json:"condition_params,omitempty"` + Pair *CurrencyPair `protobuf:"bytes,4,opt,name=pair,proto3" json:"pair,omitempty"` + AssetType string `protobuf:"bytes,5,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + Action string `protobuf:"bytes,6,opt,name=action,proto3" json:"action,omitempty"` } -func (m *AddEventRequest) Reset() { *m = AddEventRequest{} } -func (m *AddEventRequest) String() string { return proto.CompactTextString(m) } -func (*AddEventRequest) ProtoMessage() {} +func (x *AddEventRequest) Reset() { + *x = AddEventRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[72] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddEventRequest) ProtoMessage() {} + +func (x *AddEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[72] + 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 AddEventRequest.ProtoReflect.Descriptor instead. func (*AddEventRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{72} + return file_rpc_proto_rawDescGZIP(), []int{72} } -func (m *AddEventRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AddEventRequest.Unmarshal(m, b) -} -func (m *AddEventRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AddEventRequest.Marshal(b, m, deterministic) -} -func (m *AddEventRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddEventRequest.Merge(m, src) -} -func (m *AddEventRequest) XXX_Size() int { - return xxx_messageInfo_AddEventRequest.Size(m) -} -func (m *AddEventRequest) XXX_DiscardUnknown() { - xxx_messageInfo_AddEventRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_AddEventRequest proto.InternalMessageInfo - -func (m *AddEventRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *AddEventRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *AddEventRequest) GetItem() string { - if m != nil { - return m.Item +func (x *AddEventRequest) GetItem() string { + if x != nil { + return x.Item } return "" } -func (m *AddEventRequest) GetConditionParams() *ConditionParams { - if m != nil { - return m.ConditionParams +func (x *AddEventRequest) GetConditionParams() *ConditionParams { + if x != nil { + return x.ConditionParams } return nil } -func (m *AddEventRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *AddEventRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *AddEventRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *AddEventRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } -func (m *AddEventRequest) GetAction() string { - if m != nil { - return m.Action +func (x *AddEventRequest) GetAction() string { + if x != nil { + return x.Action } return "" } type AddEventResponse struct { - Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` } -func (m *AddEventResponse) Reset() { *m = AddEventResponse{} } -func (m *AddEventResponse) String() string { return proto.CompactTextString(m) } -func (*AddEventResponse) ProtoMessage() {} +func (x *AddEventResponse) Reset() { + *x = AddEventResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[73] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddEventResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddEventResponse) ProtoMessage() {} + +func (x *AddEventResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[73] + 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 AddEventResponse.ProtoReflect.Descriptor instead. func (*AddEventResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{73} + return file_rpc_proto_rawDescGZIP(), []int{73} } -func (m *AddEventResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AddEventResponse.Unmarshal(m, b) -} -func (m *AddEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AddEventResponse.Marshal(b, m, deterministic) -} -func (m *AddEventResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_AddEventResponse.Merge(m, src) -} -func (m *AddEventResponse) XXX_Size() int { - return xxx_messageInfo_AddEventResponse.Size(m) -} -func (m *AddEventResponse) XXX_DiscardUnknown() { - xxx_messageInfo_AddEventResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_AddEventResponse proto.InternalMessageInfo - -func (m *AddEventResponse) GetId() int64 { - if m != nil { - return m.Id +func (x *AddEventResponse) GetId() int64 { + if x != nil { + return x.Id } return 0 } type RemoveEventRequest struct { - Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` } -func (m *RemoveEventRequest) Reset() { *m = RemoveEventRequest{} } -func (m *RemoveEventRequest) String() string { return proto.CompactTextString(m) } -func (*RemoveEventRequest) ProtoMessage() {} +func (x *RemoveEventRequest) Reset() { + *x = RemoveEventRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[74] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RemoveEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RemoveEventRequest) ProtoMessage() {} + +func (x *RemoveEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[74] + 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 RemoveEventRequest.ProtoReflect.Descriptor instead. func (*RemoveEventRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{74} + return file_rpc_proto_rawDescGZIP(), []int{74} } -func (m *RemoveEventRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_RemoveEventRequest.Unmarshal(m, b) -} -func (m *RemoveEventRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_RemoveEventRequest.Marshal(b, m, deterministic) -} -func (m *RemoveEventRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_RemoveEventRequest.Merge(m, src) -} -func (m *RemoveEventRequest) XXX_Size() int { - return xxx_messageInfo_RemoveEventRequest.Size(m) -} -func (m *RemoveEventRequest) XXX_DiscardUnknown() { - xxx_messageInfo_RemoveEventRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_RemoveEventRequest proto.InternalMessageInfo - -func (m *RemoveEventRequest) GetId() int64 { - if m != nil { - return m.Id +func (x *RemoveEventRequest) GetId() int64 { + if x != nil { + return x.Id } return 0 } type GetCryptocurrencyDepositAddressesRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *GetCryptocurrencyDepositAddressesRequest) Reset() { - *m = GetCryptocurrencyDepositAddressesRequest{} +func (x *GetCryptocurrencyDepositAddressesRequest) Reset() { + *x = GetCryptocurrencyDepositAddressesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[75] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } } -func (m *GetCryptocurrencyDepositAddressesRequest) String() string { return proto.CompactTextString(m) } -func (*GetCryptocurrencyDepositAddressesRequest) ProtoMessage() {} + +func (x *GetCryptocurrencyDepositAddressesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCryptocurrencyDepositAddressesRequest) ProtoMessage() {} + +func (x *GetCryptocurrencyDepositAddressesRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[75] + 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 GetCryptocurrencyDepositAddressesRequest.ProtoReflect.Descriptor instead. func (*GetCryptocurrencyDepositAddressesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{75} + return file_rpc_proto_rawDescGZIP(), []int{75} } -func (m *GetCryptocurrencyDepositAddressesRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetCryptocurrencyDepositAddressesRequest.Unmarshal(m, b) -} -func (m *GetCryptocurrencyDepositAddressesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetCryptocurrencyDepositAddressesRequest.Marshal(b, m, deterministic) -} -func (m *GetCryptocurrencyDepositAddressesRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetCryptocurrencyDepositAddressesRequest.Merge(m, src) -} -func (m *GetCryptocurrencyDepositAddressesRequest) XXX_Size() int { - return xxx_messageInfo_GetCryptocurrencyDepositAddressesRequest.Size(m) -} -func (m *GetCryptocurrencyDepositAddressesRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetCryptocurrencyDepositAddressesRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetCryptocurrencyDepositAddressesRequest proto.InternalMessageInfo - -func (m *GetCryptocurrencyDepositAddressesRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetCryptocurrencyDepositAddressesRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type GetCryptocurrencyDepositAddressesResponse struct { - Addresses map[string]string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Addresses map[string]string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } -func (m *GetCryptocurrencyDepositAddressesResponse) Reset() { - *m = GetCryptocurrencyDepositAddressesResponse{} +func (x *GetCryptocurrencyDepositAddressesResponse) Reset() { + *x = GetCryptocurrencyDepositAddressesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[76] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } } -func (m *GetCryptocurrencyDepositAddressesResponse) String() string { return proto.CompactTextString(m) } -func (*GetCryptocurrencyDepositAddressesResponse) ProtoMessage() {} + +func (x *GetCryptocurrencyDepositAddressesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCryptocurrencyDepositAddressesResponse) ProtoMessage() {} + +func (x *GetCryptocurrencyDepositAddressesResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[76] + 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 GetCryptocurrencyDepositAddressesResponse.ProtoReflect.Descriptor instead. func (*GetCryptocurrencyDepositAddressesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{76} + return file_rpc_proto_rawDescGZIP(), []int{76} } -func (m *GetCryptocurrencyDepositAddressesResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetCryptocurrencyDepositAddressesResponse.Unmarshal(m, b) -} -func (m *GetCryptocurrencyDepositAddressesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetCryptocurrencyDepositAddressesResponse.Marshal(b, m, deterministic) -} -func (m *GetCryptocurrencyDepositAddressesResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetCryptocurrencyDepositAddressesResponse.Merge(m, src) -} -func (m *GetCryptocurrencyDepositAddressesResponse) XXX_Size() int { - return xxx_messageInfo_GetCryptocurrencyDepositAddressesResponse.Size(m) -} -func (m *GetCryptocurrencyDepositAddressesResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetCryptocurrencyDepositAddressesResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetCryptocurrencyDepositAddressesResponse proto.InternalMessageInfo - -func (m *GetCryptocurrencyDepositAddressesResponse) GetAddresses() map[string]string { - if m != nil { - return m.Addresses +func (x *GetCryptocurrencyDepositAddressesResponse) GetAddresses() map[string]string { + if x != nil { + return x.Addresses } return nil } type GetCryptocurrencyDepositAddressRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Cryptocurrency string `protobuf:"bytes,2,opt,name=cryptocurrency,proto3" json:"cryptocurrency,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Cryptocurrency string `protobuf:"bytes,2,opt,name=cryptocurrency,proto3" json:"cryptocurrency,omitempty"` } -func (m *GetCryptocurrencyDepositAddressRequest) Reset() { - *m = GetCryptocurrencyDepositAddressRequest{} +func (x *GetCryptocurrencyDepositAddressRequest) Reset() { + *x = GetCryptocurrencyDepositAddressRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[77] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } } -func (m *GetCryptocurrencyDepositAddressRequest) String() string { return proto.CompactTextString(m) } -func (*GetCryptocurrencyDepositAddressRequest) ProtoMessage() {} + +func (x *GetCryptocurrencyDepositAddressRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCryptocurrencyDepositAddressRequest) ProtoMessage() {} + +func (x *GetCryptocurrencyDepositAddressRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[77] + 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 GetCryptocurrencyDepositAddressRequest.ProtoReflect.Descriptor instead. func (*GetCryptocurrencyDepositAddressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{77} + return file_rpc_proto_rawDescGZIP(), []int{77} } -func (m *GetCryptocurrencyDepositAddressRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetCryptocurrencyDepositAddressRequest.Unmarshal(m, b) -} -func (m *GetCryptocurrencyDepositAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetCryptocurrencyDepositAddressRequest.Marshal(b, m, deterministic) -} -func (m *GetCryptocurrencyDepositAddressRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetCryptocurrencyDepositAddressRequest.Merge(m, src) -} -func (m *GetCryptocurrencyDepositAddressRequest) XXX_Size() int { - return xxx_messageInfo_GetCryptocurrencyDepositAddressRequest.Size(m) -} -func (m *GetCryptocurrencyDepositAddressRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetCryptocurrencyDepositAddressRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetCryptocurrencyDepositAddressRequest proto.InternalMessageInfo - -func (m *GetCryptocurrencyDepositAddressRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetCryptocurrencyDepositAddressRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetCryptocurrencyDepositAddressRequest) GetCryptocurrency() string { - if m != nil { - return m.Cryptocurrency +func (x *GetCryptocurrencyDepositAddressRequest) GetCryptocurrency() string { + if x != nil { + return x.Cryptocurrency } return "" } type GetCryptocurrencyDepositAddressResponse struct { - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` } -func (m *GetCryptocurrencyDepositAddressResponse) Reset() { - *m = GetCryptocurrencyDepositAddressResponse{} +func (x *GetCryptocurrencyDepositAddressResponse) Reset() { + *x = GetCryptocurrencyDepositAddressResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[78] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } } -func (m *GetCryptocurrencyDepositAddressResponse) String() string { return proto.CompactTextString(m) } -func (*GetCryptocurrencyDepositAddressResponse) ProtoMessage() {} + +func (x *GetCryptocurrencyDepositAddressResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCryptocurrencyDepositAddressResponse) ProtoMessage() {} + +func (x *GetCryptocurrencyDepositAddressResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[78] + 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 GetCryptocurrencyDepositAddressResponse.ProtoReflect.Descriptor instead. func (*GetCryptocurrencyDepositAddressResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{78} + return file_rpc_proto_rawDescGZIP(), []int{78} } -func (m *GetCryptocurrencyDepositAddressResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetCryptocurrencyDepositAddressResponse.Unmarshal(m, b) -} -func (m *GetCryptocurrencyDepositAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetCryptocurrencyDepositAddressResponse.Marshal(b, m, deterministic) -} -func (m *GetCryptocurrencyDepositAddressResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetCryptocurrencyDepositAddressResponse.Merge(m, src) -} -func (m *GetCryptocurrencyDepositAddressResponse) XXX_Size() int { - return xxx_messageInfo_GetCryptocurrencyDepositAddressResponse.Size(m) -} -func (m *GetCryptocurrencyDepositAddressResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetCryptocurrencyDepositAddressResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetCryptocurrencyDepositAddressResponse proto.InternalMessageInfo - -func (m *GetCryptocurrencyDepositAddressResponse) GetAddress() string { - if m != nil { - return m.Address +func (x *GetCryptocurrencyDepositAddressResponse) GetAddress() string { + if x != nil { + return x.Address } return "" } type WithdrawFiatRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Currency string `protobuf:"bytes,2,opt,name=currency,proto3" json:"currency,omitempty"` - Amount float64 `protobuf:"fixed64,3,opt,name=amount,proto3" json:"amount,omitempty"` - Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` - BankAccountId string `protobuf:"bytes,5,opt,name=bank_account_id,json=bankAccountId,proto3" json:"bank_account_id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Currency string `protobuf:"bytes,2,opt,name=currency,proto3" json:"currency,omitempty"` + Amount float64 `protobuf:"fixed64,3,opt,name=amount,proto3" json:"amount,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + BankAccountId string `protobuf:"bytes,5,opt,name=bank_account_id,json=bankAccountId,proto3" json:"bank_account_id,omitempty"` } -func (m *WithdrawFiatRequest) Reset() { *m = WithdrawFiatRequest{} } -func (m *WithdrawFiatRequest) String() string { return proto.CompactTextString(m) } -func (*WithdrawFiatRequest) ProtoMessage() {} +func (x *WithdrawFiatRequest) Reset() { + *x = WithdrawFiatRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[79] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawFiatRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawFiatRequest) ProtoMessage() {} + +func (x *WithdrawFiatRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[79] + 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 WithdrawFiatRequest.ProtoReflect.Descriptor instead. func (*WithdrawFiatRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{79} + return file_rpc_proto_rawDescGZIP(), []int{79} } -func (m *WithdrawFiatRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawFiatRequest.Unmarshal(m, b) -} -func (m *WithdrawFiatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawFiatRequest.Marshal(b, m, deterministic) -} -func (m *WithdrawFiatRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawFiatRequest.Merge(m, src) -} -func (m *WithdrawFiatRequest) XXX_Size() int { - return xxx_messageInfo_WithdrawFiatRequest.Size(m) -} -func (m *WithdrawFiatRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawFiatRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawFiatRequest proto.InternalMessageInfo - -func (m *WithdrawFiatRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WithdrawFiatRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WithdrawFiatRequest) GetCurrency() string { - if m != nil { - return m.Currency +func (x *WithdrawFiatRequest) GetCurrency() string { + if x != nil { + return x.Currency } return "" } -func (m *WithdrawFiatRequest) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *WithdrawFiatRequest) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *WithdrawFiatRequest) GetDescription() string { - if m != nil { - return m.Description +func (x *WithdrawFiatRequest) GetDescription() string { + if x != nil { + return x.Description } return "" } -func (m *WithdrawFiatRequest) GetBankAccountId() string { - if m != nil { - return m.BankAccountId +func (x *WithdrawFiatRequest) GetBankAccountId() string { + if x != nil { + return x.BankAccountId } return "" } type WithdrawCryptoRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` - AddressTag string `protobuf:"bytes,3,opt,name=address_tag,json=addressTag,proto3" json:"address_tag,omitempty"` - Currency string `protobuf:"bytes,4,opt,name=currency,proto3" json:"currency,omitempty"` - Amount float64 `protobuf:"fixed64,5,opt,name=amount,proto3" json:"amount,omitempty"` - Fee float64 `protobuf:"fixed64,6,opt,name=fee,proto3" json:"fee,omitempty"` - Description string `protobuf:"bytes,7,opt,name=description,proto3" json:"description,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` + AddressTag string `protobuf:"bytes,3,opt,name=address_tag,json=addressTag,proto3" json:"address_tag,omitempty"` + Currency string `protobuf:"bytes,4,opt,name=currency,proto3" json:"currency,omitempty"` + Amount float64 `protobuf:"fixed64,5,opt,name=amount,proto3" json:"amount,omitempty"` + Fee float64 `protobuf:"fixed64,6,opt,name=fee,proto3" json:"fee,omitempty"` + Description string `protobuf:"bytes,7,opt,name=description,proto3" json:"description,omitempty"` } -func (m *WithdrawCryptoRequest) Reset() { *m = WithdrawCryptoRequest{} } -func (m *WithdrawCryptoRequest) String() string { return proto.CompactTextString(m) } -func (*WithdrawCryptoRequest) ProtoMessage() {} +func (x *WithdrawCryptoRequest) Reset() { + *x = WithdrawCryptoRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[80] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawCryptoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawCryptoRequest) ProtoMessage() {} + +func (x *WithdrawCryptoRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[80] + 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 WithdrawCryptoRequest.ProtoReflect.Descriptor instead. func (*WithdrawCryptoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{80} + return file_rpc_proto_rawDescGZIP(), []int{80} } -func (m *WithdrawCryptoRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawCryptoRequest.Unmarshal(m, b) -} -func (m *WithdrawCryptoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawCryptoRequest.Marshal(b, m, deterministic) -} -func (m *WithdrawCryptoRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawCryptoRequest.Merge(m, src) -} -func (m *WithdrawCryptoRequest) XXX_Size() int { - return xxx_messageInfo_WithdrawCryptoRequest.Size(m) -} -func (m *WithdrawCryptoRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawCryptoRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawCryptoRequest proto.InternalMessageInfo - -func (m *WithdrawCryptoRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WithdrawCryptoRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WithdrawCryptoRequest) GetAddress() string { - if m != nil { - return m.Address +func (x *WithdrawCryptoRequest) GetAddress() string { + if x != nil { + return x.Address } return "" } -func (m *WithdrawCryptoRequest) GetAddressTag() string { - if m != nil { - return m.AddressTag +func (x *WithdrawCryptoRequest) GetAddressTag() string { + if x != nil { + return x.AddressTag } return "" } -func (m *WithdrawCryptoRequest) GetCurrency() string { - if m != nil { - return m.Currency +func (x *WithdrawCryptoRequest) GetCurrency() string { + if x != nil { + return x.Currency } return "" } -func (m *WithdrawCryptoRequest) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *WithdrawCryptoRequest) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *WithdrawCryptoRequest) GetFee() float64 { - if m != nil { - return m.Fee +func (x *WithdrawCryptoRequest) GetFee() float64 { + if x != nil { + return x.Fee } return 0 } -func (m *WithdrawCryptoRequest) GetDescription() string { - if m != nil { - return m.Description +func (x *WithdrawCryptoRequest) GetDescription() string { + if x != nil { + return x.Description } return "" } type WithdrawResponse struct { - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Status string `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Status string `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` } -func (m *WithdrawResponse) Reset() { *m = WithdrawResponse{} } -func (m *WithdrawResponse) String() string { return proto.CompactTextString(m) } -func (*WithdrawResponse) ProtoMessage() {} +func (x *WithdrawResponse) Reset() { + *x = WithdrawResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[81] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawResponse) ProtoMessage() {} + +func (x *WithdrawResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[81] + 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 WithdrawResponse.ProtoReflect.Descriptor instead. func (*WithdrawResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{81} + return file_rpc_proto_rawDescGZIP(), []int{81} } -func (m *WithdrawResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawResponse.Unmarshal(m, b) -} -func (m *WithdrawResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawResponse.Marshal(b, m, deterministic) -} -func (m *WithdrawResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawResponse.Merge(m, src) -} -func (m *WithdrawResponse) XXX_Size() int { - return xxx_messageInfo_WithdrawResponse.Size(m) -} -func (m *WithdrawResponse) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawResponse proto.InternalMessageInfo - -func (m *WithdrawResponse) GetId() string { - if m != nil { - return m.Id +func (x *WithdrawResponse) GetId() string { + if x != nil { + return x.Id } return "" } -func (m *WithdrawResponse) GetStatus() string { - if m != nil { - return m.Status +func (x *WithdrawResponse) GetStatus() string { + if x != nil { + return x.Status } return "" } type WithdrawalEventByIDRequest struct { - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` } -func (m *WithdrawalEventByIDRequest) Reset() { *m = WithdrawalEventByIDRequest{} } -func (m *WithdrawalEventByIDRequest) String() string { return proto.CompactTextString(m) } -func (*WithdrawalEventByIDRequest) ProtoMessage() {} +func (x *WithdrawalEventByIDRequest) Reset() { + *x = WithdrawalEventByIDRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[82] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawalEventByIDRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawalEventByIDRequest) ProtoMessage() {} + +func (x *WithdrawalEventByIDRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[82] + 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 WithdrawalEventByIDRequest.ProtoReflect.Descriptor instead. func (*WithdrawalEventByIDRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{82} + return file_rpc_proto_rawDescGZIP(), []int{82} } -func (m *WithdrawalEventByIDRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawalEventByIDRequest.Unmarshal(m, b) -} -func (m *WithdrawalEventByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawalEventByIDRequest.Marshal(b, m, deterministic) -} -func (m *WithdrawalEventByIDRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawalEventByIDRequest.Merge(m, src) -} -func (m *WithdrawalEventByIDRequest) XXX_Size() int { - return xxx_messageInfo_WithdrawalEventByIDRequest.Size(m) -} -func (m *WithdrawalEventByIDRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawalEventByIDRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawalEventByIDRequest proto.InternalMessageInfo - -func (m *WithdrawalEventByIDRequest) GetId() string { - if m != nil { - return m.Id +func (x *WithdrawalEventByIDRequest) GetId() string { + if x != nil { + return x.Id } return "" } type WithdrawalEventByIDResponse struct { - Event *WithdrawalEventResponse `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Event *WithdrawalEventResponse `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"` } -func (m *WithdrawalEventByIDResponse) Reset() { *m = WithdrawalEventByIDResponse{} } -func (m *WithdrawalEventByIDResponse) String() string { return proto.CompactTextString(m) } -func (*WithdrawalEventByIDResponse) ProtoMessage() {} +func (x *WithdrawalEventByIDResponse) Reset() { + *x = WithdrawalEventByIDResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[83] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawalEventByIDResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawalEventByIDResponse) ProtoMessage() {} + +func (x *WithdrawalEventByIDResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[83] + 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 WithdrawalEventByIDResponse.ProtoReflect.Descriptor instead. func (*WithdrawalEventByIDResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{83} + return file_rpc_proto_rawDescGZIP(), []int{83} } -func (m *WithdrawalEventByIDResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawalEventByIDResponse.Unmarshal(m, b) -} -func (m *WithdrawalEventByIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawalEventByIDResponse.Marshal(b, m, deterministic) -} -func (m *WithdrawalEventByIDResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawalEventByIDResponse.Merge(m, src) -} -func (m *WithdrawalEventByIDResponse) XXX_Size() int { - return xxx_messageInfo_WithdrawalEventByIDResponse.Size(m) -} -func (m *WithdrawalEventByIDResponse) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawalEventByIDResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawalEventByIDResponse proto.InternalMessageInfo - -func (m *WithdrawalEventByIDResponse) GetEvent() *WithdrawalEventResponse { - if m != nil { - return m.Event +func (x *WithdrawalEventByIDResponse) GetEvent() *WithdrawalEventResponse { + if x != nil { + return x.Event } return nil } type WithdrawalEventsByExchangeRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` - Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` } -func (m *WithdrawalEventsByExchangeRequest) Reset() { *m = WithdrawalEventsByExchangeRequest{} } -func (m *WithdrawalEventsByExchangeRequest) String() string { return proto.CompactTextString(m) } -func (*WithdrawalEventsByExchangeRequest) ProtoMessage() {} +func (x *WithdrawalEventsByExchangeRequest) Reset() { + *x = WithdrawalEventsByExchangeRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[84] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawalEventsByExchangeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawalEventsByExchangeRequest) ProtoMessage() {} + +func (x *WithdrawalEventsByExchangeRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[84] + 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 WithdrawalEventsByExchangeRequest.ProtoReflect.Descriptor instead. func (*WithdrawalEventsByExchangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{84} + return file_rpc_proto_rawDescGZIP(), []int{84} } -func (m *WithdrawalEventsByExchangeRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawalEventsByExchangeRequest.Unmarshal(m, b) -} -func (m *WithdrawalEventsByExchangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawalEventsByExchangeRequest.Marshal(b, m, deterministic) -} -func (m *WithdrawalEventsByExchangeRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawalEventsByExchangeRequest.Merge(m, src) -} -func (m *WithdrawalEventsByExchangeRequest) XXX_Size() int { - return xxx_messageInfo_WithdrawalEventsByExchangeRequest.Size(m) -} -func (m *WithdrawalEventsByExchangeRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawalEventsByExchangeRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawalEventsByExchangeRequest proto.InternalMessageInfo - -func (m *WithdrawalEventsByExchangeRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WithdrawalEventsByExchangeRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WithdrawalEventsByExchangeRequest) GetId() string { - if m != nil { - return m.Id +func (x *WithdrawalEventsByExchangeRequest) GetId() string { + if x != nil { + return x.Id } return "" } -func (m *WithdrawalEventsByExchangeRequest) GetLimit() int32 { - if m != nil { - return m.Limit +func (x *WithdrawalEventsByExchangeRequest) GetLimit() int32 { + if x != nil { + return x.Limit } return 0 } type WithdrawalEventsByDateRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Start string `protobuf:"bytes,2,opt,name=start,proto3" json:"start,omitempty"` - End string `protobuf:"bytes,3,opt,name=end,proto3" json:"end,omitempty"` - Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Start string `protobuf:"bytes,2,opt,name=start,proto3" json:"start,omitempty"` + End string `protobuf:"bytes,3,opt,name=end,proto3" json:"end,omitempty"` + Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` } -func (m *WithdrawalEventsByDateRequest) Reset() { *m = WithdrawalEventsByDateRequest{} } -func (m *WithdrawalEventsByDateRequest) String() string { return proto.CompactTextString(m) } -func (*WithdrawalEventsByDateRequest) ProtoMessage() {} +func (x *WithdrawalEventsByDateRequest) Reset() { + *x = WithdrawalEventsByDateRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[85] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawalEventsByDateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawalEventsByDateRequest) ProtoMessage() {} + +func (x *WithdrawalEventsByDateRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[85] + 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 WithdrawalEventsByDateRequest.ProtoReflect.Descriptor instead. func (*WithdrawalEventsByDateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{85} + return file_rpc_proto_rawDescGZIP(), []int{85} } -func (m *WithdrawalEventsByDateRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawalEventsByDateRequest.Unmarshal(m, b) -} -func (m *WithdrawalEventsByDateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawalEventsByDateRequest.Marshal(b, m, deterministic) -} -func (m *WithdrawalEventsByDateRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawalEventsByDateRequest.Merge(m, src) -} -func (m *WithdrawalEventsByDateRequest) XXX_Size() int { - return xxx_messageInfo_WithdrawalEventsByDateRequest.Size(m) -} -func (m *WithdrawalEventsByDateRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawalEventsByDateRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawalEventsByDateRequest proto.InternalMessageInfo - -func (m *WithdrawalEventsByDateRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WithdrawalEventsByDateRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WithdrawalEventsByDateRequest) GetStart() string { - if m != nil { - return m.Start +func (x *WithdrawalEventsByDateRequest) GetStart() string { + if x != nil { + return x.Start } return "" } -func (m *WithdrawalEventsByDateRequest) GetEnd() string { - if m != nil { - return m.End +func (x *WithdrawalEventsByDateRequest) GetEnd() string { + if x != nil { + return x.End } return "" } -func (m *WithdrawalEventsByDateRequest) GetLimit() int32 { - if m != nil { - return m.Limit +func (x *WithdrawalEventsByDateRequest) GetLimit() int32 { + if x != nil { + return x.Limit } return 0 } type WithdrawalEventsByExchangeResponse struct { - Event []*WithdrawalEventResponse `protobuf:"bytes,2,rep,name=event,proto3" json:"event,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Event []*WithdrawalEventResponse `protobuf:"bytes,2,rep,name=event,proto3" json:"event,omitempty"` } -func (m *WithdrawalEventsByExchangeResponse) Reset() { *m = WithdrawalEventsByExchangeResponse{} } -func (m *WithdrawalEventsByExchangeResponse) String() string { return proto.CompactTextString(m) } -func (*WithdrawalEventsByExchangeResponse) ProtoMessage() {} +func (x *WithdrawalEventsByExchangeResponse) Reset() { + *x = WithdrawalEventsByExchangeResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[86] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawalEventsByExchangeResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawalEventsByExchangeResponse) ProtoMessage() {} + +func (x *WithdrawalEventsByExchangeResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[86] + 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 WithdrawalEventsByExchangeResponse.ProtoReflect.Descriptor instead. func (*WithdrawalEventsByExchangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{86} + return file_rpc_proto_rawDescGZIP(), []int{86} } -func (m *WithdrawalEventsByExchangeResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawalEventsByExchangeResponse.Unmarshal(m, b) -} -func (m *WithdrawalEventsByExchangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawalEventsByExchangeResponse.Marshal(b, m, deterministic) -} -func (m *WithdrawalEventsByExchangeResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawalEventsByExchangeResponse.Merge(m, src) -} -func (m *WithdrawalEventsByExchangeResponse) XXX_Size() int { - return xxx_messageInfo_WithdrawalEventsByExchangeResponse.Size(m) -} -func (m *WithdrawalEventsByExchangeResponse) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawalEventsByExchangeResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawalEventsByExchangeResponse proto.InternalMessageInfo - -func (m *WithdrawalEventsByExchangeResponse) GetEvent() []*WithdrawalEventResponse { - if m != nil { - return m.Event +func (x *WithdrawalEventsByExchangeResponse) GetEvent() []*WithdrawalEventResponse { + if x != nil { + return x.Event } return nil } type WithdrawalEventResponse struct { - Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` - Exchange *WithdrawlExchangeEvent `protobuf:"bytes,3,opt,name=exchange,proto3" json:"exchange,omitempty"` - Request *WithdrawalRequestEvent `protobuf:"bytes,4,opt,name=request,proto3" json:"request,omitempty"` - CreatedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` - UpdatedAt *timestamp.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + Exchange *WithdrawlExchangeEvent `protobuf:"bytes,3,opt,name=exchange,proto3" json:"exchange,omitempty"` + Request *WithdrawalRequestEvent `protobuf:"bytes,4,opt,name=request,proto3" json:"request,omitempty"` + CreatedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + UpdatedAt *timestamp.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` } -func (m *WithdrawalEventResponse) Reset() { *m = WithdrawalEventResponse{} } -func (m *WithdrawalEventResponse) String() string { return proto.CompactTextString(m) } -func (*WithdrawalEventResponse) ProtoMessage() {} +func (x *WithdrawalEventResponse) Reset() { + *x = WithdrawalEventResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[87] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawalEventResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawalEventResponse) ProtoMessage() {} + +func (x *WithdrawalEventResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[87] + 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 WithdrawalEventResponse.ProtoReflect.Descriptor instead. func (*WithdrawalEventResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{87} + return file_rpc_proto_rawDescGZIP(), []int{87} } -func (m *WithdrawalEventResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawalEventResponse.Unmarshal(m, b) -} -func (m *WithdrawalEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawalEventResponse.Marshal(b, m, deterministic) -} -func (m *WithdrawalEventResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawalEventResponse.Merge(m, src) -} -func (m *WithdrawalEventResponse) XXX_Size() int { - return xxx_messageInfo_WithdrawalEventResponse.Size(m) -} -func (m *WithdrawalEventResponse) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawalEventResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawalEventResponse proto.InternalMessageInfo - -func (m *WithdrawalEventResponse) GetId() string { - if m != nil { - return m.Id +func (x *WithdrawalEventResponse) GetId() string { + if x != nil { + return x.Id } return "" } -func (m *WithdrawalEventResponse) GetExchange() *WithdrawlExchangeEvent { - if m != nil { - return m.Exchange +func (x *WithdrawalEventResponse) GetExchange() *WithdrawlExchangeEvent { + if x != nil { + return x.Exchange } return nil } -func (m *WithdrawalEventResponse) GetRequest() *WithdrawalRequestEvent { - if m != nil { - return m.Request +func (x *WithdrawalEventResponse) GetRequest() *WithdrawalRequestEvent { + if x != nil { + return x.Request } return nil } -func (m *WithdrawalEventResponse) GetCreatedAt() *timestamp.Timestamp { - if m != nil { - return m.CreatedAt +func (x *WithdrawalEventResponse) GetCreatedAt() *timestamp.Timestamp { + if x != nil { + return x.CreatedAt } return nil } -func (m *WithdrawalEventResponse) GetUpdatedAt() *timestamp.Timestamp { - if m != nil { - return m.UpdatedAt +func (x *WithdrawalEventResponse) GetUpdatedAt() *timestamp.Timestamp { + if x != nil { + return x.UpdatedAt } return nil } type WithdrawlExchangeEvent struct { - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` - Status string `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + Status string `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` } -func (m *WithdrawlExchangeEvent) Reset() { *m = WithdrawlExchangeEvent{} } -func (m *WithdrawlExchangeEvent) String() string { return proto.CompactTextString(m) } -func (*WithdrawlExchangeEvent) ProtoMessage() {} +func (x *WithdrawlExchangeEvent) Reset() { + *x = WithdrawlExchangeEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[88] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawlExchangeEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawlExchangeEvent) ProtoMessage() {} + +func (x *WithdrawlExchangeEvent) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[88] + 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 WithdrawlExchangeEvent.ProtoReflect.Descriptor instead. func (*WithdrawlExchangeEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{88} + return file_rpc_proto_rawDescGZIP(), []int{88} } -func (m *WithdrawlExchangeEvent) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawlExchangeEvent.Unmarshal(m, b) -} -func (m *WithdrawlExchangeEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawlExchangeEvent.Marshal(b, m, deterministic) -} -func (m *WithdrawlExchangeEvent) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawlExchangeEvent.Merge(m, src) -} -func (m *WithdrawlExchangeEvent) XXX_Size() int { - return xxx_messageInfo_WithdrawlExchangeEvent.Size(m) -} -func (m *WithdrawlExchangeEvent) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawlExchangeEvent.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawlExchangeEvent proto.InternalMessageInfo - -func (m *WithdrawlExchangeEvent) GetName() string { - if m != nil { - return m.Name +func (x *WithdrawlExchangeEvent) GetName() string { + if x != nil { + return x.Name } return "" } -func (m *WithdrawlExchangeEvent) GetId() string { - if m != nil { - return m.Id +func (x *WithdrawlExchangeEvent) GetId() string { + if x != nil { + return x.Id } return "" } -func (m *WithdrawlExchangeEvent) GetStatus() string { - if m != nil { - return m.Status +func (x *WithdrawlExchangeEvent) GetStatus() string { + if x != nil { + return x.Status } return "" } type WithdrawalRequestEvent struct { - Currency string `protobuf:"bytes,2,opt,name=currency,proto3" json:"currency,omitempty"` - Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` - Amount float64 `protobuf:"fixed64,4,opt,name=amount,proto3" json:"amount,omitempty"` - Type int32 `protobuf:"varint,5,opt,name=type,proto3" json:"type,omitempty"` - Fiat *FiatWithdrawalEvent `protobuf:"bytes,6,opt,name=fiat,proto3" json:"fiat,omitempty"` - Crypto *CryptoWithdrawalEvent `protobuf:"bytes,7,opt,name=crypto,proto3" json:"crypto,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Currency string `protobuf:"bytes,2,opt,name=currency,proto3" json:"currency,omitempty"` + Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + Amount float64 `protobuf:"fixed64,4,opt,name=amount,proto3" json:"amount,omitempty"` + Type int32 `protobuf:"varint,5,opt,name=type,proto3" json:"type,omitempty"` + Fiat *FiatWithdrawalEvent `protobuf:"bytes,6,opt,name=fiat,proto3" json:"fiat,omitempty"` + Crypto *CryptoWithdrawalEvent `protobuf:"bytes,7,opt,name=crypto,proto3" json:"crypto,omitempty"` } -func (m *WithdrawalRequestEvent) Reset() { *m = WithdrawalRequestEvent{} } -func (m *WithdrawalRequestEvent) String() string { return proto.CompactTextString(m) } -func (*WithdrawalRequestEvent) ProtoMessage() {} +func (x *WithdrawalRequestEvent) Reset() { + *x = WithdrawalRequestEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[89] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawalRequestEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawalRequestEvent) ProtoMessage() {} + +func (x *WithdrawalRequestEvent) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[89] + 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 WithdrawalRequestEvent.ProtoReflect.Descriptor instead. func (*WithdrawalRequestEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{89} + return file_rpc_proto_rawDescGZIP(), []int{89} } -func (m *WithdrawalRequestEvent) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WithdrawalRequestEvent.Unmarshal(m, b) -} -func (m *WithdrawalRequestEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WithdrawalRequestEvent.Marshal(b, m, deterministic) -} -func (m *WithdrawalRequestEvent) XXX_Merge(src proto.Message) { - xxx_messageInfo_WithdrawalRequestEvent.Merge(m, src) -} -func (m *WithdrawalRequestEvent) XXX_Size() int { - return xxx_messageInfo_WithdrawalRequestEvent.Size(m) -} -func (m *WithdrawalRequestEvent) XXX_DiscardUnknown() { - xxx_messageInfo_WithdrawalRequestEvent.DiscardUnknown(m) -} - -var xxx_messageInfo_WithdrawalRequestEvent proto.InternalMessageInfo - -func (m *WithdrawalRequestEvent) GetCurrency() string { - if m != nil { - return m.Currency +func (x *WithdrawalRequestEvent) GetCurrency() string { + if x != nil { + return x.Currency } return "" } -func (m *WithdrawalRequestEvent) GetDescription() string { - if m != nil { - return m.Description +func (x *WithdrawalRequestEvent) GetDescription() string { + if x != nil { + return x.Description } return "" } -func (m *WithdrawalRequestEvent) GetAmount() float64 { - if m != nil { - return m.Amount +func (x *WithdrawalRequestEvent) GetAmount() float64 { + if x != nil { + return x.Amount } return 0 } -func (m *WithdrawalRequestEvent) GetType() int32 { - if m != nil { - return m.Type +func (x *WithdrawalRequestEvent) GetType() int32 { + if x != nil { + return x.Type } return 0 } -func (m *WithdrawalRequestEvent) GetFiat() *FiatWithdrawalEvent { - if m != nil { - return m.Fiat +func (x *WithdrawalRequestEvent) GetFiat() *FiatWithdrawalEvent { + if x != nil { + return x.Fiat } return nil } -func (m *WithdrawalRequestEvent) GetCrypto() *CryptoWithdrawalEvent { - if m != nil { - return m.Crypto +func (x *WithdrawalRequestEvent) GetCrypto() *CryptoWithdrawalEvent { + if x != nil { + return x.Crypto } return nil } type FiatWithdrawalEvent struct { - BankName string `protobuf:"bytes,1,opt,name=bank_name,json=bankName,proto3" json:"bank_name,omitempty"` - AccountName string `protobuf:"bytes,2,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"` - AccountNumber string `protobuf:"bytes,3,opt,name=account_number,json=accountNumber,proto3" json:"account_number,omitempty"` - Bsb string `protobuf:"bytes,4,opt,name=bsb,proto3" json:"bsb,omitempty"` - Swift string `protobuf:"bytes,5,opt,name=swift,proto3" json:"swift,omitempty"` - Iban string `protobuf:"bytes,6,opt,name=iban,proto3" json:"iban,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BankName string `protobuf:"bytes,1,opt,name=bank_name,json=bankName,proto3" json:"bank_name,omitempty"` + AccountName string `protobuf:"bytes,2,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"` + AccountNumber string `protobuf:"bytes,3,opt,name=account_number,json=accountNumber,proto3" json:"account_number,omitempty"` + Bsb string `protobuf:"bytes,4,opt,name=bsb,proto3" json:"bsb,omitempty"` + Swift string `protobuf:"bytes,5,opt,name=swift,proto3" json:"swift,omitempty"` + Iban string `protobuf:"bytes,6,opt,name=iban,proto3" json:"iban,omitempty"` } -func (m *FiatWithdrawalEvent) Reset() { *m = FiatWithdrawalEvent{} } -func (m *FiatWithdrawalEvent) String() string { return proto.CompactTextString(m) } -func (*FiatWithdrawalEvent) ProtoMessage() {} +func (x *FiatWithdrawalEvent) Reset() { + *x = FiatWithdrawalEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[90] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FiatWithdrawalEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FiatWithdrawalEvent) ProtoMessage() {} + +func (x *FiatWithdrawalEvent) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[90] + 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 FiatWithdrawalEvent.ProtoReflect.Descriptor instead. func (*FiatWithdrawalEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{90} + return file_rpc_proto_rawDescGZIP(), []int{90} } -func (m *FiatWithdrawalEvent) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FiatWithdrawalEvent.Unmarshal(m, b) -} -func (m *FiatWithdrawalEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FiatWithdrawalEvent.Marshal(b, m, deterministic) -} -func (m *FiatWithdrawalEvent) XXX_Merge(src proto.Message) { - xxx_messageInfo_FiatWithdrawalEvent.Merge(m, src) -} -func (m *FiatWithdrawalEvent) XXX_Size() int { - return xxx_messageInfo_FiatWithdrawalEvent.Size(m) -} -func (m *FiatWithdrawalEvent) XXX_DiscardUnknown() { - xxx_messageInfo_FiatWithdrawalEvent.DiscardUnknown(m) -} - -var xxx_messageInfo_FiatWithdrawalEvent proto.InternalMessageInfo - -func (m *FiatWithdrawalEvent) GetBankName() string { - if m != nil { - return m.BankName +func (x *FiatWithdrawalEvent) GetBankName() string { + if x != nil { + return x.BankName } return "" } -func (m *FiatWithdrawalEvent) GetAccountName() string { - if m != nil { - return m.AccountName +func (x *FiatWithdrawalEvent) GetAccountName() string { + if x != nil { + return x.AccountName } return "" } -func (m *FiatWithdrawalEvent) GetAccountNumber() string { - if m != nil { - return m.AccountNumber +func (x *FiatWithdrawalEvent) GetAccountNumber() string { + if x != nil { + return x.AccountNumber } return "" } -func (m *FiatWithdrawalEvent) GetBsb() string { - if m != nil { - return m.Bsb +func (x *FiatWithdrawalEvent) GetBsb() string { + if x != nil { + return x.Bsb } return "" } -func (m *FiatWithdrawalEvent) GetSwift() string { - if m != nil { - return m.Swift +func (x *FiatWithdrawalEvent) GetSwift() string { + if x != nil { + return x.Swift } return "" } -func (m *FiatWithdrawalEvent) GetIban() string { - if m != nil { - return m.Iban +func (x *FiatWithdrawalEvent) GetIban() string { + if x != nil { + return x.Iban } return "" } type CryptoWithdrawalEvent struct { - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - AddressTag string `protobuf:"bytes,2,opt,name=address_tag,json=addressTag,proto3" json:"address_tag,omitempty"` - Fee float64 `protobuf:"fixed64,3,opt,name=fee,proto3" json:"fee,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + AddressTag string `protobuf:"bytes,2,opt,name=address_tag,json=addressTag,proto3" json:"address_tag,omitempty"` + Fee float64 `protobuf:"fixed64,3,opt,name=fee,proto3" json:"fee,omitempty"` } -func (m *CryptoWithdrawalEvent) Reset() { *m = CryptoWithdrawalEvent{} } -func (m *CryptoWithdrawalEvent) String() string { return proto.CompactTextString(m) } -func (*CryptoWithdrawalEvent) ProtoMessage() {} +func (x *CryptoWithdrawalEvent) Reset() { + *x = CryptoWithdrawalEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[91] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CryptoWithdrawalEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CryptoWithdrawalEvent) ProtoMessage() {} + +func (x *CryptoWithdrawalEvent) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[91] + 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 CryptoWithdrawalEvent.ProtoReflect.Descriptor instead. func (*CryptoWithdrawalEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{91} + return file_rpc_proto_rawDescGZIP(), []int{91} } -func (m *CryptoWithdrawalEvent) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_CryptoWithdrawalEvent.Unmarshal(m, b) -} -func (m *CryptoWithdrawalEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_CryptoWithdrawalEvent.Marshal(b, m, deterministic) -} -func (m *CryptoWithdrawalEvent) XXX_Merge(src proto.Message) { - xxx_messageInfo_CryptoWithdrawalEvent.Merge(m, src) -} -func (m *CryptoWithdrawalEvent) XXX_Size() int { - return xxx_messageInfo_CryptoWithdrawalEvent.Size(m) -} -func (m *CryptoWithdrawalEvent) XXX_DiscardUnknown() { - xxx_messageInfo_CryptoWithdrawalEvent.DiscardUnknown(m) -} - -var xxx_messageInfo_CryptoWithdrawalEvent proto.InternalMessageInfo - -func (m *CryptoWithdrawalEvent) GetAddress() string { - if m != nil { - return m.Address +func (x *CryptoWithdrawalEvent) GetAddress() string { + if x != nil { + return x.Address } return "" } -func (m *CryptoWithdrawalEvent) GetAddressTag() string { - if m != nil { - return m.AddressTag +func (x *CryptoWithdrawalEvent) GetAddressTag() string { + if x != nil { + return x.AddressTag } return "" } -func (m *CryptoWithdrawalEvent) GetFee() float64 { - if m != nil { - return m.Fee +func (x *CryptoWithdrawalEvent) GetFee() float64 { + if x != nil { + return x.Fee } return 0 } type GetLoggerDetailsRequest struct { - Logger string `protobuf:"bytes,1,opt,name=logger,proto3" json:"logger,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Logger string `protobuf:"bytes,1,opt,name=logger,proto3" json:"logger,omitempty"` } -func (m *GetLoggerDetailsRequest) Reset() { *m = GetLoggerDetailsRequest{} } -func (m *GetLoggerDetailsRequest) String() string { return proto.CompactTextString(m) } -func (*GetLoggerDetailsRequest) ProtoMessage() {} +func (x *GetLoggerDetailsRequest) Reset() { + *x = GetLoggerDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[92] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetLoggerDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLoggerDetailsRequest) ProtoMessage() {} + +func (x *GetLoggerDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[92] + 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 GetLoggerDetailsRequest.ProtoReflect.Descriptor instead. func (*GetLoggerDetailsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{92} + return file_rpc_proto_rawDescGZIP(), []int{92} } -func (m *GetLoggerDetailsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetLoggerDetailsRequest.Unmarshal(m, b) -} -func (m *GetLoggerDetailsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetLoggerDetailsRequest.Marshal(b, m, deterministic) -} -func (m *GetLoggerDetailsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetLoggerDetailsRequest.Merge(m, src) -} -func (m *GetLoggerDetailsRequest) XXX_Size() int { - return xxx_messageInfo_GetLoggerDetailsRequest.Size(m) -} -func (m *GetLoggerDetailsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetLoggerDetailsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetLoggerDetailsRequest proto.InternalMessageInfo - -func (m *GetLoggerDetailsRequest) GetLogger() string { - if m != nil { - return m.Logger +func (x *GetLoggerDetailsRequest) GetLogger() string { + if x != nil { + return x.Logger } return "" } type GetLoggerDetailsResponse struct { - Info bool `protobuf:"varint,1,opt,name=info,proto3" json:"info,omitempty"` - Debug bool `protobuf:"varint,2,opt,name=debug,proto3" json:"debug,omitempty"` - Warn bool `protobuf:"varint,3,opt,name=warn,proto3" json:"warn,omitempty"` - Error bool `protobuf:"varint,4,opt,name=error,proto3" json:"error,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Info bool `protobuf:"varint,1,opt,name=info,proto3" json:"info,omitempty"` + Debug bool `protobuf:"varint,2,opt,name=debug,proto3" json:"debug,omitempty"` + Warn bool `protobuf:"varint,3,opt,name=warn,proto3" json:"warn,omitempty"` + Error bool `protobuf:"varint,4,opt,name=error,proto3" json:"error,omitempty"` } -func (m *GetLoggerDetailsResponse) Reset() { *m = GetLoggerDetailsResponse{} } -func (m *GetLoggerDetailsResponse) String() string { return proto.CompactTextString(m) } -func (*GetLoggerDetailsResponse) ProtoMessage() {} +func (x *GetLoggerDetailsResponse) Reset() { + *x = GetLoggerDetailsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[93] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetLoggerDetailsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLoggerDetailsResponse) ProtoMessage() {} + +func (x *GetLoggerDetailsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[93] + 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 GetLoggerDetailsResponse.ProtoReflect.Descriptor instead. func (*GetLoggerDetailsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{93} + return file_rpc_proto_rawDescGZIP(), []int{93} } -func (m *GetLoggerDetailsResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetLoggerDetailsResponse.Unmarshal(m, b) -} -func (m *GetLoggerDetailsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetLoggerDetailsResponse.Marshal(b, m, deterministic) -} -func (m *GetLoggerDetailsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetLoggerDetailsResponse.Merge(m, src) -} -func (m *GetLoggerDetailsResponse) XXX_Size() int { - return xxx_messageInfo_GetLoggerDetailsResponse.Size(m) -} -func (m *GetLoggerDetailsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetLoggerDetailsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetLoggerDetailsResponse proto.InternalMessageInfo - -func (m *GetLoggerDetailsResponse) GetInfo() bool { - if m != nil { - return m.Info +func (x *GetLoggerDetailsResponse) GetInfo() bool { + if x != nil { + return x.Info } return false } -func (m *GetLoggerDetailsResponse) GetDebug() bool { - if m != nil { - return m.Debug +func (x *GetLoggerDetailsResponse) GetDebug() bool { + if x != nil { + return x.Debug } return false } -func (m *GetLoggerDetailsResponse) GetWarn() bool { - if m != nil { - return m.Warn +func (x *GetLoggerDetailsResponse) GetWarn() bool { + if x != nil { + return x.Warn } return false } -func (m *GetLoggerDetailsResponse) GetError() bool { - if m != nil { - return m.Error +func (x *GetLoggerDetailsResponse) GetError() bool { + if x != nil { + return x.Error } return false } type SetLoggerDetailsRequest struct { - Logger string `protobuf:"bytes,1,opt,name=logger,proto3" json:"logger,omitempty"` - Level string `protobuf:"bytes,2,opt,name=level,proto3" json:"level,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Logger string `protobuf:"bytes,1,opt,name=logger,proto3" json:"logger,omitempty"` + Level string `protobuf:"bytes,2,opt,name=level,proto3" json:"level,omitempty"` } -func (m *SetLoggerDetailsRequest) Reset() { *m = SetLoggerDetailsRequest{} } -func (m *SetLoggerDetailsRequest) String() string { return proto.CompactTextString(m) } -func (*SetLoggerDetailsRequest) ProtoMessage() {} +func (x *SetLoggerDetailsRequest) Reset() { + *x = SetLoggerDetailsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[94] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetLoggerDetailsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetLoggerDetailsRequest) ProtoMessage() {} + +func (x *SetLoggerDetailsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[94] + 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 SetLoggerDetailsRequest.ProtoReflect.Descriptor instead. func (*SetLoggerDetailsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{94} + return file_rpc_proto_rawDescGZIP(), []int{94} } -func (m *SetLoggerDetailsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetLoggerDetailsRequest.Unmarshal(m, b) -} -func (m *SetLoggerDetailsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetLoggerDetailsRequest.Marshal(b, m, deterministic) -} -func (m *SetLoggerDetailsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetLoggerDetailsRequest.Merge(m, src) -} -func (m *SetLoggerDetailsRequest) XXX_Size() int { - return xxx_messageInfo_SetLoggerDetailsRequest.Size(m) -} -func (m *SetLoggerDetailsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SetLoggerDetailsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_SetLoggerDetailsRequest proto.InternalMessageInfo - -func (m *SetLoggerDetailsRequest) GetLogger() string { - if m != nil { - return m.Logger +func (x *SetLoggerDetailsRequest) GetLogger() string { + if x != nil { + return x.Logger } return "" } -func (m *SetLoggerDetailsRequest) GetLevel() string { - if m != nil { - return m.Level +func (x *SetLoggerDetailsRequest) GetLevel() string { + if x != nil { + return x.Level } return "" } type GetExchangePairsRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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 (m *GetExchangePairsRequest) Reset() { *m = GetExchangePairsRequest{} } -func (m *GetExchangePairsRequest) String() string { return proto.CompactTextString(m) } -func (*GetExchangePairsRequest) ProtoMessage() {} +func (x *GetExchangePairsRequest) Reset() { + *x = GetExchangePairsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[95] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangePairsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangePairsRequest) ProtoMessage() {} + +func (x *GetExchangePairsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[95] + 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 GetExchangePairsRequest.ProtoReflect.Descriptor instead. func (*GetExchangePairsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{95} + return file_rpc_proto_rawDescGZIP(), []int{95} } -func (m *GetExchangePairsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangePairsRequest.Unmarshal(m, b) -} -func (m *GetExchangePairsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangePairsRequest.Marshal(b, m, deterministic) -} -func (m *GetExchangePairsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangePairsRequest.Merge(m, src) -} -func (m *GetExchangePairsRequest) XXX_Size() int { - return xxx_messageInfo_GetExchangePairsRequest.Size(m) -} -func (m *GetExchangePairsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangePairsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangePairsRequest proto.InternalMessageInfo - -func (m *GetExchangePairsRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetExchangePairsRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetExchangePairsRequest) GetAsset() string { - if m != nil { - return m.Asset +func (x *GetExchangePairsRequest) GetAsset() string { + if x != nil { + return x.Asset } return "" } type GetExchangePairsResponse struct { - SupportedAssets map[string]*PairsSupported `protobuf:"bytes,1,rep,name=supported_assets,json=supportedAssets,proto3" json:"supported_assets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SupportedAssets map[string]*PairsSupported `protobuf:"bytes,1,rep,name=supported_assets,json=supportedAssets,proto3" json:"supported_assets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } -func (m *GetExchangePairsResponse) Reset() { *m = GetExchangePairsResponse{} } -func (m *GetExchangePairsResponse) String() string { return proto.CompactTextString(m) } -func (*GetExchangePairsResponse) ProtoMessage() {} +func (x *GetExchangePairsResponse) Reset() { + *x = GetExchangePairsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[96] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangePairsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangePairsResponse) ProtoMessage() {} + +func (x *GetExchangePairsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[96] + 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 GetExchangePairsResponse.ProtoReflect.Descriptor instead. func (*GetExchangePairsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{96} + return file_rpc_proto_rawDescGZIP(), []int{96} } -func (m *GetExchangePairsResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangePairsResponse.Unmarshal(m, b) -} -func (m *GetExchangePairsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangePairsResponse.Marshal(b, m, deterministic) -} -func (m *GetExchangePairsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangePairsResponse.Merge(m, src) -} -func (m *GetExchangePairsResponse) XXX_Size() int { - return xxx_messageInfo_GetExchangePairsResponse.Size(m) -} -func (m *GetExchangePairsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangePairsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangePairsResponse proto.InternalMessageInfo - -func (m *GetExchangePairsResponse) GetSupportedAssets() map[string]*PairsSupported { - if m != nil { - return m.SupportedAssets +func (x *GetExchangePairsResponse) GetSupportedAssets() map[string]*PairsSupported { + if x != nil { + return x.SupportedAssets } return nil } type SetExchangePairRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - AssetType string `protobuf:"bytes,2,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` - Pairs []*CurrencyPair `protobuf:"bytes,3,rep,name=pairs,proto3" json:"pairs,omitempty"` - Enable bool `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + AssetType string `protobuf:"bytes,2,opt,name=asset_type,json=assetType,proto3" json:"asset_type,omitempty"` + Pairs []*CurrencyPair `protobuf:"bytes,3,rep,name=pairs,proto3" json:"pairs,omitempty"` + Enable bool `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"` } -func (m *SetExchangePairRequest) Reset() { *m = SetExchangePairRequest{} } -func (m *SetExchangePairRequest) String() string { return proto.CompactTextString(m) } -func (*SetExchangePairRequest) ProtoMessage() {} +func (x *SetExchangePairRequest) Reset() { + *x = SetExchangePairRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[97] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetExchangePairRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetExchangePairRequest) ProtoMessage() {} + +func (x *SetExchangePairRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[97] + 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 SetExchangePairRequest.ProtoReflect.Descriptor instead. func (*SetExchangePairRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{97} + return file_rpc_proto_rawDescGZIP(), []int{97} } -func (m *SetExchangePairRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetExchangePairRequest.Unmarshal(m, b) -} -func (m *SetExchangePairRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetExchangePairRequest.Marshal(b, m, deterministic) -} -func (m *SetExchangePairRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetExchangePairRequest.Merge(m, src) -} -func (m *SetExchangePairRequest) XXX_Size() int { - return xxx_messageInfo_SetExchangePairRequest.Size(m) -} -func (m *SetExchangePairRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SetExchangePairRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_SetExchangePairRequest proto.InternalMessageInfo - -func (m *SetExchangePairRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *SetExchangePairRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *SetExchangePairRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *SetExchangePairRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } -func (m *SetExchangePairRequest) GetPairs() []*CurrencyPair { - if m != nil { - return m.Pairs +func (x *SetExchangePairRequest) GetPairs() []*CurrencyPair { + if x != nil { + return x.Pairs } return nil } -func (m *SetExchangePairRequest) GetEnable() bool { - if m != nil { - return m.Enable +func (x *SetExchangePairRequest) GetEnable() bool { + if x != nil { + return x.Enable } return false } type GetOrderbookStreamRequest struct { - 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"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` } -func (m *GetOrderbookStreamRequest) Reset() { *m = GetOrderbookStreamRequest{} } -func (m *GetOrderbookStreamRequest) String() string { return proto.CompactTextString(m) } -func (*GetOrderbookStreamRequest) ProtoMessage() {} +func (x *GetOrderbookStreamRequest) Reset() { + *x = GetOrderbookStreamRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[98] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetOrderbookStreamRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOrderbookStreamRequest) ProtoMessage() {} + +func (x *GetOrderbookStreamRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[98] + 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 GetOrderbookStreamRequest.ProtoReflect.Descriptor instead. func (*GetOrderbookStreamRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{98} + return file_rpc_proto_rawDescGZIP(), []int{98} } -func (m *GetOrderbookStreamRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetOrderbookStreamRequest.Unmarshal(m, b) -} -func (m *GetOrderbookStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetOrderbookStreamRequest.Marshal(b, m, deterministic) -} -func (m *GetOrderbookStreamRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOrderbookStreamRequest.Merge(m, src) -} -func (m *GetOrderbookStreamRequest) XXX_Size() int { - return xxx_messageInfo_GetOrderbookStreamRequest.Size(m) -} -func (m *GetOrderbookStreamRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetOrderbookStreamRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetOrderbookStreamRequest proto.InternalMessageInfo - -func (m *GetOrderbookStreamRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetOrderbookStreamRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetOrderbookStreamRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *GetOrderbookStreamRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *GetOrderbookStreamRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *GetOrderbookStreamRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } type GetExchangeOrderbookStreamRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *GetExchangeOrderbookStreamRequest) Reset() { *m = GetExchangeOrderbookStreamRequest{} } -func (m *GetExchangeOrderbookStreamRequest) String() string { return proto.CompactTextString(m) } -func (*GetExchangeOrderbookStreamRequest) ProtoMessage() {} +func (x *GetExchangeOrderbookStreamRequest) Reset() { + *x = GetExchangeOrderbookStreamRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[99] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangeOrderbookStreamRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangeOrderbookStreamRequest) ProtoMessage() {} + +func (x *GetExchangeOrderbookStreamRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[99] + 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 GetExchangeOrderbookStreamRequest.ProtoReflect.Descriptor instead. func (*GetExchangeOrderbookStreamRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{99} + return file_rpc_proto_rawDescGZIP(), []int{99} } -func (m *GetExchangeOrderbookStreamRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangeOrderbookStreamRequest.Unmarshal(m, b) -} -func (m *GetExchangeOrderbookStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangeOrderbookStreamRequest.Marshal(b, m, deterministic) -} -func (m *GetExchangeOrderbookStreamRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangeOrderbookStreamRequest.Merge(m, src) -} -func (m *GetExchangeOrderbookStreamRequest) XXX_Size() int { - return xxx_messageInfo_GetExchangeOrderbookStreamRequest.Size(m) -} -func (m *GetExchangeOrderbookStreamRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangeOrderbookStreamRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangeOrderbookStreamRequest proto.InternalMessageInfo - -func (m *GetExchangeOrderbookStreamRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetExchangeOrderbookStreamRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type GetTickerStreamRequest struct { - 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"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` } -func (m *GetTickerStreamRequest) Reset() { *m = GetTickerStreamRequest{} } -func (m *GetTickerStreamRequest) String() string { return proto.CompactTextString(m) } -func (*GetTickerStreamRequest) ProtoMessage() {} +func (x *GetTickerStreamRequest) Reset() { + *x = GetTickerStreamRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[100] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetTickerStreamRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetTickerStreamRequest) ProtoMessage() {} + +func (x *GetTickerStreamRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[100] + 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 GetTickerStreamRequest.ProtoReflect.Descriptor instead. func (*GetTickerStreamRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{100} + return file_rpc_proto_rawDescGZIP(), []int{100} } -func (m *GetTickerStreamRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetTickerStreamRequest.Unmarshal(m, b) -} -func (m *GetTickerStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetTickerStreamRequest.Marshal(b, m, deterministic) -} -func (m *GetTickerStreamRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetTickerStreamRequest.Merge(m, src) -} -func (m *GetTickerStreamRequest) XXX_Size() int { - return xxx_messageInfo_GetTickerStreamRequest.Size(m) -} -func (m *GetTickerStreamRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetTickerStreamRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetTickerStreamRequest proto.InternalMessageInfo - -func (m *GetTickerStreamRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetTickerStreamRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetTickerStreamRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *GetTickerStreamRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *GetTickerStreamRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *GetTickerStreamRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } type GetExchangeTickerStreamRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *GetExchangeTickerStreamRequest) Reset() { *m = GetExchangeTickerStreamRequest{} } -func (m *GetExchangeTickerStreamRequest) String() string { return proto.CompactTextString(m) } -func (*GetExchangeTickerStreamRequest) ProtoMessage() {} +func (x *GetExchangeTickerStreamRequest) Reset() { + *x = GetExchangeTickerStreamRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[101] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangeTickerStreamRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangeTickerStreamRequest) ProtoMessage() {} + +func (x *GetExchangeTickerStreamRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[101] + 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 GetExchangeTickerStreamRequest.ProtoReflect.Descriptor instead. func (*GetExchangeTickerStreamRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{101} + return file_rpc_proto_rawDescGZIP(), []int{101} } -func (m *GetExchangeTickerStreamRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangeTickerStreamRequest.Unmarshal(m, b) -} -func (m *GetExchangeTickerStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangeTickerStreamRequest.Marshal(b, m, deterministic) -} -func (m *GetExchangeTickerStreamRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangeTickerStreamRequest.Merge(m, src) -} -func (m *GetExchangeTickerStreamRequest) XXX_Size() int { - return xxx_messageInfo_GetExchangeTickerStreamRequest.Size(m) -} -func (m *GetExchangeTickerStreamRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangeTickerStreamRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangeTickerStreamRequest proto.InternalMessageInfo - -func (m *GetExchangeTickerStreamRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetExchangeTickerStreamRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type GetAuditEventRequest struct { - StartDate string `protobuf:"bytes,1,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` - EndDate string `protobuf:"bytes,2,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` - OrderBy string `protobuf:"bytes,3,opt,name=order_by,json=orderBy,proto3" json:"order_by,omitempty"` - Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` - Offset int32 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StartDate string `protobuf:"bytes,1,opt,name=start_date,json=startDate,proto3" json:"start_date,omitempty"` + EndDate string `protobuf:"bytes,2,opt,name=end_date,json=endDate,proto3" json:"end_date,omitempty"` + OrderBy string `protobuf:"bytes,3,opt,name=order_by,json=orderBy,proto3" json:"order_by,omitempty"` + Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` + Offset int32 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"` } -func (m *GetAuditEventRequest) Reset() { *m = GetAuditEventRequest{} } -func (m *GetAuditEventRequest) String() string { return proto.CompactTextString(m) } -func (*GetAuditEventRequest) ProtoMessage() {} +func (x *GetAuditEventRequest) Reset() { + *x = GetAuditEventRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[102] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAuditEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAuditEventRequest) ProtoMessage() {} + +func (x *GetAuditEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[102] + 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 GetAuditEventRequest.ProtoReflect.Descriptor instead. func (*GetAuditEventRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{102} + return file_rpc_proto_rawDescGZIP(), []int{102} } -func (m *GetAuditEventRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetAuditEventRequest.Unmarshal(m, b) -} -func (m *GetAuditEventRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetAuditEventRequest.Marshal(b, m, deterministic) -} -func (m *GetAuditEventRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAuditEventRequest.Merge(m, src) -} -func (m *GetAuditEventRequest) XXX_Size() int { - return xxx_messageInfo_GetAuditEventRequest.Size(m) -} -func (m *GetAuditEventRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetAuditEventRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetAuditEventRequest proto.InternalMessageInfo - -func (m *GetAuditEventRequest) GetStartDate() string { - if m != nil { - return m.StartDate +func (x *GetAuditEventRequest) GetStartDate() string { + if x != nil { + return x.StartDate } return "" } -func (m *GetAuditEventRequest) GetEndDate() string { - if m != nil { - return m.EndDate +func (x *GetAuditEventRequest) GetEndDate() string { + if x != nil { + return x.EndDate } return "" } -func (m *GetAuditEventRequest) GetOrderBy() string { - if m != nil { - return m.OrderBy +func (x *GetAuditEventRequest) GetOrderBy() string { + if x != nil { + return x.OrderBy } return "" } -func (m *GetAuditEventRequest) GetLimit() int32 { - if m != nil { - return m.Limit +func (x *GetAuditEventRequest) GetLimit() int32 { + if x != nil { + return x.Limit } return 0 } -func (m *GetAuditEventRequest) GetOffset() int32 { - if m != nil { - return m.Offset +func (x *GetAuditEventRequest) GetOffset() int32 { + if x != nil { + return x.Offset } return 0 } type GetAuditEventResponse struct { - Events []*AuditEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Events []*AuditEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` } -func (m *GetAuditEventResponse) Reset() { *m = GetAuditEventResponse{} } -func (m *GetAuditEventResponse) String() string { return proto.CompactTextString(m) } -func (*GetAuditEventResponse) ProtoMessage() {} +func (x *GetAuditEventResponse) Reset() { + *x = GetAuditEventResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[103] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAuditEventResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAuditEventResponse) ProtoMessage() {} + +func (x *GetAuditEventResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[103] + 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 GetAuditEventResponse.ProtoReflect.Descriptor instead. func (*GetAuditEventResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{103} + return file_rpc_proto_rawDescGZIP(), []int{103} } -func (m *GetAuditEventResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetAuditEventResponse.Unmarshal(m, b) -} -func (m *GetAuditEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetAuditEventResponse.Marshal(b, m, deterministic) -} -func (m *GetAuditEventResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAuditEventResponse.Merge(m, src) -} -func (m *GetAuditEventResponse) XXX_Size() int { - return xxx_messageInfo_GetAuditEventResponse.Size(m) -} -func (m *GetAuditEventResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetAuditEventResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetAuditEventResponse proto.InternalMessageInfo - -func (m *GetAuditEventResponse) GetEvents() []*AuditEvent { - if m != nil { - return m.Events +func (x *GetAuditEventResponse) GetEvents() []*AuditEvent { + if x != nil { + return x.Events } return nil } type GetHistoricCandlesRequest struct { - 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"` - Start int64 `protobuf:"varint,4,opt,name=start,proto3" json:"start,omitempty"` - End int64 `protobuf:"varint,5,opt,name=end,proto3" json:"end,omitempty"` - TimeInterval int64 `protobuf:"varint,6,opt,name=time_interval,json=timeInterval,proto3" json:"time_interval,omitempty"` - ExRequest bool `protobuf:"varint,7,opt,name=ex_request,json=exRequest,proto3" json:"ex_request,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` + Start int64 `protobuf:"varint,4,opt,name=start,proto3" json:"start,omitempty"` + End int64 `protobuf:"varint,5,opt,name=end,proto3" json:"end,omitempty"` + TimeInterval int64 `protobuf:"varint,6,opt,name=time_interval,json=timeInterval,proto3" json:"time_interval,omitempty"` + ExRequest bool `protobuf:"varint,7,opt,name=ex_request,json=exRequest,proto3" json:"ex_request,omitempty"` + Sync bool `protobuf:"varint,8,opt,name=sync,proto3" json:"sync,omitempty"` + UseDb bool `protobuf:"varint,9,opt,name=use_db,json=useDb,proto3" json:"use_db,omitempty"` } -func (m *GetHistoricCandlesRequest) Reset() { *m = GetHistoricCandlesRequest{} } -func (m *GetHistoricCandlesRequest) String() string { return proto.CompactTextString(m) } -func (*GetHistoricCandlesRequest) ProtoMessage() {} +func (x *GetHistoricCandlesRequest) Reset() { + *x = GetHistoricCandlesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[104] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetHistoricCandlesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetHistoricCandlesRequest) ProtoMessage() {} + +func (x *GetHistoricCandlesRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[104] + 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 GetHistoricCandlesRequest.ProtoReflect.Descriptor instead. func (*GetHistoricCandlesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{104} + return file_rpc_proto_rawDescGZIP(), []int{104} } -func (m *GetHistoricCandlesRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetHistoricCandlesRequest.Unmarshal(m, b) -} -func (m *GetHistoricCandlesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetHistoricCandlesRequest.Marshal(b, m, deterministic) -} -func (m *GetHistoricCandlesRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetHistoricCandlesRequest.Merge(m, src) -} -func (m *GetHistoricCandlesRequest) XXX_Size() int { - return xxx_messageInfo_GetHistoricCandlesRequest.Size(m) -} -func (m *GetHistoricCandlesRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetHistoricCandlesRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetHistoricCandlesRequest proto.InternalMessageInfo - -func (m *GetHistoricCandlesRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetHistoricCandlesRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetHistoricCandlesRequest) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *GetHistoricCandlesRequest) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *GetHistoricCandlesRequest) GetAssetType() string { - if m != nil { - return m.AssetType +func (x *GetHistoricCandlesRequest) GetAssetType() string { + if x != nil { + return x.AssetType } return "" } -func (m *GetHistoricCandlesRequest) GetStart() int64 { - if m != nil { - return m.Start +func (x *GetHistoricCandlesRequest) GetStart() int64 { + if x != nil { + return x.Start } return 0 } -func (m *GetHistoricCandlesRequest) GetEnd() int64 { - if m != nil { - return m.End +func (x *GetHistoricCandlesRequest) GetEnd() int64 { + if x != nil { + return x.End } return 0 } -func (m *GetHistoricCandlesRequest) GetTimeInterval() int64 { - if m != nil { - return m.TimeInterval +func (x *GetHistoricCandlesRequest) GetTimeInterval() int64 { + if x != nil { + return x.TimeInterval } return 0 } -func (m *GetHistoricCandlesRequest) GetExRequest() bool { - if m != nil { - return m.ExRequest +func (x *GetHistoricCandlesRequest) GetExRequest() bool { + if x != nil { + return x.ExRequest + } + return false +} + +func (x *GetHistoricCandlesRequest) GetSync() bool { + if x != nil { + return x.Sync + } + return false +} + +func (x *GetHistoricCandlesRequest) GetUseDb() bool { + if x != nil { + return x.UseDb } return false } type GetHistoricCandlesResponse struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"` - Start int64 `protobuf:"varint,3,opt,name=start,proto3" json:"start,omitempty"` - End int64 `protobuf:"varint,4,opt,name=end,proto3" json:"end,omitempty"` - Interval string `protobuf:"bytes,6,opt,name=interval,proto3" json:"interval,omitempty"` - Candle []*Candle `protobuf:"bytes,5,rep,name=candle,proto3" json:"candle,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` + Start int64 `protobuf:"varint,3,opt,name=start,proto3" json:"start,omitempty"` + End int64 `protobuf:"varint,4,opt,name=end,proto3" json:"end,omitempty"` + Interval string `protobuf:"bytes,6,opt,name=interval,proto3" json:"interval,omitempty"` + Candle []*Candle `protobuf:"bytes,5,rep,name=candle,proto3" json:"candle,omitempty"` } -func (m *GetHistoricCandlesResponse) Reset() { *m = GetHistoricCandlesResponse{} } -func (m *GetHistoricCandlesResponse) String() string { return proto.CompactTextString(m) } -func (*GetHistoricCandlesResponse) ProtoMessage() {} +func (x *GetHistoricCandlesResponse) Reset() { + *x = GetHistoricCandlesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[105] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetHistoricCandlesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetHistoricCandlesResponse) ProtoMessage() {} + +func (x *GetHistoricCandlesResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[105] + 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 GetHistoricCandlesResponse.ProtoReflect.Descriptor instead. func (*GetHistoricCandlesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{105} + return file_rpc_proto_rawDescGZIP(), []int{105} } -func (m *GetHistoricCandlesResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetHistoricCandlesResponse.Unmarshal(m, b) -} -func (m *GetHistoricCandlesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetHistoricCandlesResponse.Marshal(b, m, deterministic) -} -func (m *GetHistoricCandlesResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetHistoricCandlesResponse.Merge(m, src) -} -func (m *GetHistoricCandlesResponse) XXX_Size() int { - return xxx_messageInfo_GetHistoricCandlesResponse.Size(m) -} -func (m *GetHistoricCandlesResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetHistoricCandlesResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetHistoricCandlesResponse proto.InternalMessageInfo - -func (m *GetHistoricCandlesResponse) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetHistoricCandlesResponse) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *GetHistoricCandlesResponse) GetPair() *CurrencyPair { - if m != nil { - return m.Pair +func (x *GetHistoricCandlesResponse) GetPair() *CurrencyPair { + if x != nil { + return x.Pair } return nil } -func (m *GetHistoricCandlesResponse) GetStart() int64 { - if m != nil { - return m.Start +func (x *GetHistoricCandlesResponse) GetStart() int64 { + if x != nil { + return x.Start } return 0 } -func (m *GetHistoricCandlesResponse) GetEnd() int64 { - if m != nil { - return m.End +func (x *GetHistoricCandlesResponse) GetEnd() int64 { + if x != nil { + return x.End } return 0 } -func (m *GetHistoricCandlesResponse) GetInterval() string { - if m != nil { - return m.Interval +func (x *GetHistoricCandlesResponse) GetInterval() string { + if x != nil { + return x.Interval } return "" } -func (m *GetHistoricCandlesResponse) GetCandle() []*Candle { - if m != nil { - return m.Candle +func (x *GetHistoricCandlesResponse) GetCandle() []*Candle { + if x != nil { + return x.Candle } return nil } type Candle struct { - Time int64 `protobuf:"varint,1,opt,name=time,proto3" json:"time,omitempty"` - Low float64 `protobuf:"fixed64,2,opt,name=low,proto3" json:"low,omitempty"` - High float64 `protobuf:"fixed64,3,opt,name=high,proto3" json:"high,omitempty"` - Open float64 `protobuf:"fixed64,4,opt,name=open,proto3" json:"open,omitempty"` - Close float64 `protobuf:"fixed64,5,opt,name=close,proto3" json:"close,omitempty"` - Volume float64 `protobuf:"fixed64,6,opt,name=volume,proto3" json:"volume,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Time int64 `protobuf:"varint,1,opt,name=time,proto3" json:"time,omitempty"` + Low float64 `protobuf:"fixed64,2,opt,name=low,proto3" json:"low,omitempty"` + High float64 `protobuf:"fixed64,3,opt,name=high,proto3" json:"high,omitempty"` + Open float64 `protobuf:"fixed64,4,opt,name=open,proto3" json:"open,omitempty"` + Close float64 `protobuf:"fixed64,5,opt,name=close,proto3" json:"close,omitempty"` + Volume float64 `protobuf:"fixed64,6,opt,name=volume,proto3" json:"volume,omitempty"` } -func (m *Candle) Reset() { *m = Candle{} } -func (m *Candle) String() string { return proto.CompactTextString(m) } -func (*Candle) ProtoMessage() {} +func (x *Candle) Reset() { + *x = Candle{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[106] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Candle) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Candle) ProtoMessage() {} + +func (x *Candle) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[106] + 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 Candle.ProtoReflect.Descriptor instead. func (*Candle) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{106} + return file_rpc_proto_rawDescGZIP(), []int{106} } -func (m *Candle) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_Candle.Unmarshal(m, b) -} -func (m *Candle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_Candle.Marshal(b, m, deterministic) -} -func (m *Candle) XXX_Merge(src proto.Message) { - xxx_messageInfo_Candle.Merge(m, src) -} -func (m *Candle) XXX_Size() int { - return xxx_messageInfo_Candle.Size(m) -} -func (m *Candle) XXX_DiscardUnknown() { - xxx_messageInfo_Candle.DiscardUnknown(m) -} - -var xxx_messageInfo_Candle proto.InternalMessageInfo - -func (m *Candle) GetTime() int64 { - if m != nil { - return m.Time +func (x *Candle) GetTime() int64 { + if x != nil { + return x.Time } return 0 } -func (m *Candle) GetLow() float64 { - if m != nil { - return m.Low +func (x *Candle) GetLow() float64 { + if x != nil { + return x.Low } return 0 } -func (m *Candle) GetHigh() float64 { - if m != nil { - return m.High +func (x *Candle) GetHigh() float64 { + if x != nil { + return x.High } return 0 } -func (m *Candle) GetOpen() float64 { - if m != nil { - return m.Open +func (x *Candle) GetOpen() float64 { + if x != nil { + return x.Open } return 0 } -func (m *Candle) GetClose() float64 { - if m != nil { - return m.Close +func (x *Candle) GetClose() float64 { + if x != nil { + return x.Close } return 0 } -func (m *Candle) GetVolume() float64 { - if m != nil { - return m.Volume +func (x *Candle) GetVolume() float64 { + if x != nil { + return x.Volume } return 0 } type AuditEvent struct { - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - Identifier string `protobuf:"bytes,2,opt,name=identifier,proto3" json:"identifier,omitempty"` - Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"` - Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + Identifier string `protobuf:"bytes,2,opt,name=identifier,proto3" json:"identifier,omitempty"` + Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"` + Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` } -func (m *AuditEvent) Reset() { *m = AuditEvent{} } -func (m *AuditEvent) String() string { return proto.CompactTextString(m) } -func (*AuditEvent) ProtoMessage() {} +func (x *AuditEvent) Reset() { + *x = AuditEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[107] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AuditEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AuditEvent) ProtoMessage() {} + +func (x *AuditEvent) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[107] + 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 AuditEvent.ProtoReflect.Descriptor instead. func (*AuditEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{107} + return file_rpc_proto_rawDescGZIP(), []int{107} } -func (m *AuditEvent) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AuditEvent.Unmarshal(m, b) -} -func (m *AuditEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AuditEvent.Marshal(b, m, deterministic) -} -func (m *AuditEvent) XXX_Merge(src proto.Message) { - xxx_messageInfo_AuditEvent.Merge(m, src) -} -func (m *AuditEvent) XXX_Size() int { - return xxx_messageInfo_AuditEvent.Size(m) -} -func (m *AuditEvent) XXX_DiscardUnknown() { - xxx_messageInfo_AuditEvent.DiscardUnknown(m) -} - -var xxx_messageInfo_AuditEvent proto.InternalMessageInfo - -func (m *AuditEvent) GetType() string { - if m != nil { - return m.Type +func (x *AuditEvent) GetType() string { + if x != nil { + return x.Type } return "" } -func (m *AuditEvent) GetIdentifier() string { - if m != nil { - return m.Identifier +func (x *AuditEvent) GetIdentifier() string { + if x != nil { + return x.Identifier } return "" } -func (m *AuditEvent) GetMessage() string { - if m != nil { - return m.Message +func (x *AuditEvent) GetMessage() string { + if x != nil { + return x.Message } return "" } -func (m *AuditEvent) GetTimestamp() string { - if m != nil { - return m.Timestamp +func (x *AuditEvent) GetTimestamp() string { + if x != nil { + return x.Timestamp } return "" } type GCTScript struct { - UUID string `protobuf:"bytes,1,opt,name=UUID,proto3" json:"UUID,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"` - NextRun string `protobuf:"bytes,4,opt,name=next_run,json=nextRun,proto3" json:"next_run,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UUID string `protobuf:"bytes,1,opt,name=UUID,proto3" json:"UUID,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"` + NextRun string `protobuf:"bytes,4,opt,name=next_run,json=nextRun,proto3" json:"next_run,omitempty"` } -func (m *GCTScript) Reset() { *m = GCTScript{} } -func (m *GCTScript) String() string { return proto.CompactTextString(m) } -func (*GCTScript) ProtoMessage() {} +func (x *GCTScript) Reset() { + *x = GCTScript{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[108] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScript) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScript) ProtoMessage() {} + +func (x *GCTScript) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[108] + 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 GCTScript.ProtoReflect.Descriptor instead. func (*GCTScript) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{108} + return file_rpc_proto_rawDescGZIP(), []int{108} } -func (m *GCTScript) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScript.Unmarshal(m, b) -} -func (m *GCTScript) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScript.Marshal(b, m, deterministic) -} -func (m *GCTScript) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScript.Merge(m, src) -} -func (m *GCTScript) XXX_Size() int { - return xxx_messageInfo_GCTScript.Size(m) -} -func (m *GCTScript) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScript.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScript proto.InternalMessageInfo - -func (m *GCTScript) GetUUID() string { - if m != nil { - return m.UUID +func (x *GCTScript) GetUUID() string { + if x != nil { + return x.UUID } return "" } -func (m *GCTScript) GetName() string { - if m != nil { - return m.Name +func (x *GCTScript) GetName() string { + if x != nil { + return x.Name } return "" } -func (m *GCTScript) GetPath() string { - if m != nil { - return m.Path +func (x *GCTScript) GetPath() string { + if x != nil { + return x.Path } return "" } -func (m *GCTScript) GetNextRun() string { - if m != nil { - return m.NextRun +func (x *GCTScript) GetNextRun() string { + if x != nil { + return x.NextRun } return "" } type GCTScriptExecuteRequest struct { - Script *GCTScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Script *GCTScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` } -func (m *GCTScriptExecuteRequest) Reset() { *m = GCTScriptExecuteRequest{} } -func (m *GCTScriptExecuteRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptExecuteRequest) ProtoMessage() {} +func (x *GCTScriptExecuteRequest) Reset() { + *x = GCTScriptExecuteRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[109] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptExecuteRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptExecuteRequest) ProtoMessage() {} + +func (x *GCTScriptExecuteRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[109] + 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 GCTScriptExecuteRequest.ProtoReflect.Descriptor instead. func (*GCTScriptExecuteRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{109} + return file_rpc_proto_rawDescGZIP(), []int{109} } -func (m *GCTScriptExecuteRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptExecuteRequest.Unmarshal(m, b) -} -func (m *GCTScriptExecuteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptExecuteRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptExecuteRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptExecuteRequest.Merge(m, src) -} -func (m *GCTScriptExecuteRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptExecuteRequest.Size(m) -} -func (m *GCTScriptExecuteRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptExecuteRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptExecuteRequest proto.InternalMessageInfo - -func (m *GCTScriptExecuteRequest) GetScript() *GCTScript { - if m != nil { - return m.Script +func (x *GCTScriptExecuteRequest) GetScript() *GCTScript { + if x != nil { + return x.Script } return nil } type GCTScriptStopRequest struct { - Script *GCTScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Script *GCTScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` } -func (m *GCTScriptStopRequest) Reset() { *m = GCTScriptStopRequest{} } -func (m *GCTScriptStopRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptStopRequest) ProtoMessage() {} +func (x *GCTScriptStopRequest) Reset() { + *x = GCTScriptStopRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[110] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptStopRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptStopRequest) ProtoMessage() {} + +func (x *GCTScriptStopRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[110] + 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 GCTScriptStopRequest.ProtoReflect.Descriptor instead. func (*GCTScriptStopRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{110} + return file_rpc_proto_rawDescGZIP(), []int{110} } -func (m *GCTScriptStopRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptStopRequest.Unmarshal(m, b) -} -func (m *GCTScriptStopRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptStopRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptStopRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptStopRequest.Merge(m, src) -} -func (m *GCTScriptStopRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptStopRequest.Size(m) -} -func (m *GCTScriptStopRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptStopRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptStopRequest proto.InternalMessageInfo - -func (m *GCTScriptStopRequest) GetScript() *GCTScript { - if m != nil { - return m.Script +func (x *GCTScriptStopRequest) GetScript() *GCTScript { + if x != nil { + return x.Script } return nil } type GCTScriptStopAllRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GCTScriptStopAllRequest) Reset() { *m = GCTScriptStopAllRequest{} } -func (m *GCTScriptStopAllRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptStopAllRequest) ProtoMessage() {} +func (x *GCTScriptStopAllRequest) Reset() { + *x = GCTScriptStopAllRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[111] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptStopAllRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptStopAllRequest) ProtoMessage() {} + +func (x *GCTScriptStopAllRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[111] + 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 GCTScriptStopAllRequest.ProtoReflect.Descriptor instead. func (*GCTScriptStopAllRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{111} + return file_rpc_proto_rawDescGZIP(), []int{111} } -func (m *GCTScriptStopAllRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptStopAllRequest.Unmarshal(m, b) -} -func (m *GCTScriptStopAllRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptStopAllRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptStopAllRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptStopAllRequest.Merge(m, src) -} -func (m *GCTScriptStopAllRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptStopAllRequest.Size(m) -} -func (m *GCTScriptStopAllRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptStopAllRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptStopAllRequest proto.InternalMessageInfo - type GCTScriptStatusRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GCTScriptStatusRequest) Reset() { *m = GCTScriptStatusRequest{} } -func (m *GCTScriptStatusRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptStatusRequest) ProtoMessage() {} +func (x *GCTScriptStatusRequest) Reset() { + *x = GCTScriptStatusRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[112] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptStatusRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptStatusRequest) ProtoMessage() {} + +func (x *GCTScriptStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[112] + 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 GCTScriptStatusRequest.ProtoReflect.Descriptor instead. func (*GCTScriptStatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{112} + return file_rpc_proto_rawDescGZIP(), []int{112} } -func (m *GCTScriptStatusRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptStatusRequest.Unmarshal(m, b) -} -func (m *GCTScriptStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptStatusRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptStatusRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptStatusRequest.Merge(m, src) -} -func (m *GCTScriptStatusRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptStatusRequest.Size(m) -} -func (m *GCTScriptStatusRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptStatusRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptStatusRequest proto.InternalMessageInfo - type GCTScriptListAllRequest struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GCTScriptListAllRequest) Reset() { *m = GCTScriptListAllRequest{} } -func (m *GCTScriptListAllRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptListAllRequest) ProtoMessage() {} +func (x *GCTScriptListAllRequest) Reset() { + *x = GCTScriptListAllRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[113] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptListAllRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptListAllRequest) ProtoMessage() {} + +func (x *GCTScriptListAllRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[113] + 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 GCTScriptListAllRequest.ProtoReflect.Descriptor instead. func (*GCTScriptListAllRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{113} + return file_rpc_proto_rawDescGZIP(), []int{113} } -func (m *GCTScriptListAllRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptListAllRequest.Unmarshal(m, b) -} -func (m *GCTScriptListAllRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptListAllRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptListAllRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptListAllRequest.Merge(m, src) -} -func (m *GCTScriptListAllRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptListAllRequest.Size(m) -} -func (m *GCTScriptListAllRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptListAllRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptListAllRequest proto.InternalMessageInfo - type GCTScriptUploadRequest struct { - ScriptName string `protobuf:"bytes,1,opt,name=script_name,json=scriptName,proto3" json:"script_name,omitempty"` - ScriptData string `protobuf:"bytes,2,opt,name=script_data,json=scriptData,proto3" json:"script_data,omitempty"` - Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` - Archived bool `protobuf:"varint,4,opt,name=archived,proto3" json:"archived,omitempty"` - Overwrite bool `protobuf:"varint,5,opt,name=overwrite,proto3" json:"overwrite,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ScriptName string `protobuf:"bytes,1,opt,name=script_name,json=scriptName,proto3" json:"script_name,omitempty"` + ScriptData string `protobuf:"bytes,2,opt,name=script_data,json=scriptData,proto3" json:"script_data,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + Archived bool `protobuf:"varint,4,opt,name=archived,proto3" json:"archived,omitempty"` + Overwrite bool `protobuf:"varint,5,opt,name=overwrite,proto3" json:"overwrite,omitempty"` } -func (m *GCTScriptUploadRequest) Reset() { *m = GCTScriptUploadRequest{} } -func (m *GCTScriptUploadRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptUploadRequest) ProtoMessage() {} +func (x *GCTScriptUploadRequest) Reset() { + *x = GCTScriptUploadRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[114] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptUploadRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptUploadRequest) ProtoMessage() {} + +func (x *GCTScriptUploadRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[114] + 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 GCTScriptUploadRequest.ProtoReflect.Descriptor instead. func (*GCTScriptUploadRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{114} + return file_rpc_proto_rawDescGZIP(), []int{114} } -func (m *GCTScriptUploadRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptUploadRequest.Unmarshal(m, b) -} -func (m *GCTScriptUploadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptUploadRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptUploadRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptUploadRequest.Merge(m, src) -} -func (m *GCTScriptUploadRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptUploadRequest.Size(m) -} -func (m *GCTScriptUploadRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptUploadRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptUploadRequest proto.InternalMessageInfo - -func (m *GCTScriptUploadRequest) GetScriptName() string { - if m != nil { - return m.ScriptName +func (x *GCTScriptUploadRequest) GetScriptName() string { + if x != nil { + return x.ScriptName } return "" } -func (m *GCTScriptUploadRequest) GetScriptData() string { - if m != nil { - return m.ScriptData +func (x *GCTScriptUploadRequest) GetScriptData() string { + if x != nil { + return x.ScriptData } return "" } -func (m *GCTScriptUploadRequest) GetData() []byte { - if m != nil { - return m.Data +func (x *GCTScriptUploadRequest) GetData() []byte { + if x != nil { + return x.Data } return nil } -func (m *GCTScriptUploadRequest) GetArchived() bool { - if m != nil { - return m.Archived +func (x *GCTScriptUploadRequest) GetArchived() bool { + if x != nil { + return x.Archived } return false } -func (m *GCTScriptUploadRequest) GetOverwrite() bool { - if m != nil { - return m.Overwrite +func (x *GCTScriptUploadRequest) GetOverwrite() bool { + if x != nil { + return x.Overwrite } return false } type GCTScriptReadScriptRequest struct { - Script *GCTScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Script *GCTScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` } -func (m *GCTScriptReadScriptRequest) Reset() { *m = GCTScriptReadScriptRequest{} } -func (m *GCTScriptReadScriptRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptReadScriptRequest) ProtoMessage() {} +func (x *GCTScriptReadScriptRequest) Reset() { + *x = GCTScriptReadScriptRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[115] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptReadScriptRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptReadScriptRequest) ProtoMessage() {} + +func (x *GCTScriptReadScriptRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[115] + 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 GCTScriptReadScriptRequest.ProtoReflect.Descriptor instead. func (*GCTScriptReadScriptRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{115} + return file_rpc_proto_rawDescGZIP(), []int{115} } -func (m *GCTScriptReadScriptRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptReadScriptRequest.Unmarshal(m, b) -} -func (m *GCTScriptReadScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptReadScriptRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptReadScriptRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptReadScriptRequest.Merge(m, src) -} -func (m *GCTScriptReadScriptRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptReadScriptRequest.Size(m) -} -func (m *GCTScriptReadScriptRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptReadScriptRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptReadScriptRequest proto.InternalMessageInfo - -func (m *GCTScriptReadScriptRequest) GetScript() *GCTScript { - if m != nil { - return m.Script +func (x *GCTScriptReadScriptRequest) GetScript() *GCTScript { + if x != nil { + return x.Script } return nil } type GCTScriptQueryRequest struct { - Script *GCTScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Script *GCTScript `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` } -func (m *GCTScriptQueryRequest) Reset() { *m = GCTScriptQueryRequest{} } -func (m *GCTScriptQueryRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptQueryRequest) ProtoMessage() {} +func (x *GCTScriptQueryRequest) Reset() { + *x = GCTScriptQueryRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[116] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptQueryRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptQueryRequest) ProtoMessage() {} + +func (x *GCTScriptQueryRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[116] + 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 GCTScriptQueryRequest.ProtoReflect.Descriptor instead. func (*GCTScriptQueryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{116} + return file_rpc_proto_rawDescGZIP(), []int{116} } -func (m *GCTScriptQueryRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptQueryRequest.Unmarshal(m, b) -} -func (m *GCTScriptQueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptQueryRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptQueryRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptQueryRequest.Merge(m, src) -} -func (m *GCTScriptQueryRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptQueryRequest.Size(m) -} -func (m *GCTScriptQueryRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptQueryRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptQueryRequest proto.InternalMessageInfo - -func (m *GCTScriptQueryRequest) GetScript() *GCTScript { - if m != nil { - return m.Script +func (x *GCTScriptQueryRequest) GetScript() *GCTScript { + if x != nil { + return x.Script } return nil } type GCTScriptAutoLoadRequest struct { - Script string `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` - Status bool `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Script string `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"` + Status bool `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"` } -func (m *GCTScriptAutoLoadRequest) Reset() { *m = GCTScriptAutoLoadRequest{} } -func (m *GCTScriptAutoLoadRequest) String() string { return proto.CompactTextString(m) } -func (*GCTScriptAutoLoadRequest) ProtoMessage() {} +func (x *GCTScriptAutoLoadRequest) Reset() { + *x = GCTScriptAutoLoadRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[117] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptAutoLoadRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptAutoLoadRequest) ProtoMessage() {} + +func (x *GCTScriptAutoLoadRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[117] + 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 GCTScriptAutoLoadRequest.ProtoReflect.Descriptor instead. func (*GCTScriptAutoLoadRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{117} + return file_rpc_proto_rawDescGZIP(), []int{117} } -func (m *GCTScriptAutoLoadRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptAutoLoadRequest.Unmarshal(m, b) -} -func (m *GCTScriptAutoLoadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptAutoLoadRequest.Marshal(b, m, deterministic) -} -func (m *GCTScriptAutoLoadRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptAutoLoadRequest.Merge(m, src) -} -func (m *GCTScriptAutoLoadRequest) XXX_Size() int { - return xxx_messageInfo_GCTScriptAutoLoadRequest.Size(m) -} -func (m *GCTScriptAutoLoadRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptAutoLoadRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptAutoLoadRequest proto.InternalMessageInfo - -func (m *GCTScriptAutoLoadRequest) GetScript() string { - if m != nil { - return m.Script +func (x *GCTScriptAutoLoadRequest) GetScript() string { + if x != nil { + return x.Script } return "" } -func (m *GCTScriptAutoLoadRequest) GetStatus() bool { - if m != nil { - return m.Status +func (x *GCTScriptAutoLoadRequest) GetStatus() bool { + if x != nil { + return x.Status } return false } type GCTScriptStatusResponse struct { - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - Scripts []*GCTScript `protobuf:"bytes,2,rep,name=scripts,proto3" json:"scripts,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Scripts []*GCTScript `protobuf:"bytes,2,rep,name=scripts,proto3" json:"scripts,omitempty"` } -func (m *GCTScriptStatusResponse) Reset() { *m = GCTScriptStatusResponse{} } -func (m *GCTScriptStatusResponse) String() string { return proto.CompactTextString(m) } -func (*GCTScriptStatusResponse) ProtoMessage() {} +func (x *GCTScriptStatusResponse) Reset() { + *x = GCTScriptStatusResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[118] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptStatusResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptStatusResponse) ProtoMessage() {} + +func (x *GCTScriptStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[118] + 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 GCTScriptStatusResponse.ProtoReflect.Descriptor instead. func (*GCTScriptStatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{118} + return file_rpc_proto_rawDescGZIP(), []int{118} } -func (m *GCTScriptStatusResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptStatusResponse.Unmarshal(m, b) -} -func (m *GCTScriptStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptStatusResponse.Marshal(b, m, deterministic) -} -func (m *GCTScriptStatusResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptStatusResponse.Merge(m, src) -} -func (m *GCTScriptStatusResponse) XXX_Size() int { - return xxx_messageInfo_GCTScriptStatusResponse.Size(m) -} -func (m *GCTScriptStatusResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptStatusResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptStatusResponse proto.InternalMessageInfo - -func (m *GCTScriptStatusResponse) GetStatus() string { - if m != nil { - return m.Status +func (x *GCTScriptStatusResponse) GetStatus() string { + if x != nil { + return x.Status } return "" } -func (m *GCTScriptStatusResponse) GetScripts() []*GCTScript { - if m != nil { - return m.Scripts +func (x *GCTScriptStatusResponse) GetScripts() []*GCTScript { + if x != nil { + return x.Scripts } return nil } type GCTScriptQueryResponse struct { - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - Script *GCTScript `protobuf:"bytes,2,opt,name=script,proto3" json:"script,omitempty"` - Data string `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Script *GCTScript `protobuf:"bytes,2,opt,name=script,proto3" json:"script,omitempty"` + Data string `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` } -func (m *GCTScriptQueryResponse) Reset() { *m = GCTScriptQueryResponse{} } -func (m *GCTScriptQueryResponse) String() string { return proto.CompactTextString(m) } -func (*GCTScriptQueryResponse) ProtoMessage() {} +func (x *GCTScriptQueryResponse) Reset() { + *x = GCTScriptQueryResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[119] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GCTScriptQueryResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GCTScriptQueryResponse) ProtoMessage() {} + +func (x *GCTScriptQueryResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[119] + 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 GCTScriptQueryResponse.ProtoReflect.Descriptor instead. func (*GCTScriptQueryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{119} + return file_rpc_proto_rawDescGZIP(), []int{119} } -func (m *GCTScriptQueryResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GCTScriptQueryResponse.Unmarshal(m, b) -} -func (m *GCTScriptQueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GCTScriptQueryResponse.Marshal(b, m, deterministic) -} -func (m *GCTScriptQueryResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GCTScriptQueryResponse.Merge(m, src) -} -func (m *GCTScriptQueryResponse) XXX_Size() int { - return xxx_messageInfo_GCTScriptQueryResponse.Size(m) -} -func (m *GCTScriptQueryResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GCTScriptQueryResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GCTScriptQueryResponse proto.InternalMessageInfo - -func (m *GCTScriptQueryResponse) GetStatus() string { - if m != nil { - return m.Status +func (x *GCTScriptQueryResponse) GetStatus() string { + if x != nil { + return x.Status } return "" } -func (m *GCTScriptQueryResponse) GetScript() *GCTScript { - if m != nil { - return m.Script +func (x *GCTScriptQueryResponse) GetScript() *GCTScript { + if x != nil { + return x.Script } return nil } -func (m *GCTScriptQueryResponse) GetData() string { - if m != nil { - return m.Data +func (x *GCTScriptQueryResponse) GetData() string { + if x != nil { + return x.Data } return "" } type GenericResponse struct { - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - Data string `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Data string `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` } -func (m *GenericResponse) Reset() { *m = GenericResponse{} } -func (m *GenericResponse) String() string { return proto.CompactTextString(m) } -func (*GenericResponse) ProtoMessage() {} +func (x *GenericResponse) Reset() { + *x = GenericResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[120] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenericResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenericResponse) ProtoMessage() {} + +func (x *GenericResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[120] + 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 GenericResponse.ProtoReflect.Descriptor instead. func (*GenericResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{120} + return file_rpc_proto_rawDescGZIP(), []int{120} } -func (m *GenericResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GenericResponse.Unmarshal(m, b) -} -func (m *GenericResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GenericResponse.Marshal(b, m, deterministic) -} -func (m *GenericResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenericResponse.Merge(m, src) -} -func (m *GenericResponse) XXX_Size() int { - return xxx_messageInfo_GenericResponse.Size(m) -} -func (m *GenericResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GenericResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GenericResponse proto.InternalMessageInfo - -func (m *GenericResponse) GetStatus() string { - if m != nil { - return m.Status +func (x *GenericResponse) GetStatus() string { + if x != nil { + return x.Status } return "" } -func (m *GenericResponse) GetData() string { - if m != nil { - return m.Data +func (x *GenericResponse) GetData() string { + if x != nil { + return x.Data } return "" } type SetExchangeAssetRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Asset string `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"` - Enable bool `protobuf:"varint,3,opt,name=enable,proto3" json:"enable,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + 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"` + Enable bool `protobuf:"varint,3,opt,name=enable,proto3" json:"enable,omitempty"` } -func (m *SetExchangeAssetRequest) Reset() { *m = SetExchangeAssetRequest{} } -func (m *SetExchangeAssetRequest) String() string { return proto.CompactTextString(m) } -func (*SetExchangeAssetRequest) ProtoMessage() {} +func (x *SetExchangeAssetRequest) Reset() { + *x = SetExchangeAssetRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[121] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetExchangeAssetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetExchangeAssetRequest) ProtoMessage() {} + +func (x *SetExchangeAssetRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[121] + 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 SetExchangeAssetRequest.ProtoReflect.Descriptor instead. func (*SetExchangeAssetRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{121} + return file_rpc_proto_rawDescGZIP(), []int{121} } -func (m *SetExchangeAssetRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetExchangeAssetRequest.Unmarshal(m, b) -} -func (m *SetExchangeAssetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetExchangeAssetRequest.Marshal(b, m, deterministic) -} -func (m *SetExchangeAssetRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetExchangeAssetRequest.Merge(m, src) -} -func (m *SetExchangeAssetRequest) XXX_Size() int { - return xxx_messageInfo_SetExchangeAssetRequest.Size(m) -} -func (m *SetExchangeAssetRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SetExchangeAssetRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_SetExchangeAssetRequest proto.InternalMessageInfo - -func (m *SetExchangeAssetRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *SetExchangeAssetRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *SetExchangeAssetRequest) GetAsset() string { - if m != nil { - return m.Asset +func (x *SetExchangeAssetRequest) GetAsset() string { + if x != nil { + return x.Asset } return "" } -func (m *SetExchangeAssetRequest) GetEnable() bool { - if m != nil { - return m.Enable +func (x *SetExchangeAssetRequest) GetEnable() bool { + if x != nil { + return x.Enable } return false } type SetExchangeAllPairsRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Enable bool `protobuf:"varint,2,opt,name=enable,proto3" json:"enable,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Enable bool `protobuf:"varint,2,opt,name=enable,proto3" json:"enable,omitempty"` } -func (m *SetExchangeAllPairsRequest) Reset() { *m = SetExchangeAllPairsRequest{} } -func (m *SetExchangeAllPairsRequest) String() string { return proto.CompactTextString(m) } -func (*SetExchangeAllPairsRequest) ProtoMessage() {} +func (x *SetExchangeAllPairsRequest) Reset() { + *x = SetExchangeAllPairsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[122] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetExchangeAllPairsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetExchangeAllPairsRequest) ProtoMessage() {} + +func (x *SetExchangeAllPairsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[122] + 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 SetExchangeAllPairsRequest.ProtoReflect.Descriptor instead. func (*SetExchangeAllPairsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{122} + return file_rpc_proto_rawDescGZIP(), []int{122} } -func (m *SetExchangeAllPairsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetExchangeAllPairsRequest.Unmarshal(m, b) -} -func (m *SetExchangeAllPairsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetExchangeAllPairsRequest.Marshal(b, m, deterministic) -} -func (m *SetExchangeAllPairsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetExchangeAllPairsRequest.Merge(m, src) -} -func (m *SetExchangeAllPairsRequest) XXX_Size() int { - return xxx_messageInfo_SetExchangeAllPairsRequest.Size(m) -} -func (m *SetExchangeAllPairsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SetExchangeAllPairsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_SetExchangeAllPairsRequest proto.InternalMessageInfo - -func (m *SetExchangeAllPairsRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *SetExchangeAllPairsRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *SetExchangeAllPairsRequest) GetEnable() bool { - if m != nil { - return m.Enable +func (x *SetExchangeAllPairsRequest) GetEnable() bool { + if x != nil { + return x.Enable } return false } type UpdateExchangeSupportedPairsRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *UpdateExchangeSupportedPairsRequest) Reset() { *m = UpdateExchangeSupportedPairsRequest{} } -func (m *UpdateExchangeSupportedPairsRequest) String() string { return proto.CompactTextString(m) } -func (*UpdateExchangeSupportedPairsRequest) ProtoMessage() {} +func (x *UpdateExchangeSupportedPairsRequest) Reset() { + *x = UpdateExchangeSupportedPairsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[123] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateExchangeSupportedPairsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateExchangeSupportedPairsRequest) ProtoMessage() {} + +func (x *UpdateExchangeSupportedPairsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[123] + 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 UpdateExchangeSupportedPairsRequest.ProtoReflect.Descriptor instead. func (*UpdateExchangeSupportedPairsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{123} + return file_rpc_proto_rawDescGZIP(), []int{123} } -func (m *UpdateExchangeSupportedPairsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UpdateExchangeSupportedPairsRequest.Unmarshal(m, b) -} -func (m *UpdateExchangeSupportedPairsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UpdateExchangeSupportedPairsRequest.Marshal(b, m, deterministic) -} -func (m *UpdateExchangeSupportedPairsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_UpdateExchangeSupportedPairsRequest.Merge(m, src) -} -func (m *UpdateExchangeSupportedPairsRequest) XXX_Size() int { - return xxx_messageInfo_UpdateExchangeSupportedPairsRequest.Size(m) -} -func (m *UpdateExchangeSupportedPairsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_UpdateExchangeSupportedPairsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_UpdateExchangeSupportedPairsRequest proto.InternalMessageInfo - -func (m *UpdateExchangeSupportedPairsRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *UpdateExchangeSupportedPairsRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type GetExchangeAssetsRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *GetExchangeAssetsRequest) Reset() { *m = GetExchangeAssetsRequest{} } -func (m *GetExchangeAssetsRequest) String() string { return proto.CompactTextString(m) } -func (*GetExchangeAssetsRequest) ProtoMessage() {} +func (x *GetExchangeAssetsRequest) Reset() { + *x = GetExchangeAssetsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[124] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangeAssetsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangeAssetsRequest) ProtoMessage() {} + +func (x *GetExchangeAssetsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[124] + 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 GetExchangeAssetsRequest.ProtoReflect.Descriptor instead. func (*GetExchangeAssetsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{124} + return file_rpc_proto_rawDescGZIP(), []int{124} } -func (m *GetExchangeAssetsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangeAssetsRequest.Unmarshal(m, b) -} -func (m *GetExchangeAssetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangeAssetsRequest.Marshal(b, m, deterministic) -} -func (m *GetExchangeAssetsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangeAssetsRequest.Merge(m, src) -} -func (m *GetExchangeAssetsRequest) XXX_Size() int { - return xxx_messageInfo_GetExchangeAssetsRequest.Size(m) -} -func (m *GetExchangeAssetsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangeAssetsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangeAssetsRequest proto.InternalMessageInfo - -func (m *GetExchangeAssetsRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *GetExchangeAssetsRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type GetExchangeAssetsResponse struct { - Assets string `protobuf:"bytes,1,opt,name=assets,proto3" json:"assets,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Assets string `protobuf:"bytes,1,opt,name=assets,proto3" json:"assets,omitempty"` } -func (m *GetExchangeAssetsResponse) Reset() { *m = GetExchangeAssetsResponse{} } -func (m *GetExchangeAssetsResponse) String() string { return proto.CompactTextString(m) } -func (*GetExchangeAssetsResponse) ProtoMessage() {} +func (x *GetExchangeAssetsResponse) Reset() { + *x = GetExchangeAssetsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[125] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetExchangeAssetsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetExchangeAssetsResponse) ProtoMessage() {} + +func (x *GetExchangeAssetsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[125] + 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 GetExchangeAssetsResponse.ProtoReflect.Descriptor instead. func (*GetExchangeAssetsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{125} + return file_rpc_proto_rawDescGZIP(), []int{125} } -func (m *GetExchangeAssetsResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetExchangeAssetsResponse.Unmarshal(m, b) -} -func (m *GetExchangeAssetsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetExchangeAssetsResponse.Marshal(b, m, deterministic) -} -func (m *GetExchangeAssetsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExchangeAssetsResponse.Merge(m, src) -} -func (m *GetExchangeAssetsResponse) XXX_Size() int { - return xxx_messageInfo_GetExchangeAssetsResponse.Size(m) -} -func (m *GetExchangeAssetsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetExchangeAssetsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetExchangeAssetsResponse proto.InternalMessageInfo - -func (m *GetExchangeAssetsResponse) GetAssets() string { - if m != nil { - return m.Assets +func (x *GetExchangeAssetsResponse) GetAssets() string { + if x != nil { + return x.Assets } return "" } type WebsocketGetInfoRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *WebsocketGetInfoRequest) Reset() { *m = WebsocketGetInfoRequest{} } -func (m *WebsocketGetInfoRequest) String() string { return proto.CompactTextString(m) } -func (*WebsocketGetInfoRequest) ProtoMessage() {} +func (x *WebsocketGetInfoRequest) Reset() { + *x = WebsocketGetInfoRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[126] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebsocketGetInfoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebsocketGetInfoRequest) ProtoMessage() {} + +func (x *WebsocketGetInfoRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[126] + 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 WebsocketGetInfoRequest.ProtoReflect.Descriptor instead. func (*WebsocketGetInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{126} + return file_rpc_proto_rawDescGZIP(), []int{126} } -func (m *WebsocketGetInfoRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WebsocketGetInfoRequest.Unmarshal(m, b) -} -func (m *WebsocketGetInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WebsocketGetInfoRequest.Marshal(b, m, deterministic) -} -func (m *WebsocketGetInfoRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WebsocketGetInfoRequest.Merge(m, src) -} -func (m *WebsocketGetInfoRequest) XXX_Size() int { - return xxx_messageInfo_WebsocketGetInfoRequest.Size(m) -} -func (m *WebsocketGetInfoRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WebsocketGetInfoRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WebsocketGetInfoRequest proto.InternalMessageInfo - -func (m *WebsocketGetInfoRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WebsocketGetInfoRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type WebsocketGetInfoResponse struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Supported bool `protobuf:"varint,2,opt,name=supported,proto3" json:"supported,omitempty"` - Enabled bool `protobuf:"varint,3,opt,name=enabled,proto3" json:"enabled,omitempty"` - AuthenticatedSupported bool `protobuf:"varint,4,opt,name=authenticated_supported,json=authenticatedSupported,proto3" json:"authenticated_supported,omitempty"` - Authenticated bool `protobuf:"varint,5,opt,name=authenticated,proto3" json:"authenticated,omitempty"` - RunningUrl string `protobuf:"bytes,6,opt,name=running_url,json=runningUrl,proto3" json:"running_url,omitempty"` - ProxyAddress string `protobuf:"bytes,7,opt,name=proxy_address,json=proxyAddress,proto3" json:"proxy_address,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Supported bool `protobuf:"varint,2,opt,name=supported,proto3" json:"supported,omitempty"` + Enabled bool `protobuf:"varint,3,opt,name=enabled,proto3" json:"enabled,omitempty"` + AuthenticatedSupported bool `protobuf:"varint,4,opt,name=authenticated_supported,json=authenticatedSupported,proto3" json:"authenticated_supported,omitempty"` + Authenticated bool `protobuf:"varint,5,opt,name=authenticated,proto3" json:"authenticated,omitempty"` + RunningUrl string `protobuf:"bytes,6,opt,name=running_url,json=runningUrl,proto3" json:"running_url,omitempty"` + ProxyAddress string `protobuf:"bytes,7,opt,name=proxy_address,json=proxyAddress,proto3" json:"proxy_address,omitempty"` } -func (m *WebsocketGetInfoResponse) Reset() { *m = WebsocketGetInfoResponse{} } -func (m *WebsocketGetInfoResponse) String() string { return proto.CompactTextString(m) } -func (*WebsocketGetInfoResponse) ProtoMessage() {} +func (x *WebsocketGetInfoResponse) Reset() { + *x = WebsocketGetInfoResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[127] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebsocketGetInfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebsocketGetInfoResponse) ProtoMessage() {} + +func (x *WebsocketGetInfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[127] + 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 WebsocketGetInfoResponse.ProtoReflect.Descriptor instead. func (*WebsocketGetInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{127} + return file_rpc_proto_rawDescGZIP(), []int{127} } -func (m *WebsocketGetInfoResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WebsocketGetInfoResponse.Unmarshal(m, b) -} -func (m *WebsocketGetInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WebsocketGetInfoResponse.Marshal(b, m, deterministic) -} -func (m *WebsocketGetInfoResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_WebsocketGetInfoResponse.Merge(m, src) -} -func (m *WebsocketGetInfoResponse) XXX_Size() int { - return xxx_messageInfo_WebsocketGetInfoResponse.Size(m) -} -func (m *WebsocketGetInfoResponse) XXX_DiscardUnknown() { - xxx_messageInfo_WebsocketGetInfoResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_WebsocketGetInfoResponse proto.InternalMessageInfo - -func (m *WebsocketGetInfoResponse) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WebsocketGetInfoResponse) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WebsocketGetInfoResponse) GetSupported() bool { - if m != nil { - return m.Supported +func (x *WebsocketGetInfoResponse) GetSupported() bool { + if x != nil { + return x.Supported } return false } -func (m *WebsocketGetInfoResponse) GetEnabled() bool { - if m != nil { - return m.Enabled +func (x *WebsocketGetInfoResponse) GetEnabled() bool { + if x != nil { + return x.Enabled } return false } -func (m *WebsocketGetInfoResponse) GetAuthenticatedSupported() bool { - if m != nil { - return m.AuthenticatedSupported +func (x *WebsocketGetInfoResponse) GetAuthenticatedSupported() bool { + if x != nil { + return x.AuthenticatedSupported } return false } -func (m *WebsocketGetInfoResponse) GetAuthenticated() bool { - if m != nil { - return m.Authenticated +func (x *WebsocketGetInfoResponse) GetAuthenticated() bool { + if x != nil { + return x.Authenticated } return false } -func (m *WebsocketGetInfoResponse) GetRunningUrl() string { - if m != nil { - return m.RunningUrl +func (x *WebsocketGetInfoResponse) GetRunningUrl() string { + if x != nil { + return x.RunningUrl } return "" } -func (m *WebsocketGetInfoResponse) GetProxyAddress() string { - if m != nil { - return m.ProxyAddress +func (x *WebsocketGetInfoResponse) GetProxyAddress() string { + if x != nil { + return x.ProxyAddress } return "" } type WebsocketSetEnabledRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Enable bool `protobuf:"varint,2,opt,name=enable,proto3" json:"enable,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Enable bool `protobuf:"varint,2,opt,name=enable,proto3" json:"enable,omitempty"` } -func (m *WebsocketSetEnabledRequest) Reset() { *m = WebsocketSetEnabledRequest{} } -func (m *WebsocketSetEnabledRequest) String() string { return proto.CompactTextString(m) } -func (*WebsocketSetEnabledRequest) ProtoMessage() {} +func (x *WebsocketSetEnabledRequest) Reset() { + *x = WebsocketSetEnabledRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[128] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebsocketSetEnabledRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebsocketSetEnabledRequest) ProtoMessage() {} + +func (x *WebsocketSetEnabledRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[128] + 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 WebsocketSetEnabledRequest.ProtoReflect.Descriptor instead. func (*WebsocketSetEnabledRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{128} + return file_rpc_proto_rawDescGZIP(), []int{128} } -func (m *WebsocketSetEnabledRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WebsocketSetEnabledRequest.Unmarshal(m, b) -} -func (m *WebsocketSetEnabledRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WebsocketSetEnabledRequest.Marshal(b, m, deterministic) -} -func (m *WebsocketSetEnabledRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WebsocketSetEnabledRequest.Merge(m, src) -} -func (m *WebsocketSetEnabledRequest) XXX_Size() int { - return xxx_messageInfo_WebsocketSetEnabledRequest.Size(m) -} -func (m *WebsocketSetEnabledRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WebsocketSetEnabledRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WebsocketSetEnabledRequest proto.InternalMessageInfo - -func (m *WebsocketSetEnabledRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WebsocketSetEnabledRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WebsocketSetEnabledRequest) GetEnable() bool { - if m != nil { - return m.Enable +func (x *WebsocketSetEnabledRequest) GetEnable() bool { + if x != nil { + return x.Enable } return false } type WebsocketGetSubscriptionsRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` } -func (m *WebsocketGetSubscriptionsRequest) Reset() { *m = WebsocketGetSubscriptionsRequest{} } -func (m *WebsocketGetSubscriptionsRequest) String() string { return proto.CompactTextString(m) } -func (*WebsocketGetSubscriptionsRequest) ProtoMessage() {} +func (x *WebsocketGetSubscriptionsRequest) Reset() { + *x = WebsocketGetSubscriptionsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[129] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebsocketGetSubscriptionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebsocketGetSubscriptionsRequest) ProtoMessage() {} + +func (x *WebsocketGetSubscriptionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[129] + 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 WebsocketGetSubscriptionsRequest.ProtoReflect.Descriptor instead. func (*WebsocketGetSubscriptionsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{129} + return file_rpc_proto_rawDescGZIP(), []int{129} } -func (m *WebsocketGetSubscriptionsRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WebsocketGetSubscriptionsRequest.Unmarshal(m, b) -} -func (m *WebsocketGetSubscriptionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WebsocketGetSubscriptionsRequest.Marshal(b, m, deterministic) -} -func (m *WebsocketGetSubscriptionsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WebsocketGetSubscriptionsRequest.Merge(m, src) -} -func (m *WebsocketGetSubscriptionsRequest) XXX_Size() int { - return xxx_messageInfo_WebsocketGetSubscriptionsRequest.Size(m) -} -func (m *WebsocketGetSubscriptionsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WebsocketGetSubscriptionsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WebsocketGetSubscriptionsRequest proto.InternalMessageInfo - -func (m *WebsocketGetSubscriptionsRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WebsocketGetSubscriptionsRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } type WebsocketSubscription struct { - Channel string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` - Currency string `protobuf:"bytes,2,opt,name=currency,proto3" json:"currency,omitempty"` - Asset string `protobuf:"bytes,3,opt,name=asset,proto3" json:"asset,omitempty"` - Params string `protobuf:"bytes,4,opt,name=params,proto3" json:"params,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Channel string `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` + Currency string `protobuf:"bytes,2,opt,name=currency,proto3" json:"currency,omitempty"` + Asset string `protobuf:"bytes,3,opt,name=asset,proto3" json:"asset,omitempty"` + Params string `protobuf:"bytes,4,opt,name=params,proto3" json:"params,omitempty"` } -func (m *WebsocketSubscription) Reset() { *m = WebsocketSubscription{} } -func (m *WebsocketSubscription) String() string { return proto.CompactTextString(m) } -func (*WebsocketSubscription) ProtoMessage() {} +func (x *WebsocketSubscription) Reset() { + *x = WebsocketSubscription{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[130] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebsocketSubscription) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebsocketSubscription) ProtoMessage() {} + +func (x *WebsocketSubscription) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[130] + 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 WebsocketSubscription.ProtoReflect.Descriptor instead. func (*WebsocketSubscription) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{130} + return file_rpc_proto_rawDescGZIP(), []int{130} } -func (m *WebsocketSubscription) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WebsocketSubscription.Unmarshal(m, b) -} -func (m *WebsocketSubscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WebsocketSubscription.Marshal(b, m, deterministic) -} -func (m *WebsocketSubscription) XXX_Merge(src proto.Message) { - xxx_messageInfo_WebsocketSubscription.Merge(m, src) -} -func (m *WebsocketSubscription) XXX_Size() int { - return xxx_messageInfo_WebsocketSubscription.Size(m) -} -func (m *WebsocketSubscription) XXX_DiscardUnknown() { - xxx_messageInfo_WebsocketSubscription.DiscardUnknown(m) -} - -var xxx_messageInfo_WebsocketSubscription proto.InternalMessageInfo - -func (m *WebsocketSubscription) GetChannel() string { - if m != nil { - return m.Channel +func (x *WebsocketSubscription) GetChannel() string { + if x != nil { + return x.Channel } return "" } -func (m *WebsocketSubscription) GetCurrency() string { - if m != nil { - return m.Currency +func (x *WebsocketSubscription) GetCurrency() string { + if x != nil { + return x.Currency } return "" } -func (m *WebsocketSubscription) GetAsset() string { - if m != nil { - return m.Asset +func (x *WebsocketSubscription) GetAsset() string { + if x != nil { + return x.Asset } return "" } -func (m *WebsocketSubscription) GetParams() string { - if m != nil { - return m.Params +func (x *WebsocketSubscription) GetParams() string { + if x != nil { + return x.Params } return "" } type WebsocketGetSubscriptionsResponse struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Subscriptions []*WebsocketSubscription `protobuf:"bytes,2,rep,name=subscriptions,proto3" json:"subscriptions,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Subscriptions []*WebsocketSubscription `protobuf:"bytes,2,rep,name=subscriptions,proto3" json:"subscriptions,omitempty"` } -func (m *WebsocketGetSubscriptionsResponse) Reset() { *m = WebsocketGetSubscriptionsResponse{} } -func (m *WebsocketGetSubscriptionsResponse) String() string { return proto.CompactTextString(m) } -func (*WebsocketGetSubscriptionsResponse) ProtoMessage() {} +func (x *WebsocketGetSubscriptionsResponse) Reset() { + *x = WebsocketGetSubscriptionsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[131] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebsocketGetSubscriptionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebsocketGetSubscriptionsResponse) ProtoMessage() {} + +func (x *WebsocketGetSubscriptionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[131] + 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 WebsocketGetSubscriptionsResponse.ProtoReflect.Descriptor instead. func (*WebsocketGetSubscriptionsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{131} + return file_rpc_proto_rawDescGZIP(), []int{131} } -func (m *WebsocketGetSubscriptionsResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WebsocketGetSubscriptionsResponse.Unmarshal(m, b) -} -func (m *WebsocketGetSubscriptionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WebsocketGetSubscriptionsResponse.Marshal(b, m, deterministic) -} -func (m *WebsocketGetSubscriptionsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_WebsocketGetSubscriptionsResponse.Merge(m, src) -} -func (m *WebsocketGetSubscriptionsResponse) XXX_Size() int { - return xxx_messageInfo_WebsocketGetSubscriptionsResponse.Size(m) -} -func (m *WebsocketGetSubscriptionsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_WebsocketGetSubscriptionsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_WebsocketGetSubscriptionsResponse proto.InternalMessageInfo - -func (m *WebsocketGetSubscriptionsResponse) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WebsocketGetSubscriptionsResponse) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WebsocketGetSubscriptionsResponse) GetSubscriptions() []*WebsocketSubscription { - if m != nil { - return m.Subscriptions +func (x *WebsocketGetSubscriptionsResponse) GetSubscriptions() []*WebsocketSubscription { + if x != nil { + return x.Subscriptions } return nil } type WebsocketSetProxyRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Proxy string `protobuf:"bytes,2,opt,name=proxy,proto3" json:"proxy,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Proxy string `protobuf:"bytes,2,opt,name=proxy,proto3" json:"proxy,omitempty"` } -func (m *WebsocketSetProxyRequest) Reset() { *m = WebsocketSetProxyRequest{} } -func (m *WebsocketSetProxyRequest) String() string { return proto.CompactTextString(m) } -func (*WebsocketSetProxyRequest) ProtoMessage() {} +func (x *WebsocketSetProxyRequest) Reset() { + *x = WebsocketSetProxyRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[132] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebsocketSetProxyRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebsocketSetProxyRequest) ProtoMessage() {} + +func (x *WebsocketSetProxyRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[132] + 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 WebsocketSetProxyRequest.ProtoReflect.Descriptor instead. func (*WebsocketSetProxyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{132} + return file_rpc_proto_rawDescGZIP(), []int{132} } -func (m *WebsocketSetProxyRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WebsocketSetProxyRequest.Unmarshal(m, b) -} -func (m *WebsocketSetProxyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WebsocketSetProxyRequest.Marshal(b, m, deterministic) -} -func (m *WebsocketSetProxyRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WebsocketSetProxyRequest.Merge(m, src) -} -func (m *WebsocketSetProxyRequest) XXX_Size() int { - return xxx_messageInfo_WebsocketSetProxyRequest.Size(m) -} -func (m *WebsocketSetProxyRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WebsocketSetProxyRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WebsocketSetProxyRequest proto.InternalMessageInfo - -func (m *WebsocketSetProxyRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WebsocketSetProxyRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WebsocketSetProxyRequest) GetProxy() string { - if m != nil { - return m.Proxy +func (x *WebsocketSetProxyRequest) GetProxy() string { + if x != nil { + return x.Proxy } return "" } type WebsocketSetURLRequest struct { - Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` - Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"` } -func (m *WebsocketSetURLRequest) Reset() { *m = WebsocketSetURLRequest{} } -func (m *WebsocketSetURLRequest) String() string { return proto.CompactTextString(m) } -func (*WebsocketSetURLRequest) ProtoMessage() {} +func (x *WebsocketSetURLRequest) Reset() { + *x = WebsocketSetURLRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[133] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WebsocketSetURLRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WebsocketSetURLRequest) ProtoMessage() {} + +func (x *WebsocketSetURLRequest) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[133] + 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 WebsocketSetURLRequest.ProtoReflect.Descriptor instead. func (*WebsocketSetURLRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_77a6da22d6a3feb1, []int{133} + return file_rpc_proto_rawDescGZIP(), []int{133} } -func (m *WebsocketSetURLRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_WebsocketSetURLRequest.Unmarshal(m, b) -} -func (m *WebsocketSetURLRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_WebsocketSetURLRequest.Marshal(b, m, deterministic) -} -func (m *WebsocketSetURLRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WebsocketSetURLRequest.Merge(m, src) -} -func (m *WebsocketSetURLRequest) XXX_Size() int { - return xxx_messageInfo_WebsocketSetURLRequest.Size(m) -} -func (m *WebsocketSetURLRequest) XXX_DiscardUnknown() { - xxx_messageInfo_WebsocketSetURLRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_WebsocketSetURLRequest proto.InternalMessageInfo - -func (m *WebsocketSetURLRequest) GetExchange() string { - if m != nil { - return m.Exchange +func (x *WebsocketSetURLRequest) GetExchange() string { + if x != nil { + return x.Exchange } return "" } -func (m *WebsocketSetURLRequest) GetUrl() string { - if m != nil { - return m.Url +func (x *WebsocketSetURLRequest) GetUrl() string { + if x != nil { + return x.Url } return "" } -func init() { - proto.RegisterType((*GetInfoRequest)(nil), "gctrpc.GetInfoRequest") - proto.RegisterType((*GetInfoResponse)(nil), "gctrpc.GetInfoResponse") - proto.RegisterMapType((map[string]*RPCEndpoint)(nil), "gctrpc.GetInfoResponse.RpcEndpointsEntry") - proto.RegisterMapType((map[string]bool)(nil), "gctrpc.GetInfoResponse.SubsystemStatusEntry") - proto.RegisterType((*GetCommunicationRelayersRequest)(nil), "gctrpc.GetCommunicationRelayersRequest") - proto.RegisterType((*CommunicationRelayer)(nil), "gctrpc.CommunicationRelayer") - proto.RegisterType((*GetCommunicationRelayersResponse)(nil), "gctrpc.GetCommunicationRelayersResponse") - proto.RegisterMapType((map[string]*CommunicationRelayer)(nil), "gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry") - proto.RegisterType((*GenericSubsystemRequest)(nil), "gctrpc.GenericSubsystemRequest") - proto.RegisterType((*GetSubsystemsRequest)(nil), "gctrpc.GetSubsystemsRequest") - proto.RegisterType((*GetSusbsytemsResponse)(nil), "gctrpc.GetSusbsytemsResponse") - proto.RegisterMapType((map[string]bool)(nil), "gctrpc.GetSusbsytemsResponse.SubsystemsStatusEntry") - proto.RegisterType((*GetRPCEndpointsRequest)(nil), "gctrpc.GetRPCEndpointsRequest") - proto.RegisterType((*RPCEndpoint)(nil), "gctrpc.RPCEndpoint") - proto.RegisterType((*GetRPCEndpointsResponse)(nil), "gctrpc.GetRPCEndpointsResponse") - proto.RegisterMapType((map[string]*RPCEndpoint)(nil), "gctrpc.GetRPCEndpointsResponse.EndpointsEntry") - proto.RegisterType((*GenericExchangeNameRequest)(nil), "gctrpc.GenericExchangeNameRequest") - proto.RegisterType((*GetExchangesRequest)(nil), "gctrpc.GetExchangesRequest") - proto.RegisterType((*GetExchangesResponse)(nil), "gctrpc.GetExchangesResponse") - proto.RegisterType((*GetExchangeOTPReponse)(nil), "gctrpc.GetExchangeOTPReponse") - proto.RegisterType((*GetExchangeOTPsRequest)(nil), "gctrpc.GetExchangeOTPsRequest") - proto.RegisterType((*GetExchangeOTPsResponse)(nil), "gctrpc.GetExchangeOTPsResponse") - proto.RegisterMapType((map[string]string)(nil), "gctrpc.GetExchangeOTPsResponse.OtpCodesEntry") - proto.RegisterType((*DisableExchangeRequest)(nil), "gctrpc.DisableExchangeRequest") - proto.RegisterType((*PairsSupported)(nil), "gctrpc.PairsSupported") - proto.RegisterType((*GetExchangeInfoResponse)(nil), "gctrpc.GetExchangeInfoResponse") - proto.RegisterMapType((map[string]*PairsSupported)(nil), "gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry") - proto.RegisterType((*GetTickerRequest)(nil), "gctrpc.GetTickerRequest") - proto.RegisterType((*CurrencyPair)(nil), "gctrpc.CurrencyPair") - proto.RegisterType((*TickerResponse)(nil), "gctrpc.TickerResponse") - proto.RegisterType((*GetTickersRequest)(nil), "gctrpc.GetTickersRequest") - proto.RegisterType((*Tickers)(nil), "gctrpc.Tickers") - proto.RegisterType((*GetTickersResponse)(nil), "gctrpc.GetTickersResponse") - proto.RegisterType((*GetOrderbookRequest)(nil), "gctrpc.GetOrderbookRequest") - proto.RegisterType((*OrderbookItem)(nil), "gctrpc.OrderbookItem") - proto.RegisterType((*OrderbookResponse)(nil), "gctrpc.OrderbookResponse") - proto.RegisterType((*GetOrderbooksRequest)(nil), "gctrpc.GetOrderbooksRequest") - proto.RegisterType((*Orderbooks)(nil), "gctrpc.Orderbooks") - proto.RegisterType((*GetOrderbooksResponse)(nil), "gctrpc.GetOrderbooksResponse") - proto.RegisterType((*GetAccountInfoRequest)(nil), "gctrpc.GetAccountInfoRequest") - proto.RegisterType((*Account)(nil), "gctrpc.Account") - proto.RegisterType((*AccountCurrencyInfo)(nil), "gctrpc.AccountCurrencyInfo") - proto.RegisterType((*GetAccountInfoResponse)(nil), "gctrpc.GetAccountInfoResponse") - proto.RegisterType((*GetConfigRequest)(nil), "gctrpc.GetConfigRequest") - proto.RegisterType((*GetConfigResponse)(nil), "gctrpc.GetConfigResponse") - proto.RegisterType((*PortfolioAddress)(nil), "gctrpc.PortfolioAddress") - proto.RegisterType((*GetPortfolioRequest)(nil), "gctrpc.GetPortfolioRequest") - proto.RegisterType((*GetPortfolioResponse)(nil), "gctrpc.GetPortfolioResponse") - proto.RegisterType((*GetPortfolioSummaryRequest)(nil), "gctrpc.GetPortfolioSummaryRequest") - proto.RegisterType((*Coin)(nil), "gctrpc.Coin") - proto.RegisterType((*OfflineCoinSummary)(nil), "gctrpc.OfflineCoinSummary") - proto.RegisterType((*OnlineCoinSummary)(nil), "gctrpc.OnlineCoinSummary") - proto.RegisterType((*OfflineCoins)(nil), "gctrpc.OfflineCoins") - proto.RegisterType((*OnlineCoins)(nil), "gctrpc.OnlineCoins") - proto.RegisterMapType((map[string]*OnlineCoinSummary)(nil), "gctrpc.OnlineCoins.CoinsEntry") - proto.RegisterType((*GetPortfolioSummaryResponse)(nil), "gctrpc.GetPortfolioSummaryResponse") - proto.RegisterMapType((map[string]*OfflineCoins)(nil), "gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry") - proto.RegisterMapType((map[string]*OnlineCoins)(nil), "gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry") - proto.RegisterType((*AddPortfolioAddressRequest)(nil), "gctrpc.AddPortfolioAddressRequest") - proto.RegisterType((*RemovePortfolioAddressRequest)(nil), "gctrpc.RemovePortfolioAddressRequest") - proto.RegisterType((*GetForexProvidersRequest)(nil), "gctrpc.GetForexProvidersRequest") - proto.RegisterType((*ForexProvider)(nil), "gctrpc.ForexProvider") - proto.RegisterType((*GetForexProvidersResponse)(nil), "gctrpc.GetForexProvidersResponse") - proto.RegisterType((*GetForexRatesRequest)(nil), "gctrpc.GetForexRatesRequest") - proto.RegisterType((*ForexRatesConversion)(nil), "gctrpc.ForexRatesConversion") - proto.RegisterType((*GetForexRatesResponse)(nil), "gctrpc.GetForexRatesResponse") - proto.RegisterType((*OrderDetails)(nil), "gctrpc.OrderDetails") - proto.RegisterType((*TradeHistory)(nil), "gctrpc.TradeHistory") - proto.RegisterType((*GetOrdersRequest)(nil), "gctrpc.GetOrdersRequest") - proto.RegisterType((*GetOrdersResponse)(nil), "gctrpc.GetOrdersResponse") - proto.RegisterType((*GetOrderRequest)(nil), "gctrpc.GetOrderRequest") - proto.RegisterType((*SubmitOrderRequest)(nil), "gctrpc.SubmitOrderRequest") - proto.RegisterType((*SubmitOrderResponse)(nil), "gctrpc.SubmitOrderResponse") - proto.RegisterType((*SimulateOrderRequest)(nil), "gctrpc.SimulateOrderRequest") - proto.RegisterType((*SimulateOrderResponse)(nil), "gctrpc.SimulateOrderResponse") - proto.RegisterType((*WhaleBombRequest)(nil), "gctrpc.WhaleBombRequest") - proto.RegisterType((*CancelOrderRequest)(nil), "gctrpc.CancelOrderRequest") - proto.RegisterType((*CancelAllOrdersRequest)(nil), "gctrpc.CancelAllOrdersRequest") - proto.RegisterType((*CancelAllOrdersResponse)(nil), "gctrpc.CancelAllOrdersResponse") - proto.RegisterType((*CancelAllOrdersResponse_Orders)(nil), "gctrpc.CancelAllOrdersResponse.Orders") - proto.RegisterMapType((map[string]string)(nil), "gctrpc.CancelAllOrdersResponse.Orders.OrderStatusEntry") - proto.RegisterType((*GetEventsRequest)(nil), "gctrpc.GetEventsRequest") - proto.RegisterType((*ConditionParams)(nil), "gctrpc.ConditionParams") - proto.RegisterType((*GetEventsResponse)(nil), "gctrpc.GetEventsResponse") - proto.RegisterType((*AddEventRequest)(nil), "gctrpc.AddEventRequest") - proto.RegisterType((*AddEventResponse)(nil), "gctrpc.AddEventResponse") - proto.RegisterType((*RemoveEventRequest)(nil), "gctrpc.RemoveEventRequest") - proto.RegisterType((*GetCryptocurrencyDepositAddressesRequest)(nil), "gctrpc.GetCryptocurrencyDepositAddressesRequest") - proto.RegisterType((*GetCryptocurrencyDepositAddressesResponse)(nil), "gctrpc.GetCryptocurrencyDepositAddressesResponse") - proto.RegisterMapType((map[string]string)(nil), "gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry") - proto.RegisterType((*GetCryptocurrencyDepositAddressRequest)(nil), "gctrpc.GetCryptocurrencyDepositAddressRequest") - proto.RegisterType((*GetCryptocurrencyDepositAddressResponse)(nil), "gctrpc.GetCryptocurrencyDepositAddressResponse") - proto.RegisterType((*WithdrawFiatRequest)(nil), "gctrpc.WithdrawFiatRequest") - proto.RegisterType((*WithdrawCryptoRequest)(nil), "gctrpc.WithdrawCryptoRequest") - proto.RegisterType((*WithdrawResponse)(nil), "gctrpc.WithdrawResponse") - proto.RegisterType((*WithdrawalEventByIDRequest)(nil), "gctrpc.WithdrawalEventByIDRequest") - proto.RegisterType((*WithdrawalEventByIDResponse)(nil), "gctrpc.WithdrawalEventByIDResponse") - proto.RegisterType((*WithdrawalEventsByExchangeRequest)(nil), "gctrpc.WithdrawalEventsByExchangeRequest") - proto.RegisterType((*WithdrawalEventsByDateRequest)(nil), "gctrpc.WithdrawalEventsByDateRequest") - proto.RegisterType((*WithdrawalEventsByExchangeResponse)(nil), "gctrpc.WithdrawalEventsByExchangeResponse") - proto.RegisterType((*WithdrawalEventResponse)(nil), "gctrpc.WithdrawalEventResponse") - proto.RegisterType((*WithdrawlExchangeEvent)(nil), "gctrpc.WithdrawlExchangeEvent") - proto.RegisterType((*WithdrawalRequestEvent)(nil), "gctrpc.WithdrawalRequestEvent") - proto.RegisterType((*FiatWithdrawalEvent)(nil), "gctrpc.FiatWithdrawalEvent") - proto.RegisterType((*CryptoWithdrawalEvent)(nil), "gctrpc.CryptoWithdrawalEvent") - proto.RegisterType((*GetLoggerDetailsRequest)(nil), "gctrpc.GetLoggerDetailsRequest") - proto.RegisterType((*GetLoggerDetailsResponse)(nil), "gctrpc.GetLoggerDetailsResponse") - proto.RegisterType((*SetLoggerDetailsRequest)(nil), "gctrpc.SetLoggerDetailsRequest") - proto.RegisterType((*GetExchangePairsRequest)(nil), "gctrpc.GetExchangePairsRequest") - proto.RegisterType((*GetExchangePairsResponse)(nil), "gctrpc.GetExchangePairsResponse") - proto.RegisterMapType((map[string]*PairsSupported)(nil), "gctrpc.GetExchangePairsResponse.SupportedAssetsEntry") - proto.RegisterType((*SetExchangePairRequest)(nil), "gctrpc.SetExchangePairRequest") - proto.RegisterType((*GetOrderbookStreamRequest)(nil), "gctrpc.GetOrderbookStreamRequest") - proto.RegisterType((*GetExchangeOrderbookStreamRequest)(nil), "gctrpc.GetExchangeOrderbookStreamRequest") - proto.RegisterType((*GetTickerStreamRequest)(nil), "gctrpc.GetTickerStreamRequest") - proto.RegisterType((*GetExchangeTickerStreamRequest)(nil), "gctrpc.GetExchangeTickerStreamRequest") - proto.RegisterType((*GetAuditEventRequest)(nil), "gctrpc.GetAuditEventRequest") - proto.RegisterType((*GetAuditEventResponse)(nil), "gctrpc.GetAuditEventResponse") - proto.RegisterType((*GetHistoricCandlesRequest)(nil), "gctrpc.GetHistoricCandlesRequest") - proto.RegisterType((*GetHistoricCandlesResponse)(nil), "gctrpc.GetHistoricCandlesResponse") - proto.RegisterType((*Candle)(nil), "gctrpc.Candle") - proto.RegisterType((*AuditEvent)(nil), "gctrpc.AuditEvent") - proto.RegisterType((*GCTScript)(nil), "gctrpc.GCTScript") - proto.RegisterType((*GCTScriptExecuteRequest)(nil), "gctrpc.GCTScriptExecuteRequest") - proto.RegisterType((*GCTScriptStopRequest)(nil), "gctrpc.GCTScriptStopRequest") - proto.RegisterType((*GCTScriptStopAllRequest)(nil), "gctrpc.GCTScriptStopAllRequest") - proto.RegisterType((*GCTScriptStatusRequest)(nil), "gctrpc.GCTScriptStatusRequest") - proto.RegisterType((*GCTScriptListAllRequest)(nil), "gctrpc.GCTScriptListAllRequest") - proto.RegisterType((*GCTScriptUploadRequest)(nil), "gctrpc.GCTScriptUploadRequest") - proto.RegisterType((*GCTScriptReadScriptRequest)(nil), "gctrpc.GCTScriptReadScriptRequest") - proto.RegisterType((*GCTScriptQueryRequest)(nil), "gctrpc.GCTScriptQueryRequest") - proto.RegisterType((*GCTScriptAutoLoadRequest)(nil), "gctrpc.GCTScriptAutoLoadRequest") - proto.RegisterType((*GCTScriptStatusResponse)(nil), "gctrpc.GCTScriptStatusResponse") - proto.RegisterType((*GCTScriptQueryResponse)(nil), "gctrpc.GCTScriptQueryResponse") - proto.RegisterType((*GenericResponse)(nil), "gctrpc.GenericResponse") - proto.RegisterType((*SetExchangeAssetRequest)(nil), "gctrpc.SetExchangeAssetRequest") - proto.RegisterType((*SetExchangeAllPairsRequest)(nil), "gctrpc.SetExchangeAllPairsRequest") - proto.RegisterType((*UpdateExchangeSupportedPairsRequest)(nil), "gctrpc.UpdateExchangeSupportedPairsRequest") - proto.RegisterType((*GetExchangeAssetsRequest)(nil), "gctrpc.GetExchangeAssetsRequest") - proto.RegisterType((*GetExchangeAssetsResponse)(nil), "gctrpc.GetExchangeAssetsResponse") - proto.RegisterType((*WebsocketGetInfoRequest)(nil), "gctrpc.WebsocketGetInfoRequest") - proto.RegisterType((*WebsocketGetInfoResponse)(nil), "gctrpc.WebsocketGetInfoResponse") - proto.RegisterType((*WebsocketSetEnabledRequest)(nil), "gctrpc.WebsocketSetEnabledRequest") - proto.RegisterType((*WebsocketGetSubscriptionsRequest)(nil), "gctrpc.WebsocketGetSubscriptionsRequest") - proto.RegisterType((*WebsocketSubscription)(nil), "gctrpc.WebsocketSubscription") - proto.RegisterType((*WebsocketGetSubscriptionsResponse)(nil), "gctrpc.WebsocketGetSubscriptionsResponse") - proto.RegisterType((*WebsocketSetProxyRequest)(nil), "gctrpc.WebsocketSetProxyRequest") - proto.RegisterType((*WebsocketSetURLRequest)(nil), "gctrpc.WebsocketSetURLRequest") +type CancelAllOrdersResponse_Orders struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"` + OrderStatus map[string]string `protobuf:"bytes,2,rep,name=order_status,json=orderStatus,proto3" json:"order_status,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } -func init() { - proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) +func (x *CancelAllOrdersResponse_Orders) Reset() { + *x = CancelAllOrdersResponse_Orders{} + if protoimpl.UnsafeEnabled { + mi := &file_rpc_proto_msgTypes[144] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } } -var fileDescriptor_77a6da22d6a3feb1 = []byte{ - // 6423 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x7c, 0x4d, 0x8c, 0x1c, 0xc7, - 0x75, 0x30, 0x7a, 0x66, 0xf6, 0x67, 0xde, 0xfe, 0xb2, 0xf6, 0x6f, 0x38, 0x5c, 0x72, 0xc9, 0x92, - 0x45, 0x91, 0xfa, 0x59, 0x4a, 0x94, 0x64, 0xcb, 0xf2, 0xdf, 0xb7, 0x5c, 0x4a, 0x6b, 0xda, 0xb4, - 0x44, 0xf7, 0x2e, 0x25, 0x40, 0xfe, 0xa0, 0x49, 0xcf, 0x74, 0xed, 0x6e, 0x9b, 0x3d, 0xdd, 0xa3, - 0xee, 0x9e, 0x5d, 0xae, 0x8d, 0xc0, 0x86, 0x91, 0x04, 0x01, 0x1c, 0x24, 0x08, 0x0c, 0xc3, 0x09, - 0x90, 0x53, 0x4e, 0x41, 0x2e, 0x06, 0x82, 0x1c, 0x82, 0x1c, 0x8c, 0x5c, 0x83, 0x00, 0xb9, 0x04, - 0x08, 0x7c, 0xc9, 0x29, 0x41, 0x0e, 0x41, 0x92, 0x43, 0x80, 0x5c, 0x72, 0x0a, 0xea, 0xd5, 0x4f, - 0x57, 0x75, 0xf7, 0xcc, 0xce, 0xca, 0xb4, 0x72, 0x21, 0xa7, 0x5f, 0xbd, 0x7a, 0xef, 0xd5, 0xab, - 0x57, 0xaf, 0x5e, 0xbd, 0x7a, 0xb5, 0xd0, 0x4c, 0x06, 0xbd, 0xed, 0x41, 0x12, 0x67, 0x31, 0x99, - 0x3e, 0xea, 0x65, 0xc9, 0xa0, 0xd7, 0xde, 0x3c, 0x8a, 0xe3, 0xa3, 0x90, 0xdd, 0xf1, 0x06, 0xc1, - 0x1d, 0x2f, 0x8a, 0xe2, 0xcc, 0xcb, 0x82, 0x38, 0x4a, 0x05, 0x56, 0x7b, 0x4b, 0xb6, 0xe2, 0x57, - 0x77, 0x78, 0x78, 0x27, 0x0b, 0xfa, 0x2c, 0xcd, 0xbc, 0xfe, 0x40, 0x20, 0xd0, 0x65, 0x58, 0xdc, - 0x63, 0xd9, 0x83, 0xe8, 0x30, 0x76, 0xd9, 0x27, 0x43, 0x96, 0x66, 0xf4, 0x2f, 0x1b, 0xb0, 0xa4, - 0x41, 0xe9, 0x20, 0x8e, 0x52, 0x46, 0xd6, 0x61, 0x7a, 0x38, 0xe0, 0x5d, 0x5b, 0xce, 0x75, 0xe7, - 0x56, 0xd3, 0x95, 0x5f, 0xe4, 0x0e, 0xac, 0x78, 0x27, 0x5e, 0x10, 0x7a, 0xdd, 0x90, 0x75, 0xd8, - 0xd3, 0xde, 0xb1, 0x17, 0x1d, 0xb1, 0xb4, 0x55, 0xbb, 0xee, 0xdc, 0xaa, 0xbb, 0x44, 0x37, 0xbd, - 0xa3, 0x5a, 0xc8, 0x4b, 0x70, 0x89, 0x45, 0x1c, 0xe4, 0x1b, 0xe8, 0x75, 0x44, 0x5f, 0x96, 0x0d, - 0x39, 0xf2, 0x1b, 0xb0, 0xee, 0xb3, 0x43, 0x6f, 0x18, 0x66, 0x9d, 0xc3, 0x38, 0x61, 0x4f, 0x3b, - 0x83, 0x24, 0x3e, 0x09, 0x7c, 0x96, 0xb4, 0x1a, 0x28, 0xc5, 0xaa, 0x6c, 0x7d, 0x97, 0x37, 0x3e, - 0x92, 0x6d, 0xe4, 0x2e, 0xac, 0xe9, 0x5e, 0x81, 0x97, 0x75, 0x7a, 0xc3, 0x24, 0x61, 0x51, 0xef, - 0xac, 0x35, 0x85, 0x9d, 0x56, 0x54, 0xa7, 0xc0, 0xcb, 0x76, 0x65, 0x13, 0xf9, 0x10, 0x96, 0xd3, - 0x61, 0x37, 0x3d, 0x4b, 0x33, 0xd6, 0xef, 0xa4, 0x99, 0x97, 0x0d, 0xd3, 0xd6, 0xf4, 0xf5, 0xfa, - 0xad, 0xb9, 0xbb, 0x2f, 0x6f, 0x0b, 0x3d, 0x6f, 0x17, 0x54, 0xb2, 0xbd, 0xaf, 0xf0, 0xf7, 0x11, - 0xfd, 0x9d, 0x28, 0x4b, 0xce, 0xdc, 0xa5, 0xd4, 0x86, 0x92, 0xf7, 0x60, 0x21, 0x19, 0xf4, 0x3a, - 0x2c, 0xf2, 0x07, 0x71, 0x10, 0x65, 0x69, 0x6b, 0x06, 0xa9, 0xde, 0x1e, 0x45, 0xd5, 0x1d, 0xf4, - 0xde, 0x51, 0xb8, 0x82, 0xe4, 0x7c, 0x62, 0x80, 0xda, 0xf7, 0x60, 0xb5, 0x8a, 0x31, 0x59, 0x86, - 0xfa, 0x13, 0x76, 0x26, 0x67, 0x87, 0xff, 0x24, 0xab, 0x30, 0x75, 0xe2, 0x85, 0x43, 0x86, 0x93, - 0x31, 0xeb, 0x8a, 0x8f, 0xb7, 0x6b, 0x6f, 0x39, 0xed, 0x03, 0xb8, 0x54, 0x62, 0x53, 0x41, 0xe0, - 0xb6, 0x49, 0x60, 0xee, 0xee, 0x8a, 0x12, 0xd9, 0x7d, 0xb4, 0xab, 0xfa, 0x1a, 0x54, 0xe9, 0x0d, - 0xd8, 0xda, 0x63, 0xd9, 0x6e, 0xdc, 0xef, 0x0f, 0xa3, 0xa0, 0x87, 0x46, 0xe8, 0xb2, 0xd0, 0x3b, - 0x63, 0x49, 0xaa, 0x2c, 0xeb, 0x3d, 0x58, 0xad, 0x6a, 0x27, 0x2d, 0x98, 0x91, 0x73, 0x8f, 0xfc, - 0x67, 0x5d, 0xf5, 0x49, 0x36, 0xa1, 0xd9, 0x8b, 0xa3, 0x88, 0xf5, 0x32, 0xe6, 0xcb, 0x81, 0xe4, - 0x00, 0xfa, 0x3b, 0x35, 0xb8, 0x3e, 0x9a, 0xa7, 0x34, 0xdd, 0xef, 0xc1, 0x7a, 0xcf, 0x44, 0xe8, - 0x24, 0x12, 0xa3, 0xe5, 0xe0, 0x54, 0xec, 0x1a, 0x53, 0x31, 0x96, 0xd2, 0x76, 0x65, 0xab, 0x98, - 0xa4, 0xb5, 0x5e, 0x55, 0x5b, 0xfb, 0x10, 0xda, 0xa3, 0x3b, 0x55, 0xa8, 0xfc, 0xae, 0xad, 0xf2, - 0x4d, 0x25, 0x5a, 0x15, 0x11, 0x53, 0xf7, 0x5f, 0x80, 0x8d, 0x3d, 0x16, 0xb1, 0x24, 0xe8, 0x69, - 0xe3, 0x90, 0x3a, 0xe7, 0x1a, 0xd4, 0x36, 0x29, 0x59, 0xe5, 0x00, 0xba, 0x0e, 0xab, 0x7b, 0x2c, - 0xd3, 0x9d, 0xf4, 0x4c, 0xfd, 0xc2, 0x81, 0x35, 0x6c, 0x48, 0xbb, 0xe9, 0x99, 0x68, 0x90, 0xea, - 0xfc, 0x0d, 0xb8, 0xa4, 0xbb, 0xa7, 0x6a, 0xa9, 0x08, 0x4d, 0xbe, 0x6e, 0x68, 0xb2, 0xdc, 0x33, - 0x5f, 0x30, 0xa9, 0xb9, 0x62, 0xf2, 0x75, 0x27, 0xc1, 0xed, 0x5d, 0x58, 0xab, 0x44, 0xbd, 0x88, - 0x8d, 0xd3, 0x16, 0xac, 0xef, 0xb1, 0xcc, 0x30, 0x55, 0xc3, 0x08, 0xe7, 0x0c, 0x30, 0xb7, 0xbd, - 0x34, 0xf3, 0x92, 0x2c, 0xb7, 0x3d, 0xf9, 0x49, 0x9e, 0x87, 0xc5, 0x30, 0x48, 0x33, 0x16, 0x75, - 0x3c, 0xdf, 0x4f, 0x58, 0x2a, 0xdc, 0x5a, 0xd3, 0x5d, 0x10, 0xd0, 0x1d, 0x01, 0xa4, 0x7f, 0xed, - 0x70, 0xe5, 0x17, 0x58, 0x49, 0x65, 0x3d, 0x84, 0x66, 0xbe, 0xf2, 0x85, 0x92, 0xb6, 0x0d, 0x25, - 0x55, 0xf5, 0xd9, 0x2e, 0x2c, 0xff, 0x9c, 0x40, 0xfb, 0xdb, 0xb0, 0xf8, 0xac, 0x17, 0xed, 0x5b, - 0xd0, 0x96, 0x86, 0xa3, 0xbc, 0xee, 0x7b, 0x5e, 0x9f, 0x29, 0xdb, 0x69, 0xc3, 0xac, 0x72, 0xd2, - 0x92, 0x87, 0xfe, 0xa6, 0x77, 0x60, 0x65, 0x8f, 0x65, 0xda, 0x57, 0xab, 0x2e, 0x23, 0x97, 0x32, - 0x7d, 0x03, 0x4d, 0xcd, 0xe8, 0x20, 0x75, 0xb4, 0x09, 0xcd, 0x7c, 0x27, 0x90, 0x06, 0xaa, 0x01, - 0xf4, 0x2e, 0xda, 0xa1, 0xea, 0xf5, 0xfe, 0xc1, 0x23, 0x97, 0x89, 0x6e, 0x97, 0x61, 0x36, 0xce, - 0x06, 0x9d, 0x5e, 0xec, 0x2b, 0xd9, 0x66, 0xe2, 0x6c, 0xb0, 0x1b, 0xfb, 0x4c, 0xce, 0xbd, 0xd1, - 0x47, 0xcf, 0xfd, 0x9f, 0x8a, 0xb9, 0xb2, 0x9b, 0xa4, 0x1c, 0xdf, 0x80, 0xa6, 0x22, 0xa8, 0xe6, - 0xea, 0x15, 0x63, 0xae, 0xaa, 0xfa, 0x6c, 0xbf, 0x2f, 0x38, 0xca, 0xa9, 0x9a, 0x95, 0x02, 0xa4, - 0xed, 0x2f, 0xc1, 0x82, 0xd5, 0x74, 0x9e, 0xe9, 0x36, 0xcd, 0x39, 0x79, 0x03, 0xd6, 0xef, 0x07, - 0xa9, 0xb9, 0x6d, 0x4e, 0x32, 0x1f, 0x1f, 0xc3, 0xe2, 0x23, 0x2f, 0x48, 0xd2, 0xfd, 0xe1, 0x60, - 0x10, 0xa3, 0xfd, 0xbe, 0x00, 0x4b, 0xf9, 0xde, 0x3c, 0xe0, 0x6d, 0xb2, 0xd3, 0xa2, 0x06, 0x63, - 0x0f, 0xf2, 0x1c, 0x2c, 0xa8, 0x3d, 0x59, 0xa0, 0x09, 0x91, 0xe6, 0x25, 0x10, 0x91, 0xe8, 0x8f, - 0x1a, 0x96, 0xea, 0xac, 0xe8, 0x80, 0x40, 0x23, 0xf2, 0x74, 0x6c, 0x80, 0xbf, 0x4d, 0x43, 0xa8, - 0xd9, 0x3e, 0xbd, 0x05, 0x33, 0x27, 0x2c, 0xe9, 0xc6, 0x29, 0xc3, 0x8d, 0x7f, 0xd6, 0x55, 0x9f, - 0x5c, 0x90, 0x61, 0x1a, 0x44, 0x47, 0x9d, 0xd4, 0x8b, 0xfc, 0x6e, 0xfc, 0x14, 0xb7, 0xf9, 0x59, - 0x77, 0x1e, 0x81, 0xfb, 0x02, 0x46, 0x6e, 0xc0, 0xfc, 0x71, 0x96, 0x0d, 0x3a, 0x3c, 0xfe, 0x88, - 0x87, 0x99, 0xdc, 0xd5, 0xe7, 0x38, 0xec, 0x40, 0x80, 0xf8, 0xca, 0x45, 0x94, 0x61, 0xca, 0x12, - 0xef, 0x88, 0x45, 0x59, 0x6b, 0x5a, 0xac, 0x5c, 0x0e, 0x7d, 0xac, 0x80, 0xe4, 0x2a, 0x00, 0xa2, - 0x0d, 0x92, 0xf8, 0xe9, 0x59, 0x6b, 0x46, 0x98, 0x1e, 0x87, 0x3c, 0xe2, 0x00, 0xae, 0xbf, 0xae, - 0x97, 0x32, 0x15, 0x3f, 0x04, 0x2c, 0x6d, 0xcd, 0x0a, 0xfd, 0x71, 0xf0, 0xae, 0x86, 0x92, 0x0e, - 0x0f, 0x1e, 0xa4, 0xd6, 0x3b, 0x5e, 0x9a, 0xb2, 0x2c, 0x6d, 0x35, 0xd1, 0x80, 0xde, 0xa8, 0x30, - 0xa0, 0x42, 0x10, 0x21, 0xfb, 0xed, 0x60, 0x37, 0x1d, 0x44, 0x58, 0x50, 0x1e, 0x34, 0x79, 0xc3, - 0xec, 0x98, 0x45, 0x19, 0xdf, 0x02, 0x38, 0x93, 0x41, 0xd0, 0x02, 0xd4, 0xcd, 0xb2, 0xd5, 0xb0, - 0x33, 0x08, 0xda, 0x1f, 0xf1, 0x08, 0xa1, 0x4c, 0xb5, 0xc2, 0x04, 0x5f, 0xb6, 0x7d, 0xc5, 0xba, - 0x12, 0xd6, 0xb6, 0x23, 0xd3, 0x34, 0x4f, 0x61, 0x79, 0x8f, 0x65, 0x07, 0x41, 0xef, 0x09, 0x4b, - 0x26, 0x30, 0x4a, 0x72, 0x0b, 0x1a, 0xdc, 0xa2, 0x24, 0x83, 0x55, 0xbd, 0x9d, 0xc9, 0xb0, 0x8b, - 0x33, 0x72, 0x11, 0x83, 0xcf, 0x05, 0x6a, 0xae, 0x93, 0x9d, 0x0d, 0x84, 0x5d, 0x34, 0xdd, 0x26, - 0x42, 0x0e, 0xce, 0x06, 0x8c, 0x7e, 0x00, 0xf3, 0x66, 0x27, 0xee, 0x34, 0x7c, 0x16, 0x06, 0xfd, - 0x20, 0x63, 0x89, 0x72, 0x1a, 0x1a, 0xc0, 0xed, 0x91, 0x4f, 0x91, 0xb4, 0x63, 0xfc, 0xcd, 0xd7, - 0xdb, 0x27, 0xc3, 0x38, 0x53, 0xb4, 0xc5, 0x07, 0xfd, 0x69, 0x0d, 0x16, 0xd5, 0x70, 0xa4, 0x31, - 0x2b, 0x99, 0x9d, 0x73, 0x65, 0xbe, 0x01, 0xf3, 0xa1, 0x97, 0x66, 0x9d, 0xe1, 0xc0, 0xf7, 0x54, - 0x7c, 0x52, 0x77, 0xe7, 0x38, 0xec, 0xb1, 0x00, 0x71, 0x8b, 0x56, 0xe1, 0x27, 0xae, 0x2d, 0xc9, - 0x7d, 0xbe, 0x67, 0x0e, 0x86, 0x40, 0x83, 0xf7, 0x41, 0x6b, 0x77, 0x5c, 0xfc, 0xcd, 0x61, 0xc7, - 0xc1, 0xd1, 0x31, 0x5a, 0xb7, 0xe3, 0xe2, 0x6f, 0x3e, 0x83, 0x61, 0x7c, 0x8a, 0xb6, 0xec, 0xb8, - 0xfc, 0x27, 0x87, 0x74, 0x03, 0x1f, 0x4d, 0xd7, 0x71, 0xf9, 0x4f, 0x0e, 0xf1, 0xd2, 0x27, 0x68, - 0xa8, 0x8e, 0xcb, 0x7f, 0xf2, 0xd0, 0xfd, 0x24, 0x0e, 0x87, 0x7d, 0xd6, 0x6a, 0x22, 0x50, 0x7e, - 0x91, 0x2b, 0xd0, 0x1c, 0x24, 0x41, 0x8f, 0x75, 0xbc, 0xec, 0x18, 0x8d, 0xc9, 0x71, 0x67, 0x11, - 0xb0, 0x93, 0x1d, 0xd3, 0x15, 0xb8, 0xa4, 0x27, 0x5a, 0x7b, 0xcf, 0x0f, 0x61, 0x46, 0x42, 0xc6, - 0x4e, 0xfa, 0xab, 0x30, 0x93, 0x09, 0xb4, 0x56, 0x0d, 0x57, 0x81, 0x36, 0x2c, 0x5b, 0xd3, 0xae, - 0x42, 0xa3, 0x5f, 0x03, 0x62, 0x72, 0x93, 0x13, 0x71, 0x3b, 0xa7, 0x23, 0xdc, 0xf1, 0x92, 0x4d, - 0x27, 0xcd, 0x09, 0x7c, 0x0f, 0x37, 0xa3, 0xf7, 0x13, 0x9f, 0x3b, 0x92, 0xf8, 0xc9, 0x67, 0x6a, - 0x9a, 0xdf, 0x82, 0x05, 0xcd, 0xf8, 0x41, 0xc6, 0xfa, 0x5c, 0xe1, 0x5e, 0x3f, 0x1e, 0x46, 0x19, - 0xf2, 0x74, 0x5c, 0xf9, 0xc5, 0x2d, 0x10, 0xf5, 0x8b, 0x2c, 0x1d, 0x57, 0x7c, 0x90, 0x45, 0xa8, - 0x05, 0xbe, 0x3c, 0x01, 0xd5, 0x02, 0x9f, 0xfe, 0x8f, 0x03, 0x97, 0x8c, 0x81, 0x5c, 0xd8, 0x28, - 0x4b, 0x16, 0x57, 0xab, 0xb0, 0xb8, 0xdb, 0xd0, 0xe8, 0x06, 0x3e, 0x3f, 0x78, 0x71, 0xbd, 0xae, - 0x29, 0x72, 0xd6, 0x38, 0x5c, 0x44, 0xe1, 0xa8, 0x5e, 0xfa, 0x24, 0x6d, 0x35, 0xc6, 0xa2, 0x72, - 0x94, 0xd2, 0x7a, 0x98, 0x2a, 0xaf, 0x07, 0x5b, 0x97, 0xd3, 0x45, 0x5d, 0x8a, 0x70, 0x54, 0xd3, - 0xd6, 0x96, 0xd7, 0x03, 0xc8, 0x81, 0x63, 0xa7, 0xf5, 0x8b, 0x00, 0xb1, 0xc6, 0x94, 0xf6, 0x77, - 0xb9, 0x24, 0xb4, 0x36, 0x41, 0x03, 0x99, 0x7e, 0x13, 0x43, 0x0d, 0x93, 0xb9, 0x54, 0xfe, 0x5d, - 0x8b, 0xa6, 0xb0, 0x45, 0x52, 0xa2, 0x99, 0x5a, 0xc4, 0x5e, 0x47, 0x62, 0x3b, 0xbd, 0x1e, 0x9f, - 0x7a, 0xe3, 0x74, 0x3d, 0x76, 0x0f, 0xff, 0x00, 0x66, 0x64, 0x0f, 0x69, 0x16, 0x02, 0xa1, 0x16, - 0xf8, 0xe4, 0x4b, 0x00, 0xc6, 0x3e, 0x24, 0xc6, 0x75, 0x45, 0xc9, 0x20, 0x3b, 0x29, 0x6b, 0x40, - 0x76, 0x06, 0x3a, 0x3d, 0x84, 0x95, 0x0a, 0x14, 0x2e, 0x8a, 0x3e, 0x1b, 0x4b, 0x51, 0xd4, 0x37, - 0xd9, 0x82, 0xb9, 0x2c, 0xce, 0xbc, 0xb0, 0x93, 0xef, 0x10, 0x8e, 0x0b, 0x08, 0xfa, 0x80, 0x43, - 0xd0, 0x41, 0xc5, 0xa1, 0xb0, 0x5c, 0xee, 0xa0, 0xe2, 0xd0, 0xa7, 0x1e, 0x06, 0x5e, 0xd6, 0xa0, - 0xa5, 0x0a, 0xc7, 0x4d, 0xd9, 0x4b, 0x30, 0xeb, 0x89, 0x2e, 0x6a, 0x60, 0x4b, 0x85, 0x81, 0xb9, - 0x1a, 0x81, 0x12, 0xdc, 0x81, 0x76, 0xe3, 0xe8, 0x30, 0x38, 0x52, 0xd6, 0xf1, 0x02, 0x3a, 0x2b, - 0x05, 0xcb, 0x63, 0x12, 0xdf, 0xcb, 0x3c, 0xe4, 0x36, 0xef, 0xe2, 0x6f, 0xfa, 0xdb, 0x0e, 0x2c, - 0x3f, 0x8a, 0x93, 0xec, 0x30, 0x0e, 0x83, 0x58, 0xc6, 0xef, 0x3c, 0x1c, 0x51, 0xf1, 0xbd, 0x8c, - 0x23, 0xe5, 0x27, 0xf7, 0x90, 0xbd, 0x38, 0x88, 0x84, 0xad, 0xd6, 0xa4, 0x82, 0xe2, 0x20, 0xe2, - 0xa6, 0x4a, 0xae, 0xc3, 0x9c, 0xcf, 0xd2, 0x5e, 0x12, 0x0c, 0xf8, 0x99, 0x4c, 0xba, 0x05, 0x13, - 0xc4, 0x09, 0x77, 0xbd, 0xd0, 0x8b, 0x7a, 0x4c, 0x7a, 0x76, 0xf5, 0x49, 0xd7, 0xd0, 0x5d, 0x69, - 0x49, 0x8c, 0xe3, 0xb1, 0x0d, 0x96, 0x43, 0xf9, 0x3c, 0x34, 0x07, 0x0a, 0x28, 0xcd, 0xaf, 0xa5, - 0xf7, 0xea, 0xc2, 0x70, 0xdc, 0x1c, 0x95, 0x6e, 0xf2, 0xe0, 0x3e, 0xa7, 0xb7, 0x3f, 0xec, 0xf7, - 0xbd, 0xe4, 0x4c, 0x71, 0x8b, 0xa0, 0xb1, 0x1b, 0x07, 0x11, 0x57, 0x14, 0x1f, 0x94, 0x0a, 0xde, - 0xf8, 0x6f, 0x53, 0xf4, 0x9a, 0x25, 0xba, 0xa9, 0xad, 0xba, 0xad, 0xad, 0x6b, 0x00, 0x03, 0x96, - 0xf4, 0x58, 0x94, 0x79, 0x47, 0x6a, 0xc4, 0x06, 0x84, 0x1e, 0x03, 0x79, 0xff, 0xf0, 0x30, 0x0c, - 0x22, 0xc6, 0xd9, 0x4a, 0x61, 0xc6, 0x68, 0x7f, 0xb4, 0x0c, 0x36, 0xa7, 0x7a, 0x89, 0xd3, 0xb7, - 0xe0, 0xd2, 0xfb, 0x51, 0x05, 0x23, 0x45, 0xce, 0x19, 0x47, 0xae, 0x56, 0x22, 0xf7, 0x75, 0x98, - 0x37, 0x04, 0x4f, 0xc9, 0x5b, 0xd0, 0x94, 0x32, 0xea, 0x83, 0x42, 0x5b, 0x7b, 0x83, 0xd2, 0x08, - 0xdd, 0x1c, 0x99, 0xfe, 0x91, 0x03, 0x73, 0xb9, 0x64, 0x29, 0x79, 0x03, 0xa6, 0xb8, 0xba, 0x15, - 0x95, 0x6b, 0x9a, 0x4a, 0x8e, 0xb3, 0x8d, 0xff, 0x8a, 0xb8, 0x50, 0x20, 0xb7, 0xf7, 0x01, 0x72, - 0x60, 0x45, 0x58, 0x77, 0xc7, 0x0e, 0xeb, 0x2e, 0x97, 0xa9, 0x2a, 0xd1, 0x8c, 0xc8, 0xee, 0xef, - 0x1a, 0x70, 0xa5, 0xd2, 0x58, 0xa4, 0x0d, 0xbe, 0x02, 0x73, 0x62, 0x2d, 0x70, 0x0f, 0xa0, 0x04, - 0x9e, 0xcf, 0xf3, 0x13, 0x41, 0xe4, 0x02, 0xae, 0x0d, 0x6c, 0x27, 0xaf, 0xc1, 0x02, 0x0a, 0xdb, - 0x89, 0x85, 0x42, 0xe4, 0xc2, 0xb6, 0x3b, 0xcc, 0x23, 0x8a, 0x54, 0x19, 0x19, 0xc0, 0x9a, 0xd5, - 0xa5, 0x93, 0x0a, 0x11, 0xe4, 0x26, 0xf5, 0x65, 0x23, 0x94, 0x1e, 0x25, 0xa5, 0x50, 0x96, 0x24, - 0x28, 0xdb, 0x84, 0xea, 0x56, 0x7a, 0xe5, 0x16, 0x72, 0x07, 0xe6, 0x25, 0x47, 0xd4, 0x8c, 0xdc, - 0xe2, 0x6c, 0x19, 0xe7, 0x44, 0x47, 0x44, 0x20, 0x7d, 0x58, 0x35, 0x3b, 0x68, 0x09, 0xa7, 0xb0, - 0xe3, 0x97, 0x26, 0x97, 0x30, 0x2a, 0x09, 0x48, 0x7a, 0xa5, 0x86, 0xf6, 0xff, 0x87, 0xd6, 0xa8, - 0x01, 0x55, 0x4c, 0xfb, 0x8b, 0xf6, 0xb4, 0xaf, 0x56, 0x98, 0x64, 0x6a, 0x66, 0x01, 0x3f, 0x82, - 0x8d, 0x11, 0xc2, 0x5c, 0x20, 0xad, 0x60, 0x58, 0xaa, 0x69, 0x4d, 0xff, 0xec, 0x40, 0x7b, 0xc7, - 0xf7, 0x4b, 0xce, 0x29, 0x4f, 0x12, 0x7c, 0xc6, 0x2e, 0x97, 0xdc, 0x81, 0x95, 0xfc, 0x8c, 0x96, - 0xe7, 0x1b, 0xc4, 0xe1, 0x91, 0xe8, 0xa6, 0x3c, 0xf7, 0x7c, 0x83, 0x1b, 0x47, 0xe8, 0x77, 0xd2, - 0x2c, 0xe6, 0xc7, 0x45, 0x8c, 0x55, 0x66, 0xb9, 0x39, 0x84, 0xfe, 0xbe, 0x00, 0xd1, 0xa7, 0x70, - 0xd5, 0x65, 0xfd, 0xf8, 0x84, 0x7d, 0xd6, 0xe3, 0xa4, 0x6d, 0x68, 0xed, 0x31, 0x3b, 0xed, 0xad, - 0x63, 0xa5, 0xff, 0x70, 0x60, 0xc1, 0x4e, 0x88, 0x3f, 0xab, 0xe3, 0xf9, 0xcb, 0x40, 0x12, 0x96, - 0x66, 0x9d, 0x41, 0x1c, 0x86, 0xfc, 0x94, 0xee, 0xb3, 0xd0, 0x3b, 0x93, 0xa9, 0xf8, 0x65, 0xde, - 0xf2, 0x48, 0x34, 0xdc, 0xe7, 0x70, 0xb2, 0x01, 0x33, 0xde, 0x20, 0xe8, 0x70, 0x43, 0x12, 0x5a, - 0x9e, 0xf6, 0x06, 0xc1, 0x37, 0xd9, 0x19, 0xa1, 0xb0, 0x20, 0x1b, 0x3a, 0x21, 0x3b, 0x61, 0x21, - 0xaa, 0xb6, 0xee, 0xce, 0x89, 0xe6, 0x87, 0x1c, 0x44, 0x6e, 0xc3, 0xf2, 0x20, 0x09, 0xb8, 0x45, - 0xe6, 0x39, 0xff, 0x19, 0x94, 0x66, 0x49, 0xc2, 0xd5, 0xe8, 0xe8, 0x77, 0xe0, 0x72, 0x85, 0x2e, - 0xa4, 0xdb, 0xfa, 0x2a, 0x2c, 0xd9, 0x37, 0x07, 0xca, 0x75, 0xe9, 0x40, 0xd6, 0xea, 0xe8, 0x2e, - 0x1e, 0x5a, 0x74, 0x64, 0x40, 0x8a, 0x38, 0xae, 0x97, 0xe9, 0x34, 0x17, 0xfd, 0x04, 0x56, 0x73, - 0xe0, 0x6e, 0x1c, 0x9d, 0xb0, 0x24, 0xe5, 0x06, 0x48, 0xa0, 0x71, 0x98, 0xc4, 0x2a, 0xd1, 0x8a, - 0xbf, 0x79, 0x28, 0x97, 0xc5, 0x72, 0x92, 0x6b, 0x59, 0xcc, 0x71, 0x12, 0x2f, 0x53, 0x1b, 0x17, - 0xfe, 0xe6, 0xd6, 0x16, 0x20, 0x11, 0xd6, 0xc1, 0x36, 0x61, 0xbd, 0x73, 0x12, 0xc6, 0xb9, 0xd0, - 0x0f, 0x30, 0xa2, 0x34, 0x45, 0x91, 0x63, 0xfc, 0x0a, 0xcc, 0x89, 0x31, 0xf2, 0x9e, 0x6a, 0x7c, - 0x9b, 0xd6, 0xf8, 0x0a, 0x62, 0xba, 0x70, 0xa8, 0xa1, 0xf4, 0xe7, 0x75, 0x98, 0xc7, 0x20, 0xf6, - 0x3e, 0xcb, 0xbc, 0x20, 0x1c, 0x1f, 0x5e, 0x8b, 0xb0, 0xb4, 0xa6, 0xc3, 0xd2, 0xe7, 0x60, 0xc1, - 0xcc, 0x91, 0x9c, 0xa9, 0xf3, 0xad, 0x91, 0x21, 0x39, 0x23, 0xcf, 0xc3, 0x22, 0x9e, 0xb6, 0x73, - 0x2c, 0x61, 0x33, 0x0b, 0x08, 0xd5, 0x68, 0xf6, 0xd9, 0x60, 0xaa, 0x70, 0x36, 0xe0, 0xcd, 0x18, - 0x5f, 0x77, 0xd2, 0xc0, 0xd7, 0x47, 0x07, 0x84, 0xec, 0x07, 0xbe, 0xd1, 0x8c, 0xbd, 0x67, 0x8c, - 0x66, 0xec, 0xcd, 0x8f, 0x45, 0x09, 0x13, 0x17, 0x00, 0x78, 0x8f, 0x35, 0x8b, 0x46, 0x37, 0xaf, - 0x80, 0x07, 0x41, 0x1f, 0x6f, 0xb9, 0x64, 0x42, 0xbb, 0x29, 0x2c, 0x56, 0x7c, 0xe5, 0x27, 0x37, - 0x30, 0x4f, 0x6e, 0xf9, 0x39, 0x6f, 0xce, 0x3a, 0xe7, 0x6d, 0xc1, 0x5c, 0x3c, 0x60, 0x51, 0x47, - 0x9e, 0xba, 0xe7, 0x45, 0x40, 0xc1, 0x41, 0x1f, 0x88, 0x93, 0xf7, 0x32, 0xd4, 0x0f, 0x19, 0x6b, - 0x2d, 0x88, 0x33, 0xfa, 0x21, 0xe3, 0x2b, 0x6b, 0x3a, 0x4b, 0x3c, 0x9f, 0xa5, 0xad, 0x45, 0x9c, - 0x3d, 0xed, 0xbc, 0x0f, 0x38, 0xf4, 0xeb, 0x01, 0x77, 0x42, 0x67, 0xae, 0xc4, 0xa1, 0xff, 0xe4, - 0xc0, 0xbc, 0xd9, 0x50, 0x1e, 0x9c, 0x53, 0x31, 0xb8, 0xe2, 0xd4, 0xe9, 0x41, 0xd5, 0xab, 0x07, - 0xd5, 0xb0, 0x06, 0x65, 0x1a, 0xc5, 0x54, 0xc1, 0x28, 0xc6, 0x1f, 0xea, 0x0a, 0x13, 0x37, 0x53, - 0x9c, 0x38, 0xa9, 0x8d, 0x59, 0xad, 0x0d, 0x99, 0x65, 0x42, 0x9b, 0x4c, 0x27, 0x39, 0xca, 0xdb, - 0xfc, 0x6b, 0x45, 0xfe, 0xea, 0xec, 0x5c, 0x3f, 0xef, 0xec, 0x4c, 0x77, 0xf0, 0x20, 0xa1, 0x18, - 0xcb, 0xe5, 0xf5, 0x32, 0x4c, 0xa3, 0xb0, 0x6a, 0x65, 0xad, 0x5a, 0x27, 0x3f, 0xb9, 0x68, 0x5c, - 0x89, 0x43, 0xbf, 0x8e, 0x77, 0xa7, 0xd8, 0x34, 0x89, 0xe8, 0x97, 0x61, 0x56, 0xe8, 0x46, 0x4f, - 0xcd, 0x0c, 0x7e, 0x3f, 0xf0, 0xe9, 0x2f, 0x1d, 0x20, 0xfb, 0xc3, 0x6e, 0x3f, 0x98, 0x9c, 0xda, - 0xe4, 0x39, 0x0d, 0x02, 0x0d, 0x9c, 0x0d, 0xb1, 0x5c, 0xf1, 0x77, 0x61, 0x05, 0x35, 0x8a, 0x2b, - 0x28, 0xb7, 0x8c, 0xa9, 0xea, 0xb4, 0xc6, 0xb4, 0x69, 0x47, 0x7c, 0x83, 0x0b, 0x03, 0x16, 0x65, - 0x1d, 0x99, 0x9f, 0xe2, 0x1b, 0x1c, 0x02, 0x1e, 0xf8, 0x74, 0x1f, 0x56, 0xac, 0x91, 0x49, 0x4d, - 0xdf, 0x80, 0x79, 0x21, 0xc0, 0x20, 0xf4, 0x7a, 0xfa, 0x02, 0x61, 0x0e, 0x61, 0x8f, 0x10, 0x34, - 0x4e, 0x5f, 0xbf, 0xeb, 0xc0, 0xea, 0x7e, 0xd0, 0x1f, 0x86, 0x5e, 0xc6, 0x7e, 0x0d, 0x1a, 0xcb, - 0x87, 0x5f, 0xb7, 0x86, 0xaf, 0x34, 0xd9, 0xc8, 0x35, 0x49, 0xff, 0xcb, 0x81, 0xb5, 0x82, 0x28, - 0x3a, 0x8c, 0xb6, 0x8d, 0x69, 0x44, 0x3e, 0x45, 0x22, 0x19, 0x4c, 0x6b, 0x16, 0xd3, 0xe7, 0x60, - 0xa1, 0x1f, 0x44, 0x41, 0x7f, 0xd8, 0xef, 0x98, 0x6b, 0x78, 0x5e, 0x02, 0x1f, 0xe1, 0x14, 0x70, - 0x24, 0xef, 0xa9, 0x81, 0xd4, 0x90, 0x48, 0x02, 0x28, 0x90, 0x5e, 0x85, 0xd5, 0xfc, 0xa8, 0xd3, - 0x39, 0xf2, 0x82, 0xa8, 0x13, 0xc6, 0x69, 0x2a, 0xe7, 0x98, 0xe4, 0x6d, 0x7b, 0x5e, 0x10, 0x3d, - 0x8c, 0xd3, 0xd4, 0x70, 0x92, 0xd3, 0xa6, 0x93, 0xa4, 0x7f, 0xe0, 0xc0, 0xf2, 0x87, 0xc7, 0x5e, - 0xc8, 0xee, 0xc5, 0xfd, 0xee, 0xb3, 0xd5, 0xfd, 0x0d, 0x98, 0x17, 0xa9, 0xca, 0xcc, 0x4b, 0x8e, - 0x98, 0x9a, 0x81, 0x39, 0x84, 0x1d, 0x20, 0xa8, 0x72, 0x1a, 0xfe, 0xd3, 0x01, 0xb2, 0xcb, 0xa3, - 0xbf, 0x70, 0x62, 0x7b, 0xe0, 0xae, 0x44, 0xa4, 0x1a, 0x72, 0x0b, 0x6b, 0x4a, 0xc8, 0x03, 0xdb, - 0xfc, 0xea, 0x96, 0xf9, 0xe9, 0xd1, 0x34, 0x2e, 0x98, 0x4f, 0x2c, 0xed, 0x73, 0xcf, 0xc3, 0xe2, - 0xa9, 0x17, 0x86, 0x2c, 0xd3, 0xd7, 0x8e, 0xf2, 0xf2, 0x42, 0x40, 0x55, 0xda, 0x42, 0x0d, 0x78, - 0xc6, 0x18, 0xf0, 0x1b, 0xb0, 0x2e, 0xc6, 0xbb, 0x13, 0x86, 0x13, 0xbb, 0x4f, 0xfa, 0x27, 0x35, - 0xd8, 0x28, 0x75, 0xd3, 0xf1, 0x93, 0x6d, 0xaf, 0x37, 0xf5, 0xb8, 0xaa, 0x3b, 0x6c, 0xcb, 0x4f, - 0xd9, 0xab, 0xfd, 0x37, 0x0e, 0x4c, 0x0b, 0xd0, 0x58, 0xb5, 0x7f, 0xa4, 0x56, 0xbe, 0xb4, 0x2c, - 0x71, 0x5a, 0xfc, 0xc2, 0x64, 0xcc, 0xc4, 0x7f, 0xe6, 0x9d, 0xb2, 0x70, 0x19, 0xf2, 0x3a, 0xf9, - 0xab, 0xb0, 0x5c, 0x44, 0xb8, 0xd0, 0x75, 0x9c, 0xc8, 0x38, 0xbd, 0x73, 0xc2, 0x8c, 0x3b, 0xe4, - 0x5f, 0x38, 0xb0, 0xb4, 0x1b, 0x47, 0x7e, 0xc0, 0x77, 0xd7, 0x47, 0x5e, 0xe2, 0xf5, 0x53, 0x59, - 0xaa, 0x20, 0x40, 0xea, 0x4a, 0x42, 0x03, 0x46, 0x24, 0x7f, 0xaf, 0x02, 0xf4, 0x8e, 0x59, 0xef, - 0x49, 0x47, 0x66, 0x63, 0x45, 0x7d, 0x03, 0x87, 0xdc, 0x0b, 0xfc, 0x94, 0xbc, 0x02, 0x2b, 0x79, - 0x73, 0xc7, 0x8b, 0xfc, 0x8e, 0x4c, 0xc5, 0xe2, 0xcd, 0x8f, 0xc6, 0xdb, 0x89, 0xfc, 0x9d, 0xf4, - 0x49, 0xca, 0x83, 0x66, 0x9d, 0x81, 0xec, 0x58, 0xbe, 0x7a, 0x49, 0xc3, 0x77, 0x10, 0x4c, 0xff, - 0xdb, 0xc1, 0xad, 0x4e, 0x8d, 0x4a, 0xce, 0x76, 0x9e, 0x74, 0xc4, 0x5c, 0xb4, 0x35, 0x65, 0xb5, - 0xc2, 0x94, 0x11, 0x68, 0x04, 0x19, 0xeb, 0xab, 0x1d, 0x84, 0xff, 0x26, 0xf7, 0x60, 0x59, 0x8f, - 0xb8, 0x33, 0x40, 0xb5, 0xc8, 0xf5, 0xb0, 0x91, 0x1f, 0xaa, 0x2d, 0xad, 0xb9, 0x4b, 0xbd, 0x82, - 0x1a, 0xd5, 0x3a, 0x9a, 0x9a, 0xc8, 0x23, 0xf7, 0x50, 0xdb, 0xd2, 0x11, 0x89, 0x2f, 0x21, 0x35, - 0xeb, 0x0d, 0x33, 0xe6, 0xcb, 0x33, 0x83, 0xfe, 0xa6, 0xff, 0xea, 0xc0, 0xd2, 0x8e, 0xef, 0xe3, - 0xb8, 0x27, 0xf1, 0x07, 0x6a, 0x94, 0xb5, 0x73, 0x46, 0x59, 0xff, 0x94, 0xa3, 0xfc, 0x95, 0xbd, - 0xc5, 0x08, 0x25, 0x50, 0x0a, 0xcb, 0xf9, 0x38, 0xab, 0xa7, 0x97, 0x7e, 0x0e, 0x88, 0x38, 0xbf, - 0x5a, 0xea, 0x28, 0x62, 0xbd, 0x0b, 0xb7, 0xf6, 0x58, 0xb6, 0x9b, 0x9c, 0x0d, 0xb2, 0x58, 0x05, - 0xf0, 0xf7, 0xd9, 0x20, 0x4e, 0x03, 0xe5, 0x8b, 0xd8, 0x44, 0x6e, 0xe6, 0x6f, 0x1d, 0xb8, 0x3d, - 0x01, 0x21, 0x29, 0xeb, 0xc7, 0xe5, 0x24, 0xdb, 0xff, 0x33, 0x0b, 0x75, 0x26, 0xa2, 0xb2, 0xad, - 0x21, 0xb2, 0x96, 0x42, 0x93, 0x6c, 0x7f, 0x19, 0x16, 0xed, 0xc6, 0x0b, 0xf9, 0x84, 0x10, 0x6e, - 0x9e, 0x23, 0xc4, 0x24, 0xc6, 0x75, 0x13, 0x16, 0x7b, 0x16, 0x09, 0xc9, 0xa8, 0x00, 0xa5, 0xbb, - 0xf0, 0xc2, 0xb9, 0xdc, 0xa4, 0xda, 0x46, 0x66, 0x1c, 0xe8, 0xcf, 0x1d, 0x58, 0xf9, 0x30, 0xc8, - 0x8e, 0xfd, 0xc4, 0x3b, 0x7d, 0x37, 0xf0, 0x26, 0xb2, 0x7e, 0xf3, 0x82, 0xa0, 0x56, 0xb8, 0x20, - 0x18, 0x15, 0x0f, 0x15, 0x92, 0x17, 0x8d, 0x72, 0x92, 0xe6, 0x26, 0x2c, 0x75, 0xbd, 0xe8, 0x49, - 0xc7, 0xd8, 0x68, 0x85, 0x59, 0x2f, 0x70, 0xb0, 0xba, 0x3d, 0xf0, 0xe9, 0x3f, 0x3a, 0xb0, 0xa6, - 0x24, 0x16, 0x83, 0x9f, 0x44, 0x66, 0x43, 0x03, 0x35, 0x3b, 0xe7, 0xb2, 0x05, 0x73, 0xf2, 0x67, - 0x27, 0xf3, 0x8e, 0xa4, 0xe3, 0x02, 0x09, 0x3a, 0xf0, 0x8e, 0xac, 0xe1, 0x36, 0x46, 0x0e, 0xd7, - 0x8e, 0x7e, 0xe5, 0xe9, 0x65, 0x3a, 0x3f, 0xcb, 0x15, 0x14, 0x30, 0x53, 0xce, 0xde, 0xbc, 0x0d, - 0xcb, 0x6a, 0x5c, 0x15, 0x6b, 0x53, 0x9c, 0xce, 0xf2, 0x28, 0xab, 0x66, 0x45, 0x59, 0x2f, 0x43, - 0x5b, 0xf5, 0xf5, 0x42, 0x5c, 0xb7, 0xf7, 0xce, 0x1e, 0xdc, 0x2f, 0xaf, 0x5d, 0xa4, 0x42, 0x0f, - 0xe0, 0x4a, 0x25, 0xb6, 0x64, 0xfa, 0x26, 0x4c, 0x31, 0x0e, 0x94, 0x21, 0xd8, 0x96, 0x5a, 0x60, - 0x85, 0x3e, 0xfa, 0xb6, 0x4c, 0x60, 0x53, 0x06, 0x37, 0x0a, 0x18, 0xe9, 0xbd, 0xb3, 0x0b, 0xd4, - 0xaa, 0x54, 0x1d, 0x45, 0xf1, 0xea, 0x1e, 0xe7, 0x64, 0xca, 0x15, 0x1f, 0xf4, 0x0c, 0xae, 0x96, - 0xd9, 0xdc, 0xf7, 0xb2, 0x89, 0x58, 0xac, 0xc2, 0x14, 0xd6, 0x71, 0xa9, 0xb5, 0x8b, 0x1f, 0x7c, - 0xb6, 0x58, 0xa4, 0x42, 0x37, 0xfe, 0x33, 0x67, 0xdd, 0x30, 0x59, 0x7f, 0x07, 0xe8, 0xb8, 0x11, - 0x96, 0xd5, 0x57, 0xbf, 0x80, 0xfa, 0x7e, 0x5a, 0x83, 0x8d, 0x11, 0x28, 0x25, 0xcd, 0xbc, 0x6d, - 0x0c, 0x51, 0xec, 0x31, 0xd7, 0x8a, 0x5c, 0x42, 0x25, 0x97, 0xa0, 0x94, 0xab, 0xe0, 0x2d, 0x98, - 0x49, 0x84, 0xa6, 0xe4, 0x36, 0x73, 0xad, 0x2c, 0xa0, 0x54, 0xa5, 0xe8, 0xaa, 0xd0, 0xc9, 0x17, - 0x01, 0x30, 0x75, 0xc0, 0xfc, 0x8e, 0x97, 0xc9, 0x9d, 0xb8, 0xbd, 0x2d, 0x2a, 0x89, 0xb7, 0x55, - 0x25, 0xf1, 0xf6, 0x81, 0xaa, 0x24, 0x76, 0x9b, 0x12, 0x7b, 0x07, 0xbb, 0xca, 0xeb, 0x5f, 0xde, - 0x75, 0xfa, 0xfc, 0xae, 0x12, 0x7b, 0x27, 0xa3, 0x07, 0xb0, 0x5e, 0x3d, 0xa6, 0xca, 0x04, 0x66, - 0x51, 0x53, 0xf9, 0x82, 0xa9, 0x5b, 0x0b, 0xe6, 0xdf, 0x9c, 0x9c, 0xac, 0x3d, 0xde, 0xb1, 0xee, - 0xed, 0xfc, 0x5c, 0xf3, 0xa8, 0x4c, 0x09, 0x81, 0x86, 0xde, 0xaa, 0xa7, 0x5c, 0xfc, 0x4d, 0xee, - 0x40, 0xe3, 0x30, 0xd0, 0xfa, 0xd0, 0xf7, 0xb6, 0xdc, 0x0f, 0x17, 0x2d, 0x01, 0x11, 0xc9, 0x9b, - 0x30, 0x2d, 0x36, 0x01, 0xf4, 0x1f, 0x73, 0x77, 0xaf, 0xea, 0x08, 0x01, 0xa1, 0xc5, 0x4e, 0x12, - 0x99, 0xfe, 0x95, 0x03, 0x2b, 0x15, 0x44, 0xf9, 0x69, 0x1c, 0x5d, 0xae, 0xa1, 0xc5, 0x59, 0x0e, - 0x78, 0x8f, 0x6b, 0xf2, 0x06, 0xcc, 0x2b, 0x57, 0x8c, 0xed, 0x42, 0x15, 0x73, 0x12, 0x86, 0x28, - 0xcf, 0xc3, 0xa2, 0x46, 0x19, 0xf6, 0xbb, 0x4c, 0xd5, 0xb1, 0x2c, 0x28, 0x24, 0x04, 0x62, 0x39, - 0x4a, 0xda, 0x95, 0xbe, 0x93, 0xff, 0xc4, 0x65, 0x78, 0x1a, 0x1c, 0xaa, 0x2a, 0x2d, 0xf1, 0x81, - 0x51, 0x55, 0xd7, 0x53, 0x21, 0x0b, 0xfe, 0xa6, 0x3e, 0xac, 0x55, 0x8e, 0x6d, 0x4c, 0x12, 0xbd, - 0xe0, 0xd0, 0x6b, 0x25, 0x87, 0x2e, 0x9d, 0x73, 0x3d, 0x4f, 0x2d, 0xbd, 0x86, 0x45, 0x6c, 0x0f, - 0xe3, 0xa3, 0xa3, 0x3c, 0x75, 0x23, 0x8d, 0x7e, 0x1d, 0xa6, 0x43, 0x84, 0xab, 0x12, 0x77, 0xf1, - 0x45, 0x23, 0xcc, 0xb5, 0x17, 0xba, 0xe4, 0x97, 0xcc, 0x41, 0x74, 0x18, 0xcb, 0x4c, 0x05, 0xfe, - 0xe6, 0x43, 0xf6, 0x59, 0x77, 0x78, 0xa4, 0x6a, 0x52, 0xf1, 0x83, 0x63, 0x9e, 0x7a, 0x49, 0x24, - 0x63, 0x7c, 0xfc, 0xcd, 0x31, 0x59, 0x92, 0xc4, 0x89, 0x0c, 0xe8, 0xc5, 0x07, 0xdd, 0x83, 0x8d, - 0xfd, 0x8b, 0x89, 0x88, 0x4e, 0x0c, 0x33, 0xe9, 0xd2, 0xd9, 0xe1, 0x07, 0xfd, 0xa6, 0x55, 0xb0, - 0x87, 0x45, 0x5d, 0x13, 0x7a, 0x4e, 0x0c, 0x2f, 0x15, 0x31, 0xfc, 0xa0, 0xbf, 0x74, 0x50, 0x0d, - 0x05, 0x6a, 0xba, 0x26, 0xb8, 0x5c, 0x00, 0x27, 0x62, 0xb6, 0x37, 0x2b, 0x0a, 0xe0, 0xac, 0xbe, - 0x93, 0x55, 0xc0, 0xfd, 0x5a, 0x8b, 0xda, 0x7e, 0xe6, 0xc0, 0xfa, 0xbe, 0x2d, 0xde, 0x33, 0xc8, - 0x3a, 0xbe, 0x08, 0x53, 0xa2, 0x98, 0xb2, 0x6e, 0x67, 0x0d, 0xad, 0x10, 0x5f, 0xa0, 0xf0, 0x79, - 0x15, 0xb7, 0x2f, 0xd2, 0x12, 0xe4, 0x17, 0xfd, 0xa1, 0x83, 0x77, 0x1b, 0x3a, 0x37, 0xb4, 0x9f, - 0x25, 0xcc, 0xeb, 0x7f, 0xa6, 0xd5, 0x4d, 0x5f, 0x83, 0x1b, 0x66, 0xf1, 0xeb, 0x85, 0x25, 0xa1, - 0xbf, 0x89, 0x35, 0x21, 0xa2, 0x62, 0xeb, 0xff, 0x40, 0xfe, 0x2f, 0xc3, 0x35, 0x43, 0xfe, 0x0b, - 0x8a, 0x41, 0xff, 0xd8, 0xc1, 0xfb, 0x9f, 0x9d, 0xa1, 0x1f, 0x64, 0xd6, 0x21, 0xe9, 0x2a, 0x00, - 0x46, 0x14, 0x1d, 0xbe, 0x79, 0xe9, 0xb2, 0x7a, 0x0e, 0xe1, 0x01, 0x0a, 0xb9, 0x0c, 0xb3, 0x2c, - 0xf2, 0x45, 0xa3, 0x8c, 0x42, 0x59, 0xe4, 0xab, 0x26, 0x91, 0xea, 0xe8, 0x9e, 0x59, 0x29, 0xa4, - 0x7b, 0x67, 0xd5, 0xb1, 0x08, 0x37, 0x8e, 0xf8, 0xf0, 0x90, 0x2f, 0x48, 0xb1, 0xa3, 0xc8, 0x2f, - 0xba, 0x2b, 0x2a, 0x8c, 0x0c, 0xd1, 0xe4, 0x6a, 0x7c, 0x11, 0xa6, 0x31, 0xd0, 0x28, 0x95, 0x2a, - 0x19, 0xb8, 0x12, 0x83, 0xfe, 0xbb, 0xb0, 0x30, 0x71, 0x91, 0x10, 0xf4, 0x76, 0xbd, 0xc8, 0x0f, - 0x27, 0x3a, 0xce, 0x3d, 0xb3, 0x19, 0xca, 0x23, 0xb5, 0x06, 0x1e, 0x39, 0xed, 0x48, 0x4d, 0x94, - 0x90, 0x61, 0xa4, 0xf6, 0x1c, 0x2c, 0x64, 0x41, 0x9f, 0x75, 0x82, 0x28, 0x63, 0xc9, 0x89, 0xa7, - 0xae, 0x0d, 0xe7, 0x39, 0xf0, 0x81, 0x84, 0x71, 0x5e, 0xec, 0x69, 0x47, 0x85, 0x3d, 0xe2, 0xf4, - 0xdf, 0x64, 0x4f, 0x55, 0xde, 0xe6, 0xef, 0x1d, 0x2c, 0x89, 0x29, 0x0d, 0x77, 0x82, 0x2a, 0xa5, - 0xc9, 0xc7, 0xab, 0x07, 0x54, 0xaf, 0x18, 0x50, 0x23, 0x1f, 0x50, 0x1b, 0x66, 0xad, 0xb1, 0x34, - 0x5d, 0xfd, 0x4d, 0x6e, 0xc2, 0x74, 0x0f, 0x85, 0x93, 0xb5, 0x05, 0x8b, 0x46, 0x2a, 0xcc, 0x0f, - 0x99, 0x2b, 0x5b, 0xe9, 0x6f, 0x39, 0x30, 0x2d, 0x40, 0x18, 0x77, 0xe4, 0x77, 0x3f, 0xf8, 0x5b, - 0x55, 0x8c, 0xd6, 0xf2, 0x8a, 0x51, 0x55, 0x57, 0x5a, 0x37, 0xea, 0x4a, 0x09, 0x34, 0xe2, 0x01, - 0x8b, 0x54, 0xfd, 0x29, 0xff, 0xcd, 0x07, 0xd1, 0x0b, 0xe3, 0x94, 0xc9, 0xe3, 0x8e, 0xf8, 0x30, - 0x6a, 0x49, 0xa7, 0xcd, 0x5a, 0x52, 0xfa, 0x14, 0x20, 0x37, 0x2e, 0x1d, 0x01, 0xc9, 0x70, 0x0d, - 0x23, 0xa0, 0x6b, 0x00, 0x81, 0xcf, 0xa2, 0x2c, 0x38, 0x0c, 0x98, 0xaa, 0x49, 0x34, 0x20, 0x7c, - 0x97, 0xef, 0xb3, 0x34, 0x55, 0x05, 0x3d, 0x4d, 0x57, 0x7d, 0x92, 0x4d, 0x68, 0xea, 0x37, 0x6b, - 0xea, 0x56, 0x42, 0x03, 0x68, 0x17, 0x9a, 0x7b, 0xbb, 0x07, 0xfb, 0x18, 0x95, 0x71, 0xc6, 0x8f, - 0x1f, 0x3f, 0xb8, 0xaf, 0x18, 0xf3, 0xdf, 0x3a, 0x76, 0xac, 0x19, 0xb1, 0x23, 0xe1, 0x73, 0x99, - 0x1d, 0xab, 0xdc, 0x15, 0xff, 0xcd, 0xd7, 0x65, 0xc4, 0x9e, 0x66, 0x9d, 0x64, 0xa8, 0x0e, 0xad, - 0x33, 0xfc, 0xdb, 0x1d, 0x46, 0xf4, 0x3e, 0x6c, 0x68, 0x1e, 0xef, 0x88, 0x4c, 0x92, 0x5a, 0x21, - 0xb7, 0x61, 0x5a, 0x44, 0x84, 0xb2, 0x32, 0xf3, 0x92, 0xde, 0xef, 0x54, 0x07, 0x57, 0x22, 0xd0, - 0x1d, 0x58, 0xd5, 0xc0, 0xfd, 0x2c, 0x1e, 0x7c, 0x0a, 0x12, 0x97, 0x0d, 0x41, 0x38, 0x89, 0x9d, - 0x50, 0x05, 0xb4, 0xf8, 0xe6, 0x21, 0x6f, 0xe2, 0x91, 0xaf, 0x6a, 0x31, 0x3b, 0x3d, 0x0c, 0xd2, - 0xcc, 0xe8, 0xf4, 0x67, 0x8e, 0xd1, 0xeb, 0xf1, 0x20, 0x8c, 0x3d, 0x5f, 0x49, 0xb5, 0x05, 0x73, - 0x82, 0xa9, 0x19, 0x33, 0x82, 0x00, 0x61, 0x48, 0x98, 0x23, 0x60, 0x99, 0x5d, 0xcd, 0x44, 0xb8, - 0xef, 0x65, 0x9e, 0x2e, 0xc0, 0xab, 0xe7, 0x05, 0x78, 0xdc, 0xe4, 0xbd, 0xa4, 0x77, 0x1c, 0x9c, - 0x30, 0x5f, 0x6e, 0x75, 0xfa, 0x9b, 0xcf, 0x73, 0x7c, 0xc2, 0x92, 0xd3, 0x24, 0xc8, 0x84, 0xd5, - 0xcd, 0xba, 0x39, 0x80, 0xee, 0x41, 0x3b, 0xd7, 0x07, 0xf3, 0x7c, 0xf5, 0xeb, 0xc2, 0x3a, 0xbc, - 0x07, 0x6b, 0x1a, 0xf8, 0xed, 0x21, 0xd3, 0xf5, 0x70, 0x17, 0xa1, 0xf1, 0x0d, 0x68, 0x69, 0xe0, - 0xce, 0x30, 0x8b, 0x1f, 0x1a, 0x8a, 0x5b, 0xb7, 0xc8, 0x34, 0x55, 0x9f, 0xc2, 0x81, 0x7e, 0x56, - 0x9f, 0x4f, 0x3e, 0xb6, 0xe6, 0x54, 0x4c, 0x5c, 0xfe, 0xe8, 0x52, 0xbf, 0xaf, 0x32, 0xaf, 0xa3, - 0x5f, 0x82, 0x19, 0x41, 0x54, 0x25, 0xca, 0x2b, 0x44, 0x55, 0x18, 0x34, 0x36, 0xa6, 0x58, 0x8e, - 0xf7, 0x1c, 0xf2, 0xb9, 0x22, 0x6a, 0xe7, 0x28, 0xc2, 0x9a, 0xe3, 0xa6, 0x2c, 0xb2, 0xfc, 0x0a, - 0x2c, 0xc9, 0x27, 0x45, 0xe7, 0x72, 0x52, 0xdd, 0x6b, 0x46, 0xf7, 0x1e, 0x86, 0xbf, 0x6a, 0xc3, - 0xc6, 0x58, 0xef, 0x53, 0x47, 0xad, 0x46, 0x60, 0x55, 0xb7, 0x02, 0xab, 0x47, 0xd0, 0x36, 0x99, - 0x84, 0xe1, 0xc4, 0xd1, 0x71, 0x4e, 0xb1, 0x66, 0x51, 0xdc, 0x81, 0xe7, 0x44, 0x8d, 0xb3, 0x22, - 0xaa, 0x43, 0xcd, 0x49, 0x49, 0xd3, 0xcf, 0x5b, 0x11, 0xb6, 0x88, 0x72, 0x27, 0xe9, 0xf7, 0x3a, - 0x6e, 0xe1, 0xc5, 0x7e, 0xb9, 0xea, 0x75, 0x40, 0x2e, 0xf2, 0xc3, 0xf8, 0x45, 0xdf, 0x84, 0x8d, - 0x0f, 0x59, 0x37, 0x8d, 0x7b, 0x4f, 0x58, 0x66, 0xbf, 0xff, 0x1d, 0xcb, 0xeb, 0x27, 0x35, 0x68, - 0x95, 0xfb, 0x4d, 0xb0, 0x7d, 0xe2, 0x33, 0x44, 0xa9, 0x11, 0xf5, 0x90, 0x53, 0x03, 0xcc, 0x6a, - 0xa4, 0xba, 0x5d, 0x8d, 0xf4, 0x05, 0xd8, 0xb0, 0x9f, 0xbe, 0xe4, 0x54, 0x84, 0x03, 0x59, 0xb7, - 0x9a, 0xf3, 0xd7, 0x4f, 0x9f, 0x83, 0x05, 0xab, 0x45, 0xba, 0x14, 0x1b, 0xc8, 0xbd, 0x58, 0x32, - 0x8c, 0xa2, 0x20, 0x3a, 0xea, 0x0c, 0x13, 0xb5, 0x0d, 0x83, 0x04, 0x3d, 0x4e, 0x42, 0x1e, 0x75, - 0xe0, 0xf3, 0x20, 0x7d, 0x19, 0x27, 0xf2, 0x79, 0xf3, 0x08, 0x54, 0x4f, 0x00, 0x1f, 0x41, 0x5b, - 0x2b, 0x85, 0xdb, 0x95, 0x90, 0xfd, 0x57, 0x31, 0xa7, 0xaf, 0xc2, 0x75, 0x53, 0xcd, 0xfb, 0xc3, - 0xae, 0x4e, 0x3c, 0x4c, 0x64, 0x13, 0xdf, 0x87, 0xb5, 0x5c, 0x22, 0xa3, 0x33, 0xd7, 0x34, 0x47, - 0x89, 0x58, 0xa8, 0x4e, 0xd3, 0xf2, 0x73, 0x6c, 0x36, 0x44, 0xaf, 0xae, 0x7a, 0x61, 0x75, 0x19, - 0x97, 0x3c, 0x4d, 0x57, 0x7e, 0xf1, 0xa0, 0xe4, 0xc6, 0x18, 0xe9, 0x27, 0xb0, 0x96, 0x5d, 0x58, - 0x48, 0xcd, 0x4e, 0xd2, 0xcf, 0xe9, 0x2c, 0x48, 0xe5, 0xd8, 0x5c, 0xbb, 0x0f, 0x7d, 0x68, 0x98, - 0xea, 0x3e, 0xcb, 0xf0, 0x51, 0xd7, 0x84, 0xae, 0x44, 0xbc, 0x08, 0x93, 0xae, 0x04, 0x3f, 0xe8, - 0xbb, 0xb0, 0x6e, 0x52, 0x7b, 0xec, 0x3e, 0x9c, 0x84, 0xd6, 0x32, 0xd4, 0xb9, 0x5d, 0x09, 0x4a, - 0xfc, 0xe7, 0xdd, 0x1f, 0x7f, 0x0d, 0x16, 0xf7, 0x62, 0x91, 0xea, 0xc0, 0x22, 0x9e, 0x84, 0xbc, - 0x0f, 0x33, 0x72, 0x29, 0x91, 0xf5, 0xd2, 0xbb, 0x70, 0xe4, 0xd1, 0xde, 0x18, 0xf1, 0x5e, 0x9c, - 0xae, 0xfc, 0xe8, 0x1f, 0xfe, 0xe5, 0x27, 0xb5, 0x05, 0x32, 0x77, 0xe7, 0xe4, 0xb5, 0x3b, 0x47, - 0x2c, 0xc3, 0x14, 0xc4, 0x11, 0x2c, 0x58, 0xaf, 0x7a, 0xc9, 0xa6, 0xf5, 0x32, 0xb7, 0xf0, 0xd8, - 0xb7, 0x7d, 0x75, 0xec, 0xbb, 0x5d, 0x7a, 0x19, 0x59, 0xac, 0x90, 0x4b, 0x92, 0x45, 0xfe, 0x60, - 0x97, 0x1c, 0xc3, 0x92, 0x30, 0x76, 0x4d, 0x94, 0x6c, 0xe5, 0xc4, 0x2a, 0x1f, 0x24, 0x9b, 0x43, - 0xb1, 0x76, 0x09, 0x7a, 0x05, 0xf9, 0xac, 0x91, 0x15, 0xce, 0x47, 0xac, 0x03, 0xcd, 0x8a, 0x7c, - 0x17, 0x96, 0xe5, 0xa3, 0xc8, 0x67, 0xc1, 0x6a, 0x13, 0x59, 0xad, 0x93, 0x55, 0xce, 0xca, 0x17, - 0x74, 0x73, 0x5e, 0x31, 0xd6, 0xf0, 0x98, 0x8f, 0x73, 0xc9, 0xb5, 0x91, 0xaf, 0x76, 0x05, 0xa7, - 0xad, 0x73, 0x5e, 0xf5, 0xda, 0x83, 0x3b, 0x62, 0x1c, 0x57, 0x3f, 0xec, 0x25, 0x3f, 0x11, 0xc9, - 0x95, 0xca, 0xa7, 0xe2, 0xe4, 0x85, 0xf3, 0xdf, 0xa7, 0x0b, 0x19, 0x6e, 0x4d, 0xfa, 0x90, 0x9d, - 0x7e, 0x0e, 0x85, 0xb9, 0x46, 0x36, 0xa5, 0x30, 0xd6, 0xe3, 0x75, 0xf5, 0x3c, 0x9e, 0xf4, 0x60, - 0xde, 0x7c, 0xb0, 0x4b, 0xae, 0x54, 0xe4, 0x72, 0x34, 0xf3, 0xcd, 0xea, 0x46, 0xc9, 0xb0, 0x85, - 0x0c, 0x09, 0x59, 0x96, 0x0c, 0x75, 0x01, 0x2e, 0x89, 0x60, 0xa9, 0xf0, 0xd8, 0x95, 0xd0, 0xc2, - 0xac, 0x55, 0xbc, 0x4c, 0x1e, 0x3d, 0xb3, 0xd7, 0x90, 0x53, 0x8b, 0xae, 0x18, 0x33, 0xab, 0xb8, - 0xbd, 0xed, 0xbc, 0x48, 0x52, 0x9c, 0x5b, 0xf3, 0x2d, 0xe6, 0x44, 0xfc, 0xb6, 0xce, 0x79, 0xc8, - 0x59, 0x9a, 0x5f, 0xc5, 0x13, 0xd7, 0x63, 0x8a, 0xef, 0xdb, 0x8c, 0x17, 0xc4, 0xbb, 0xb1, 0x3f, - 0xd9, 0x38, 0xaf, 0x56, 0xbf, 0x40, 0x96, 0x8f, 0xa0, 0x69, 0x1b, 0xb9, 0xae, 0x12, 0x52, 0xe0, - 0x1a, 0x67, 0x03, 0x92, 0x5a, 0x0f, 0xb4, 0x25, 0x53, 0xdb, 0x92, 0x2b, 0x9e, 0x48, 0x57, 0x8e, - 0xd4, 0x7c, 0xf3, 0x3c, 0x72, 0xa4, 0x71, 0x36, 0x48, 0x49, 0x08, 0x8b, 0xc2, 0x21, 0x3c, 0x9b, - 0xd9, 0xbc, 0x8a, 0xbc, 0x36, 0x28, 0xc9, 0x5d, 0x82, 0x39, 0x99, 0x1f, 0x42, 0x53, 0xe7, 0x96, - 0x48, 0xcb, 0x10, 0xdc, 0x7a, 0xa1, 0xda, 0x1e, 0xf1, 0xfe, 0x50, 0x59, 0x25, 0x5d, 0x90, 0x23, - 0x11, 0xaf, 0x09, 0x39, 0xe1, 0xef, 0x00, 0xe4, 0x0f, 0x12, 0xc9, 0xe5, 0x12, 0x65, 0xad, 0xad, - 0x76, 0x55, 0x93, 0x24, 0xbf, 0x8e, 0xe4, 0x97, 0xc9, 0xa2, 0x45, 0x5e, 0xad, 0x2b, 0x9d, 0x4a, - 0xb3, 0xd6, 0x55, 0xf1, 0x09, 0x63, 0x7b, 0xf4, 0xdb, 0x35, 0x35, 0x11, 0x54, 0x2d, 0x2a, 0x5d, - 0xe3, 0xc1, 0x47, 0x20, 0xb6, 0x00, 0xe3, 0xd1, 0xdc, 0x66, 0x15, 0x97, 0xca, 0x2d, 0xa0, 0xfc, - 0x02, 0xae, 0xb4, 0x05, 0xe4, 0x0f, 0xdd, 0xc8, 0x13, 0xfc, 0xfb, 0x31, 0xc6, 0x9b, 0x2f, 0x62, - 0xd2, 0x2a, 0x3f, 0x80, 0x6b, 0x5f, 0x1b, 0xd5, 0x9c, 0x56, 0xdb, 0xb4, 0xbc, 0x62, 0xc0, 0x85, - 0x74, 0x26, 0xd2, 0x71, 0x79, 0x2f, 0x91, 0xca, 0xfb, 0x55, 0x59, 0x5e, 0x47, 0x96, 0x6d, 0xd2, - 0x2a, 0xb3, 0x4c, 0x91, 0xc1, 0xab, 0x8e, 0xb4, 0x35, 0xf1, 0xc8, 0xcc, 0xb2, 0x35, 0xeb, 0x2d, - 0x5a, 0xfb, 0x72, 0x45, 0x8b, 0xe4, 0xb2, 0x86, 0x5c, 0x96, 0xc8, 0x82, 0xf6, 0xba, 0x48, 0x4b, - 0x98, 0x83, 0x7e, 0x42, 0x60, 0x99, 0x43, 0xf1, 0x89, 0x98, 0xe5, 0x66, 0x4b, 0x0f, 0xc5, 0x4a, - 0x6e, 0x56, 0x3f, 0x05, 0x23, 0x3f, 0xb0, 0x5f, 0x9c, 0xa9, 0x17, 0x30, 0x74, 0xec, 0x93, 0x15, - 0xc1, 0xf2, 0xb9, 0x09, 0x9e, 0xb5, 0xd0, 0x2d, 0xe4, 0x7c, 0x99, 0x6c, 0x14, 0x39, 0xcb, 0x27, - 0x32, 0xe4, 0x04, 0x56, 0x2a, 0x1e, 0x84, 0xe4, 0x02, 0x8c, 0x7e, 0x2d, 0x32, 0xda, 0x3b, 0x50, - 0x64, 0xba, 0x49, 0x91, 0xa9, 0xe7, 0xfb, 0x9a, 0xa9, 0x8c, 0xd5, 0xf9, 0x3a, 0xf8, 0x01, 0xac, - 0x57, 0xbf, 0xd1, 0x20, 0xcf, 0xeb, 0x3f, 0x8d, 0x31, 0xee, 0x0d, 0xc7, 0x68, 0xee, 0xcf, 0x23, - 0xf7, 0x2d, 0xda, 0xe6, 0xdc, 0x13, 0xa4, 0x51, 0x25, 0xc0, 0x29, 0x16, 0x5a, 0xd9, 0xcf, 0x13, - 0xc8, 0x75, 0x43, 0xa7, 0x95, 0xaf, 0x38, 0xda, 0x37, 0xc6, 0x60, 0xd8, 0xce, 0x91, 0xac, 0x49, - 0x9d, 0x63, 0x4d, 0xbf, 0x7e, 0xe7, 0x20, 0x3d, 0x40, 0x5e, 0xfe, 0x6f, 0x79, 0x80, 0xd2, 0x8b, - 0x06, 0xcb, 0x03, 0x94, 0x1f, 0x19, 0x94, 0x3c, 0x00, 0x32, 0xc3, 0x07, 0x07, 0xe4, 0x23, 0x5c, - 0x19, 0xb2, 0xca, 0xaf, 0x55, 0x74, 0x24, 0x69, 0xd5, 0xca, 0xb0, 0xeb, 0xf8, 0x4a, 0x8e, 0x58, - 0x14, 0x0f, 0x72, 0xed, 0xb9, 0x30, 0xab, 0xd0, 0xc9, 0x46, 0x91, 0x80, 0xa2, 0x5c, 0x59, 0x91, - 0x4d, 0x37, 0x90, 0xe8, 0x25, 0x3a, 0x6f, 0x12, 0xe5, 0x34, 0xbb, 0x30, 0x67, 0x54, 0x1f, 0x13, - 0xed, 0xc2, 0xcb, 0xc5, 0xd6, 0xed, 0x2b, 0x95, 0x6d, 0xb6, 0xa3, 0xa2, 0x4b, 0x9c, 0x41, 0x8a, - 0x08, 0x9a, 0xc7, 0x77, 0x61, 0xc1, 0x2a, 0x00, 0xce, 0x95, 0x5f, 0x55, 0xa2, 0x9c, 0x2b, 0xbf, - 0xb2, 0x6a, 0x58, 0x85, 0xab, 0x14, 0x95, 0x9f, 0x4a, 0x14, 0xcd, 0xeb, 0x63, 0x68, 0xea, 0xba, - 0xdb, 0x5c, 0xff, 0xc5, 0x52, 0xdc, 0xf3, 0x78, 0x58, 0x73, 0x70, 0xca, 0x3b, 0x77, 0xe3, 0x7e, - 0x57, 0xd0, 0x9f, 0x33, 0xaa, 0x68, 0x73, 0x7d, 0x95, 0x4b, 0x6b, 0x47, 0x2f, 0x16, 0x4b, 0x57, - 0x3d, 0xec, 0xa8, 0xe5, 0x4f, 0x60, 0xa9, 0x50, 0xe0, 0x99, 0x07, 0x29, 0xd5, 0xe5, 0xac, 0x79, - 0x90, 0x32, 0xa2, 0x32, 0xd4, 0x0e, 0x03, 0x05, 0x3f, 0x2f, 0x0c, 0x73, 0xbb, 0x12, 0xde, 0x5c, - 0x54, 0x76, 0x58, 0x36, 0x6b, 0xd5, 0x79, 0x5a, 0x36, 0x6b, 0xd7, 0x4a, 0x96, 0xbc, 0xb9, 0xb8, - 0x50, 0x21, 0x1f, 0xc0, 0xac, 0xaa, 0xbb, 0xcb, 0x0d, 0xb6, 0x50, 0x71, 0xd8, 0x6e, 0x95, 0x1b, - 0x24, 0x55, 0xcb, 0x68, 0x3d, 0xdf, 0x47, 0xaa, 0x72, 0x12, 0x8c, 0x5a, 0xbd, 0x7c, 0x12, 0xca, - 0x05, 0x7c, 0x13, 0x4e, 0x82, 0xf0, 0x58, 0x9a, 0xfe, 0x5f, 0x38, 0x78, 0xd1, 0x37, 0xbe, 0xae, - 0x8e, 0xbc, 0x7a, 0x81, 0x12, 0x3c, 0x21, 0xcc, 0x6b, 0x17, 0x2e, 0xda, 0xa3, 0xb7, 0x50, 0x4c, - 0x4a, 0xaf, 0xaa, 0x7d, 0x12, 0xbb, 0xf9, 0x02, 0x5d, 0x57, 0xf0, 0x71, 0xa1, 0xff, 0xdc, 0x11, - 0x7f, 0x73, 0x6c, 0x0c, 0x5d, 0xb2, 0x3d, 0xa1, 0x00, 0x4a, 0xe0, 0x3b, 0x13, 0xe3, 0x4b, 0x71, - 0x6f, 0xa2, 0xb8, 0xd7, 0xe9, 0x95, 0x31, 0xe2, 0x72, 0x61, 0x43, 0xb8, 0x64, 0xd6, 0xdf, 0xbd, - 0x3b, 0x8c, 0x7c, 0xe3, 0x4c, 0x55, 0x51, 0x9a, 0x97, 0x9b, 0x49, 0xb1, 0x5a, 0x4c, 0x05, 0x2c, - 0x14, 0x5d, 0xff, 0xa9, 0x6c, 0x3d, 0x0c, 0xbc, 0xec, 0x90, 0x53, 0xe5, 0xdc, 0x7e, 0xec, 0xe4, - 0xa5, 0x5f, 0xf6, 0x30, 0x04, 0xe3, 0xab, 0x45, 0xda, 0x56, 0x85, 0xdd, 0x18, 0xd6, 0xaf, 0x23, - 0xeb, 0x57, 0xe8, 0x2d, 0x93, 0xb5, 0xfc, 0x4f, 0x0c, 0x1d, 0x65, 0xb0, 0xa5, 0xf9, 0x91, 0x51, - 0x7c, 0x68, 0x14, 0xa2, 0xe5, 0xdb, 0xff, 0xe8, 0x9a, 0xb6, 0x3c, 0xfe, 0x18, 0x53, 0xc9, 0x66, - 0x87, 0x02, 0xa7, 0x1a, 0x11, 0xcd, 0xbb, 0x7b, 0x16, 0xf8, 0x5c, 0x88, 0x9f, 0x39, 0xa5, 0xda, - 0x39, 0xa3, 0xaa, 0x8b, 0xdc, 0x1e, 0xc1, 0xa7, 0x5c, 0xdb, 0xd6, 0x7e, 0x71, 0x12, 0xd4, 0x0b, - 0x48, 0xf6, 0x87, 0x56, 0x8d, 0x92, 0x59, 0xea, 0x96, 0x47, 0x29, 0x63, 0x4b, 0xe1, 0x2e, 0x24, - 0x91, 0x3c, 0xfd, 0xd3, 0xcb, 0x95, 0x12, 0xf9, 0x5e, 0x26, 0x0f, 0xca, 0xcb, 0xc5, 0xb2, 0x17, - 0x33, 0xe1, 0x52, 0x59, 0xa0, 0xd2, 0xbe, 0x3e, 0x1a, 0xa1, 0x2a, 0xf3, 0x72, 0xc4, 0x32, 0x51, - 0xc1, 0xe2, 0x4b, 0x06, 0x27, 0xb0, 0xbc, 0x3f, 0x92, 0xe9, 0xfe, 0xa7, 0x66, 0x2a, 0xa3, 0x53, - 0x8a, 0x4c, 0xd3, 0x02, 0x53, 0x3e, 0xd8, 0x13, 0x51, 0xe3, 0x6f, 0x16, 0xa8, 0x90, 0xad, 0xd1, - 0xa5, 0x2b, 0x65, 0xbe, 0x95, 0xb5, 0x2d, 0x36, 0x5f, 0xe3, 0xa8, 0x8c, 0x55, 0x1f, 0x22, 0x4c, - 0x58, 0x2a, 0x54, 0x9e, 0xe4, 0x5b, 0x5f, 0x75, 0x49, 0xca, 0x84, 0x99, 0x8f, 0xd4, 0x66, 0xc6, - 0x79, 0x65, 0x98, 0x84, 0x28, 0x54, 0x70, 0x90, 0x1b, 0x55, 0x07, 0x3f, 0xab, 0x40, 0x62, 0xdc, - 0x11, 0x54, 0xf2, 0x24, 0xeb, 0xa5, 0x73, 0xa1, 0x3a, 0x36, 0xfd, 0x9e, 0xb8, 0x71, 0x1f, 0x51, - 0x40, 0x42, 0x6e, 0x57, 0x65, 0x1b, 0x2e, 0x2c, 0x86, 0x74, 0xc1, 0xe4, 0x5a, 0x31, 0x25, 0x51, - 0x12, 0xe7, 0x18, 0xd3, 0x3f, 0x66, 0x19, 0x88, 0x95, 0x10, 0xa9, 0xa8, 0x0f, 0x19, 0x99, 0x3d, - 0x28, 0xe6, 0x41, 0xe4, 0xf1, 0x5e, 0x71, 0xfa, 0xa1, 0xfd, 0xa7, 0xe6, 0x2c, 0x96, 0x37, 0x2b, - 0x46, 0x7d, 0x11, 0xd6, 0xcf, 0x21, 0xeb, 0xab, 0xe4, 0x4a, 0x61, 0xbc, 0x05, 0x11, 0xc4, 0x09, - 0xc0, 0xb8, 0x98, 0x37, 0x4f, 0x00, 0xa5, 0x9a, 0x16, 0xeb, 0x04, 0x50, 0x2e, 0x2b, 0x29, 0x9d, - 0x00, 0x3c, 0x8e, 0x82, 0x4e, 0x83, 0x3c, 0x81, 0xe5, 0xe2, 0x05, 0xb9, 0xb1, 0x7c, 0xaa, 0xaf, - 0xce, 0xcf, 0x4d, 0xfa, 0xc8, 0x73, 0x4d, 0x2f, 0x13, 0x29, 0xfd, 0x3b, 0xf2, 0x0d, 0x07, 0x79, - 0x02, 0x4b, 0x85, 0x3b, 0x6b, 0x63, 0x0a, 0x2b, 0x2f, 0xb3, 0x47, 0xb3, 0xb2, 0x17, 0xa8, 0x66, - 0x35, 0xc4, 0xde, 0x7c, 0xd1, 0x3c, 0x85, 0x95, 0x8a, 0x6b, 0x67, 0xe3, 0xdc, 0x3c, 0xf2, 0x4e, - 0xba, 0x5d, 0x16, 0xca, 0xba, 0x7e, 0xb5, 0x73, 0x5b, 0x39, 0xef, 0x84, 0x09, 0xce, 0x03, 0x63, - 0x98, 0xf2, 0x6f, 0xc9, 0x96, 0x29, 0x5a, 0x37, 0xfd, 0xed, 0xad, 0x91, 0xed, 0x95, 0xce, 0x57, - 0xb3, 0x94, 0xb7, 0xb1, 0x21, 0x2c, 0xda, 0xa2, 0x1a, 0x69, 0x95, 0xaa, 0x1b, 0xf3, 0x73, 0x47, - 0x68, 0xaf, 0x10, 0xcd, 0xee, 0x13, 0xa4, 0xcd, 0x60, 0xc1, 0xaa, 0x65, 0x30, 0x8c, 0xb3, 0xa2, - 0x4a, 0x62, 0xc2, 0x14, 0xa1, 0x39, 0xa6, 0x78, 0xc0, 0xd5, 0x68, 0x9a, 0xa6, 0x2c, 0x99, 0x20, - 0x5b, 0x95, 0x9c, 0xf2, 0xba, 0x88, 0x4f, 0xcd, 0x2c, 0x35, 0x98, 0xc9, 0x52, 0x8b, 0x0a, 0x66, - 0x76, 0x11, 0xc6, 0xf9, 0xb3, 0x76, 0x0e, 0xd3, 0x53, 0xa3, 0x80, 0x40, 0x15, 0x23, 0x1c, 0xc4, - 0x47, 0x47, 0x21, 0x33, 0xd2, 0x0c, 0x23, 0xaa, 0x15, 0x46, 0x8f, 0xf4, 0x06, 0x32, 0xbd, 0x42, - 0xd7, 0x6d, 0xa6, 0xde, 0x30, 0x8b, 0xd5, 0xda, 0xf8, 0x3e, 0x6e, 0x28, 0x85, 0x5a, 0x2a, 0x6b, - 0x43, 0xa9, 0x2e, 0x2b, 0x6b, 0xd3, 0x71, 0x28, 0x23, 0x76, 0x96, 0x63, 0x89, 0xd7, 0x93, 0x6c, - 0xbe, 0x8b, 0x91, 0x82, 0x75, 0xe9, 0x6d, 0x45, 0x0a, 0x55, 0x05, 0x04, 0x13, 0xde, 0x07, 0x19, - 0x7b, 0xa7, 0xb8, 0xe7, 0x4c, 0x61, 0x65, 0x9f, 0xf1, 0x29, 0xb3, 0x03, 0x04, 0x5a, 0xc5, 0xce, - 0x2e, 0x25, 0x38, 0xd7, 0xf3, 0x88, 0x84, 0x59, 0xca, 0x32, 0x2f, 0x0c, 0xad, 0xe8, 0x80, 0xfc, - 0xbe, 0x03, 0x9b, 0xe3, 0x2a, 0x0a, 0xc8, 0x4b, 0x8a, 0xf4, 0x04, 0x75, 0x07, 0xa3, 0xe5, 0x90, - 0x87, 0x2d, 0x72, 0x9d, 0xcb, 0x21, 0x6a, 0xf1, 0xf5, 0xe5, 0x8c, 0xa2, 0x24, 0x04, 0x12, 0x89, - 0x2c, 0xbb, 0xcc, 0x80, 0x54, 0xc5, 0x40, 0x56, 0xe5, 0x82, 0x95, 0xc8, 0xaa, 0xae, 0x51, 0x28, - 0x25, 0xb2, 0x2c, 0xed, 0xa7, 0x7c, 0x55, 0x15, 0x4b, 0x0e, 0xf2, 0xa9, 0x1e, 0x51, 0xc4, 0x90, - 0x07, 0x67, 0xa3, 0xaa, 0x15, 0xec, 0x39, 0x3f, 0x55, 0x58, 0xea, 0x0a, 0x35, 0x85, 0x95, 0x8a, - 0x2b, 0x7d, 0xe3, 0xc0, 0x32, 0xf2, 0xbe, 0x7f, 0xc2, 0x39, 0xd7, 0x1c, 0xb9, 0xb9, 0x49, 0xea, - 0x3f, 0x73, 0xe0, 0xf2, 0xc8, 0x8b, 0x73, 0x72, 0xab, 0x6a, 0x48, 0x55, 0x95, 0x01, 0xed, 0xdb, - 0x13, 0x60, 0xda, 0x59, 0x4c, 0x72, 0xb5, 0xa8, 0x05, 0xeb, 0x2e, 0x9d, 0xf4, 0xe1, 0x52, 0xe9, - 0x2e, 0x9d, 0x5c, 0xaf, 0x52, 0x86, 0x79, 0xcd, 0x3e, 0xe1, 0x1e, 0x6f, 0xaa, 0x02, 0x2f, 0xdb, - 0xc9, 0x11, 0x2c, 0x15, 0x2e, 0xdb, 0xf3, 0xcd, 0xaf, 0xfa, 0x16, 0x7e, 0xc2, 0x6b, 0x65, 0x93, - 0xd5, 0x30, 0x09, 0xbb, 0xd3, 0xf8, 0x24, 0xe5, 0xf5, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xfa, - 0x35, 0xc5, 0x70, 0x58, 0x5f, 0x00, 0x00, +func (x *CancelAllOrdersResponse_Orders) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CancelAllOrdersResponse_Orders) ProtoMessage() {} + +func (x *CancelAllOrdersResponse_Orders) ProtoReflect() protoreflect.Message { + mi := &file_rpc_proto_msgTypes[144] + 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 CancelAllOrdersResponse_Orders.ProtoReflect.Descriptor instead. +func (*CancelAllOrdersResponse_Orders) Descriptor() ([]byte, []int) { + return file_rpc_proto_rawDescGZIP(), []int{68, 0} +} + +func (x *CancelAllOrdersResponse_Orders) GetExchange() string { + if x != nil { + return x.Exchange + } + return "" +} + +func (x *CancelAllOrdersResponse_Orders) GetOrderStatus() map[string]string { + if x != nil { + return x.OrderStatus + } + return nil +} + +var File_rpc_proto protoreflect.FileDescriptor + +var file_rpc_proto_rawDesc = []byte{ + 0x0a, 0x09, 0x72, 0x70, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0x10, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x22, 0xb4, 0x04, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x75, 0x70, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, 0x70, 0x74, 0x69, 0x6d, 0x65, + 0x12, 0x2f, 0x0a, 0x13, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x61, + 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x65, 0x6e, + 0x61, 0x62, 0x6c, 0x65, 0x64, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x34, + 0x0a, 0x16, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x5f, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x15, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, + 0x66, 0x69, 0x61, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x13, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x69, 0x61, 0x74, + 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x57, 0x0a, 0x10, 0x73, 0x75, 0x62, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x06, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x75, 0x62, 0x73, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0f, 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x4e, 0x0a, 0x0d, 0x72, 0x70, 0x63, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x2e, 0x52, 0x70, 0x63, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x0c, 0x72, 0x70, 0x63, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x73, 0x1a, 0x42, 0x0a, 0x14, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 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, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x54, 0x0a, 0x11, 0x52, 0x70, 0x63, 0x45, 0x6e, 0x64, 0x70, + 0x6f, 0x69, 0x6e, 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, 0x29, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x50, 0x43, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x21, 0x0a, 0x1f, 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, 0x22, 0x4e, + 0x0a, 0x14, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x22, 0x86, + 0x02, 0x0a, 0x20, 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, 0x12, 0x7a, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x43, 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, 0x2e, 0x43, 0x6f, + 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6c, 0x61, 0x79, + 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x15, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x1a, + 0x66, 0x0a, 0x1a, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 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, + 0x32, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x37, 0x0a, 0x17, 0x47, 0x65, 0x6e, 0x65, 0x72, + 0x69, 0x63, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, + 0x22, 0x16, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xbe, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, + 0x53, 0x75, 0x73, 0x62, 0x73, 0x79, 0x74, 0x65, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x60, 0x0a, 0x11, 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, + 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 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, 0x2e, 0x53, 0x75, 0x62, + 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x10, 0x73, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x1a, 0x43, 0x0a, 0x15, 0x53, 0x75, 0x62, 0x73, 0x79, 0x73, 0x74, 0x65, + 0x6d, 0x73, 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, 0x08, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x18, 0x0a, 0x16, 0x47, 0x65, 0x74, + 0x52, 0x50, 0x43, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x22, 0x4e, 0x0a, 0x0b, 0x52, 0x50, 0x43, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, + 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x12, 0x25, 0x0a, 0x0e, + 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x22, 0xba, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x52, 0x50, 0x43, 0x45, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x4c, 0x0a, 0x09, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2e, 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, 0x2e, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x09, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x1a, 0x51, 0x0a, + 0x0e, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 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, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x50, 0x43, 0x45, 0x6e, 0x64, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x38, 0x0a, 0x1a, 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, 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, 0x2f, 0x0a, 0x13, 0x47, 0x65, + 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x22, 0x34, 0x0a, 0x14, 0x47, + 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x73, 0x22, 0x32, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x4f, 0x54, 0x50, 0x52, 0x65, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x74, + 0x70, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x74, + 0x70, 0x43, 0x6f, 0x64, 0x65, 0x22, 0x18, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x54, 0x50, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, + 0xa2, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, + 0x54, 0x50, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x09, 0x6f, + 0x74, 0x70, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, + 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, 0x2e, + 0x4f, 0x74, 0x70, 0x43, 0x6f, 0x64, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6f, + 0x74, 0x70, 0x43, 0x6f, 0x64, 0x65, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x4f, 0x74, 0x70, 0x43, 0x6f, + 0x64, 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, 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, 0x34, 0x0a, 0x16, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 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, 0x22, 0x5e, 0x0a, 0x0e, 0x50, 0x61, + 0x69, 0x72, 0x73, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, + 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x70, 0x61, 0x69, 0x72, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, + 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x5f, 0x70, 0x61, 0x69, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x6e, + 0x61, 0x62, 0x6c, 0x65, 0x64, 0x50, 0x61, 0x69, 0x72, 0x73, 0x22, 0x82, 0x04, 0x0a, 0x17, 0x47, + 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, + 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x12, 0x23, + 0x0a, 0x0d, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x61, 0x6e, 0x64, 0x62, 0x6f, 0x78, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x61, 0x6e, 0x64, + 0x62, 0x6f, 0x78, 0x12, 0x21, 0x0a, 0x0c, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x6f, 0x75, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x68, 0x74, 0x74, 0x70, 0x54, + 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x75, + 0x73, 0x65, 0x72, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, + 0x68, 0x74, 0x74, 0x70, 0x55, 0x73, 0x65, 0x72, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, + 0x0a, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x68, 0x74, 0x74, 0x70, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x12, 0x27, 0x0a, 0x0f, + 0x62, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x62, 0x61, 0x73, 0x65, 0x43, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x69, 0x65, 0x73, 0x12, 0x5f, 0x0a, 0x10, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x34, 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, + 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, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, + 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x70, 0x69, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x10, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, + 0x41, 0x70, 0x69, 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, + 0x77, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, 0x6b, 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, 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, 0x56, 0x0a, 0x0c, 0x43, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x6c, 0x69, + 0x6d, 0x69, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x6c, + 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, + 0x6f, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x71, 0x75, 0x6f, 0x74, 0x65, + 0x22, 0x95, 0x02, 0x0a, 0x0e, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x01, 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, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, + 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x70, 0x61, 0x69, + 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x50, 0x61, 0x69, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x61, 0x73, 0x74, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x04, 0x6c, 0x61, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, + 0x68, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x12, 0x10, 0x0a, + 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, + 0x10, 0x0a, 0x03, 0x62, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x62, 0x69, + 0x64, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x73, 0x6b, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, + 0x61, 0x73, 0x6b, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x70, + 0x72, 0x69, 0x63, 0x65, 0x5f, 0x61, 0x74, 0x68, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, + 0x70, 0x72, 0x69, 0x63, 0x65, 0x41, 0x74, 0x68, 0x22, 0x13, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, + 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x57, 0x0a, + 0x07, 0x54, 0x69, 0x63, 0x6b, 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, 0x30, 0x0a, 0x07, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x54, + 0x69, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x07, 0x74, + 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x22, 0x3f, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x54, 0x69, 0x63, + 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x07, + 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x07, + 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x22, 0x7a, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x4f, 0x72, + 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 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, 0x4d, 0x0a, 0x0d, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, + 0x49, 0x74, 0x65, 0x6d, 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, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, + 0x69, 0x64, 0x22, 0xfa, 0x01, 0x0a, 0x11, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, + 0x18, 0x01, 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, 0x23, 0x0a, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x70, + 0x61, 0x69, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x63, 0x79, 0x50, 0x61, 0x69, 0x72, 0x12, 0x29, 0x0a, 0x04, 0x62, 0x69, 0x64, 0x73, 0x18, + 0x03, 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, 0x04, 0x62, 0x69, + 0x64, 0x73, 0x12, 0x29, 0x0a, 0x04, 0x61, 0x73, 0x6b, 0x73, 0x18, 0x04, 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, 0x04, 0x61, 0x73, 0x6b, 0x73, 0x12, 0x21, 0x0a, + 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, + 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, + 0x16, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x63, 0x0a, 0x0a, 0x4f, 0x72, 0x64, 0x65, 0x72, + 0x62, 0x6f, 0x6f, 0x6b, 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, 0x39, 0x0a, 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 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, + 0x52, 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x22, 0x4b, 0x0a, 0x15, + 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x0a, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, + 0x6f, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x52, 0x0a, 0x6f, + 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, 0x6b, 0x73, 0x22, 0x33, 0x0a, 0x15, 0x47, 0x65, 0x74, + 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 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, 0x56, + 0x0a, 0x07, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3b, 0x0a, 0x0a, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x43, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x22, 0x66, 0x0a, 0x13, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x49, 0x6e, 0x66, 0x6f, 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, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, + 0x61, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, + 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, + 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x04, 0x68, 0x6f, 0x6c, 0x64, 0x22, 0x61, + 0x0a, 0x16, 0x47, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 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, 0x2b, 0x0a, 0x08, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, + 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x08, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x73, 0x22, 0x12, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x27, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x85, + 0x01, 0x0a, 0x10, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 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, 0x1b, 0x0a, + 0x09, 0x63, 0x6f, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 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, 0x18, 0x0a, 0x07, + 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x62, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x15, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, + 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x4e, 0x0a, + 0x14, 0x47, 0x65, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x09, 0x70, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, + 0x69, 0x6f, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, + 0x63, 0x2e, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x52, 0x09, 0x70, 0x6f, 0x72, 0x74, 0x66, 0x6f, 0x6c, 0x69, 0x6f, 0x22, 0x1c, 0x0a, + 0x1a, 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, 0x22, 0x6e, 0x0a, 0x04, 0x43, + 0x6f, 0x69, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x63, 0x6f, 0x69, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x70, + 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x22, 0x68, 0x0a, 0x12, 0x4f, + 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x69, 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, + 0x79, 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, 0x18, 0x0a, 0x07, 0x62, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x62, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, + 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, + 0x6e, 0x74, 0x61, 0x67, 0x65, 0x22, 0x4d, 0x0a, 0x11, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x43, + 0x6f, 0x69, 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, + 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, + 0x74, 0x61, 0x67, 0x65, 0x22, 0x48, 0x0a, 0x0c, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x43, + 0x6f, 0x69, 0x6e, 0x73, 0x12, 0x38, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x69, 0x6e, 0x53, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x98, + 0x01, 0x0a, 0x0b, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x12, 0x34, + 0x0a, 0x05, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x69, + 0x6e, 0x73, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x63, + 0x6f, 0x69, 0x6e, 0x73, 0x1a, 0x53, 0x0a, 0x0a, 0x43, 0x6f, 0x69, 0x6e, 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, 0x2f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x6e, 0x6c, + 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x69, 0x6e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xcb, 0x04, 0x0a, 0x1b, 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, 0x12, 0x2d, 0x0a, 0x0b, 0x63, 0x6f, 0x69, + 0x6e, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, + 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x52, 0x0a, 0x63, 0x6f, + 0x69, 0x6e, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x73, 0x12, 0x31, 0x0a, 0x0d, 0x63, 0x6f, 0x69, 0x6e, + 0x73, 0x5f, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x0c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x52, 0x0c, 0x63, + 0x6f, 0x69, 0x6e, 0x73, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x70, 0x0a, 0x15, 0x63, + 0x6f, 0x69, 0x6e, 0x73, 0x5f, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x73, 0x75, 0x6d, + 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 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, 0x2e, + 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x4f, + 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x2f, 0x0a, + 0x0c, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x04, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x69, + 0x6e, 0x52, 0x0b, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x6d, + 0x0a, 0x14, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x73, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 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, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x75, 0x6d, + 0x6d, 0x61, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x12, 0x63, 0x6f, 0x69, 0x6e, 0x73, + 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x1a, 0x5c, 0x0a, + 0x18, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x75, 0x6d, + 0x6d, 0x61, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2a, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, + 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x69, 0x6e, 0x73, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x5a, 0x0a, 0x17, 0x43, + 0x6f, 0x69, 0x6e, 0x73, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, + 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xe3, 0x01, 0x0a, 0x1a, 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, 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, 0x1b, 0x0a, 0x09, 0x63, 0x6f, 0x69, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x54, 0x79, 0x70, 0x65, 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, + 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2f, 0x0a, 0x13, 0x73, 0x75, 0x70, + 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, + 0x6c, 0x64, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0b, 0x63, 0x6f, 0x6c, 0x64, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x22, 0x78, 0x0a, + 0x1d, 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, 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, 0x1b, 0x0a, 0x09, 0x63, 0x6f, 0x69, 0x6e, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x69, + 0x6e, 0x54, 0x79, 0x70, 0x65, 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, 0x22, 0x1a, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x46, 0x6f, + 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x22, 0xed, 0x01, 0x0a, 0x0d, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x12, 0x2c, 0x0a, + 0x12, 0x72, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, + 0x6c, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x72, 0x65, 0x73, 0x74, 0x50, + 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x61, + 0x70, 0x69, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x70, + 0x69, 0x4b, 0x65, 0x79, 0x12, 0x22, 0x0a, 0x0d, 0x61, 0x70, 0x69, 0x5f, 0x6b, 0x65, 0x79, 0x5f, + 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x61, 0x70, 0x69, + 0x4b, 0x65, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x72, 0x69, 0x6d, + 0x61, 0x72, 0x79, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x22, 0x5b, 0x0a, 0x19, 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, + 0x12, 0x3e, 0x0a, 0x0f, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x5f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x52, 0x0e, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, + 0x22, 0x16, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x52, 0x61, 0x74, 0x65, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x71, 0x0a, 0x14, 0x46, 0x6f, 0x72, 0x65, + 0x78, 0x52, 0x61, 0x74, 0x65, 0x73, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x02, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x04, 0x72, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x76, 0x65, + 0x72, 0x73, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, + 0x69, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x61, 0x74, 0x65, 0x22, 0x56, 0x0a, 0x15, 0x47, + 0x65, 0x74, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x5f, 0x72, 0x61, + 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x63, 0x74, 0x72, + 0x70, 0x63, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x78, 0x52, 0x61, 0x74, 0x65, 0x73, 0x43, 0x6f, 0x6e, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x66, 0x6f, 0x72, 0x65, 0x78, 0x52, 0x61, + 0x74, 0x65, 0x73, 0x22, 0xaf, 0x03, 0x0a, 0x0c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 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, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x23, 0x0a, 0x0d, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x43, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x5f, 0x63, + 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x71, + 0x75, 0x6f, 0x74, 0x65, 0x43, 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, 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, 0x1d, 0x0a, 0x0a, 0x6f, 0x72, + 0x64, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x6f, 0x72, 0x64, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, + 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x76, 0x6f, 0x6c, + 0x75, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x6f, 0x70, 0x65, 0x6e, 0x56, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x0d, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x2c, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x64, 0x65, + 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x63, 0x74, 0x72, 0x70, 0x63, + 0x2e, 0x54, 0x72, 0x61, 0x64, 0x65, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x06, 0x74, + 0x72, 0x61, 0x64, 0x65, 0x73, 0x22, 0xdd, 0x01, 0x0a, 0x0c, 0x54, 0x72, 0x61, 0x64, 0x65, 0x48, + 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70, + 0x72, 0x69, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, + 0x65, 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, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x05, 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, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, + 0x54, 0x79, 0x70, 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, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x03, 0x66, 0x65, 0x65, 0x22, 0x77, 0x0a, 0x10, 0x47, 0x65, 0x74, 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, 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, 0x22, 0x41, + 0x0a, 0x11, 0x47, 0x65, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 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, 0x22, 0x48, 0x0a, 0x0f, 0x47, 0x65, 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, 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, 0x22, 0xd8, 0x01, 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, 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, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x64, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x69, 0x64, 0x65, 0x12, 0x1d, 0x0a, 0x0a, + 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 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, 0x12, 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, 0x22, 0x53, 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, 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, 0x8f, 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, 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, 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, 0x9c, 0x02, 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, 0x3e, 0x0a, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x26, 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, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x52, 0x06, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, + 0x1a, 0xc0, 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, 0x5a, 0x0a, 0x0c, 0x6f, 0x72, 0x64, 0x65, 0x72, + 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 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, 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, 0x12, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xbe, 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, 0x2d, + 0x0a, 0x13, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x62, 0x69, 0x64, 0x73, 0x5f, 0x61, 0x6e, 0x64, + 0x5f, 0x61, 0x73, 0x6b, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x63, 0x68, 0x65, + 0x63, 0x6b, 0x42, 0x69, 0x64, 0x73, 0x41, 0x6e, 0x64, 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, 0xc9, 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, 0x3c, 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, 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, 0x6c, 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, 0x22, 0x43, 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, 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, 0xd6, 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, 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, 0x65, 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, 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, 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, 0x64, 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, + 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, 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, 0x97, 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, 0x03, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 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, 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, 0x03, 0x52, 0x05, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x03, 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, 0x84, 0x01, 0x0a, 0x06, + 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 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, 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, 0x55, 0x55, 0x49, + 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x55, 0x55, 0x49, 0x44, 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, 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, 0x32, 0x8b, 0x3f, + 0x0a, 0x0e, 0x47, 0x6f, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x54, 0x72, 0x61, 0x64, 0x65, 0x72, + 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, 0x22, 0x13, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, + 0x65, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x3a, 0x01, 0x2a, 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, 0x73, 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, 0x1d, 0x2e, 0x67, 0x63, + 0x74, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x4f, 0x54, 0x50, 0x52, 0x65, 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, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x65, 0x78, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x3a, 0x01, 0x2a, 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, + 0x22, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x3a, + 0x01, 0x2a, 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, 0x22, + 0x10, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x62, 0x6f, 0x6f, + 0x6b, 0x3a, 0x01, 0x2a, 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, 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, + 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, 0x3a, 0x01, 0x2a, 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, 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, 0x3a, 0x01, 0x2a, 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, 0x22, 0x0d, 0x2f, 0x76, 0x31, 0x2f, 0x67, + 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x3a, 0x01, 0x2a, 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, 0x22, 0x0c, + 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x01, 0x2a, 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, 0x22, + 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x6f, 0x72, 0x64, 0x65, 0x72, + 0x3a, 0x01, 0x2a, 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, 0x22, 0x11, 0x2f, 0x76, 0x31, 0x2f, 0x73, + 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x01, 0x2a, 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, 0x22, 0x0d, 0x2f, + 0x76, 0x31, 0x2f, 0x77, 0x68, 0x61, 0x6c, 0x65, 0x62, 0x6f, 0x6d, 0x62, 0x3a, 0x01, 0x2a, 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, 0x22, 0x0f, 0x2f, 0x76, 0x31, + 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x01, 0x2a, 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, 0x22, 0x13, 0x2f, 0x76, 0x31, + 0x2f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x61, 0x6c, 0x6c, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, + 0x3a, 0x01, 0x2a, 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, 0x22, 0x0c, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x64, 0x64, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x3a, 0x01, 0x2a, 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, + 0x22, 0x0f, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x3a, 0x01, 0x2a, 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, 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, 0x3a, 0x01, 0x2a, 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, 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, 0x3a, 0x01, 0x2a, 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, 0x22, 0x15, 0x2f, 0x76, 0x31, 0x2f, + 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x66, 0x69, 0x61, 0x74, 0x66, 0x75, 0x6e, 0x64, + 0x73, 0x3a, 0x01, 0x2a, 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, 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, 0x3a, + 0x01, 0x2a, 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, 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, 0x3a, 0x01, 0x2a, 0x12, 0x97, 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, 0x22, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1c, 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, 0x3a, 0x01, + 0x2a, 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, 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, 0x3a, 0x01, 0x2a, 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, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x73, + 0x65, 0x74, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x72, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x3a, + 0x01, 0x2a, 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, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, + 0x67, 0x65, 0x70, 0x61, 0x69, 0x72, 0x73, 0x3a, 0x01, 0x2a, 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, 0x22, 0x13, + 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x74, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x70, + 0x61, 0x69, 0x72, 0x3a, 0x01, 0x2a, 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, 0x22, 0x14, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x2f, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x3a, 0x01, 0x2a, 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, 0x22, 0x12, + 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x72, 0x65, + 0x61, 0x64, 0x3a, 0x01, 0x2a, 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, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x2f, 0x73, 0x74, 0x6f, 0x70, 0x3a, 0x01, 0x2a, 0x12, 0x6b, 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, 0x1d, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x17, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x2f, 0x73, 0x74, 0x6f, 0x70, 0x3a, 0x01, 0x2a, 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, 0x22, 0x12, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x63, 0x74, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x73, 0x74, 0x6f, 0x70, 0x3a, 0x01, 0x2a, 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, 0x22, 0x16, 0x2f, 0x76, + 0x31, 0x2f, 0x67, 0x63, 0x74, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2f, 0x61, 0x75, 0x74, 0x6f, + 0x6c, 0x6f, 0x61, 0x64, 0x3a, 0x01, 0x2a, 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, 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, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_rpc_proto_rawDescOnce sync.Once + file_rpc_proto_rawDescData = file_rpc_proto_rawDesc +) + +func file_rpc_proto_rawDescGZIP() []byte { + file_rpc_proto_rawDescOnce.Do(func() { + file_rpc_proto_rawDescData = protoimpl.X.CompressGZIP(file_rpc_proto_rawDescData) + }) + return file_rpc_proto_rawDescData +} + +var file_rpc_proto_msgTypes = make([]protoimpl.MessageInfo, 148) +var file_rpc_proto_goTypes = []interface{}{ + (*GetInfoRequest)(nil), // 0: gctrpc.GetInfoRequest + (*GetInfoResponse)(nil), // 1: gctrpc.GetInfoResponse + (*GetCommunicationRelayersRequest)(nil), // 2: gctrpc.GetCommunicationRelayersRequest + (*CommunicationRelayer)(nil), // 3: gctrpc.CommunicationRelayer + (*GetCommunicationRelayersResponse)(nil), // 4: gctrpc.GetCommunicationRelayersResponse + (*GenericSubsystemRequest)(nil), // 5: gctrpc.GenericSubsystemRequest + (*GetSubsystemsRequest)(nil), // 6: gctrpc.GetSubsystemsRequest + (*GetSusbsytemsResponse)(nil), // 7: gctrpc.GetSusbsytemsResponse + (*GetRPCEndpointsRequest)(nil), // 8: gctrpc.GetRPCEndpointsRequest + (*RPCEndpoint)(nil), // 9: gctrpc.RPCEndpoint + (*GetRPCEndpointsResponse)(nil), // 10: gctrpc.GetRPCEndpointsResponse + (*GenericExchangeNameRequest)(nil), // 11: gctrpc.GenericExchangeNameRequest + (*GetExchangesRequest)(nil), // 12: gctrpc.GetExchangesRequest + (*GetExchangesResponse)(nil), // 13: gctrpc.GetExchangesResponse + (*GetExchangeOTPReponse)(nil), // 14: gctrpc.GetExchangeOTPReponse + (*GetExchangeOTPsRequest)(nil), // 15: gctrpc.GetExchangeOTPsRequest + (*GetExchangeOTPsResponse)(nil), // 16: gctrpc.GetExchangeOTPsResponse + (*DisableExchangeRequest)(nil), // 17: gctrpc.DisableExchangeRequest + (*PairsSupported)(nil), // 18: gctrpc.PairsSupported + (*GetExchangeInfoResponse)(nil), // 19: gctrpc.GetExchangeInfoResponse + (*GetTickerRequest)(nil), // 20: gctrpc.GetTickerRequest + (*CurrencyPair)(nil), // 21: gctrpc.CurrencyPair + (*TickerResponse)(nil), // 22: gctrpc.TickerResponse + (*GetTickersRequest)(nil), // 23: gctrpc.GetTickersRequest + (*Tickers)(nil), // 24: gctrpc.Tickers + (*GetTickersResponse)(nil), // 25: gctrpc.GetTickersResponse + (*GetOrderbookRequest)(nil), // 26: gctrpc.GetOrderbookRequest + (*OrderbookItem)(nil), // 27: gctrpc.OrderbookItem + (*OrderbookResponse)(nil), // 28: gctrpc.OrderbookResponse + (*GetOrderbooksRequest)(nil), // 29: gctrpc.GetOrderbooksRequest + (*Orderbooks)(nil), // 30: gctrpc.Orderbooks + (*GetOrderbooksResponse)(nil), // 31: gctrpc.GetOrderbooksResponse + (*GetAccountInfoRequest)(nil), // 32: gctrpc.GetAccountInfoRequest + (*Account)(nil), // 33: gctrpc.Account + (*AccountCurrencyInfo)(nil), // 34: gctrpc.AccountCurrencyInfo + (*GetAccountInfoResponse)(nil), // 35: gctrpc.GetAccountInfoResponse + (*GetConfigRequest)(nil), // 36: gctrpc.GetConfigRequest + (*GetConfigResponse)(nil), // 37: gctrpc.GetConfigResponse + (*PortfolioAddress)(nil), // 38: gctrpc.PortfolioAddress + (*GetPortfolioRequest)(nil), // 39: gctrpc.GetPortfolioRequest + (*GetPortfolioResponse)(nil), // 40: gctrpc.GetPortfolioResponse + (*GetPortfolioSummaryRequest)(nil), // 41: gctrpc.GetPortfolioSummaryRequest + (*Coin)(nil), // 42: gctrpc.Coin + (*OfflineCoinSummary)(nil), // 43: gctrpc.OfflineCoinSummary + (*OnlineCoinSummary)(nil), // 44: gctrpc.OnlineCoinSummary + (*OfflineCoins)(nil), // 45: gctrpc.OfflineCoins + (*OnlineCoins)(nil), // 46: gctrpc.OnlineCoins + (*GetPortfolioSummaryResponse)(nil), // 47: gctrpc.GetPortfolioSummaryResponse + (*AddPortfolioAddressRequest)(nil), // 48: gctrpc.AddPortfolioAddressRequest + (*RemovePortfolioAddressRequest)(nil), // 49: gctrpc.RemovePortfolioAddressRequest + (*GetForexProvidersRequest)(nil), // 50: gctrpc.GetForexProvidersRequest + (*ForexProvider)(nil), // 51: gctrpc.ForexProvider + (*GetForexProvidersResponse)(nil), // 52: gctrpc.GetForexProvidersResponse + (*GetForexRatesRequest)(nil), // 53: gctrpc.GetForexRatesRequest + (*ForexRatesConversion)(nil), // 54: gctrpc.ForexRatesConversion + (*GetForexRatesResponse)(nil), // 55: gctrpc.GetForexRatesResponse + (*OrderDetails)(nil), // 56: gctrpc.OrderDetails + (*TradeHistory)(nil), // 57: gctrpc.TradeHistory + (*GetOrdersRequest)(nil), // 58: gctrpc.GetOrdersRequest + (*GetOrdersResponse)(nil), // 59: gctrpc.GetOrdersResponse + (*GetOrderRequest)(nil), // 60: gctrpc.GetOrderRequest + (*SubmitOrderRequest)(nil), // 61: gctrpc.SubmitOrderRequest + (*SubmitOrderResponse)(nil), // 62: gctrpc.SubmitOrderResponse + (*SimulateOrderRequest)(nil), // 63: gctrpc.SimulateOrderRequest + (*SimulateOrderResponse)(nil), // 64: gctrpc.SimulateOrderResponse + (*WhaleBombRequest)(nil), // 65: gctrpc.WhaleBombRequest + (*CancelOrderRequest)(nil), // 66: gctrpc.CancelOrderRequest + (*CancelAllOrdersRequest)(nil), // 67: gctrpc.CancelAllOrdersRequest + (*CancelAllOrdersResponse)(nil), // 68: gctrpc.CancelAllOrdersResponse + (*GetEventsRequest)(nil), // 69: gctrpc.GetEventsRequest + (*ConditionParams)(nil), // 70: gctrpc.ConditionParams + (*GetEventsResponse)(nil), // 71: gctrpc.GetEventsResponse + (*AddEventRequest)(nil), // 72: gctrpc.AddEventRequest + (*AddEventResponse)(nil), // 73: gctrpc.AddEventResponse + (*RemoveEventRequest)(nil), // 74: gctrpc.RemoveEventRequest + (*GetCryptocurrencyDepositAddressesRequest)(nil), // 75: gctrpc.GetCryptocurrencyDepositAddressesRequest + (*GetCryptocurrencyDepositAddressesResponse)(nil), // 76: gctrpc.GetCryptocurrencyDepositAddressesResponse + (*GetCryptocurrencyDepositAddressRequest)(nil), // 77: gctrpc.GetCryptocurrencyDepositAddressRequest + (*GetCryptocurrencyDepositAddressResponse)(nil), // 78: gctrpc.GetCryptocurrencyDepositAddressResponse + (*WithdrawFiatRequest)(nil), // 79: gctrpc.WithdrawFiatRequest + (*WithdrawCryptoRequest)(nil), // 80: gctrpc.WithdrawCryptoRequest + (*WithdrawResponse)(nil), // 81: gctrpc.WithdrawResponse + (*WithdrawalEventByIDRequest)(nil), // 82: gctrpc.WithdrawalEventByIDRequest + (*WithdrawalEventByIDResponse)(nil), // 83: gctrpc.WithdrawalEventByIDResponse + (*WithdrawalEventsByExchangeRequest)(nil), // 84: gctrpc.WithdrawalEventsByExchangeRequest + (*WithdrawalEventsByDateRequest)(nil), // 85: gctrpc.WithdrawalEventsByDateRequest + (*WithdrawalEventsByExchangeResponse)(nil), // 86: gctrpc.WithdrawalEventsByExchangeResponse + (*WithdrawalEventResponse)(nil), // 87: gctrpc.WithdrawalEventResponse + (*WithdrawlExchangeEvent)(nil), // 88: gctrpc.WithdrawlExchangeEvent + (*WithdrawalRequestEvent)(nil), // 89: gctrpc.WithdrawalRequestEvent + (*FiatWithdrawalEvent)(nil), // 90: gctrpc.FiatWithdrawalEvent + (*CryptoWithdrawalEvent)(nil), // 91: gctrpc.CryptoWithdrawalEvent + (*GetLoggerDetailsRequest)(nil), // 92: gctrpc.GetLoggerDetailsRequest + (*GetLoggerDetailsResponse)(nil), // 93: gctrpc.GetLoggerDetailsResponse + (*SetLoggerDetailsRequest)(nil), // 94: gctrpc.SetLoggerDetailsRequest + (*GetExchangePairsRequest)(nil), // 95: gctrpc.GetExchangePairsRequest + (*GetExchangePairsResponse)(nil), // 96: gctrpc.GetExchangePairsResponse + (*SetExchangePairRequest)(nil), // 97: gctrpc.SetExchangePairRequest + (*GetOrderbookStreamRequest)(nil), // 98: gctrpc.GetOrderbookStreamRequest + (*GetExchangeOrderbookStreamRequest)(nil), // 99: gctrpc.GetExchangeOrderbookStreamRequest + (*GetTickerStreamRequest)(nil), // 100: gctrpc.GetTickerStreamRequest + (*GetExchangeTickerStreamRequest)(nil), // 101: gctrpc.GetExchangeTickerStreamRequest + (*GetAuditEventRequest)(nil), // 102: gctrpc.GetAuditEventRequest + (*GetAuditEventResponse)(nil), // 103: gctrpc.GetAuditEventResponse + (*GetHistoricCandlesRequest)(nil), // 104: gctrpc.GetHistoricCandlesRequest + (*GetHistoricCandlesResponse)(nil), // 105: gctrpc.GetHistoricCandlesResponse + (*Candle)(nil), // 106: gctrpc.Candle + (*AuditEvent)(nil), // 107: gctrpc.AuditEvent + (*GCTScript)(nil), // 108: gctrpc.GCTScript + (*GCTScriptExecuteRequest)(nil), // 109: gctrpc.GCTScriptExecuteRequest + (*GCTScriptStopRequest)(nil), // 110: gctrpc.GCTScriptStopRequest + (*GCTScriptStopAllRequest)(nil), // 111: gctrpc.GCTScriptStopAllRequest + (*GCTScriptStatusRequest)(nil), // 112: gctrpc.GCTScriptStatusRequest + (*GCTScriptListAllRequest)(nil), // 113: gctrpc.GCTScriptListAllRequest + (*GCTScriptUploadRequest)(nil), // 114: gctrpc.GCTScriptUploadRequest + (*GCTScriptReadScriptRequest)(nil), // 115: gctrpc.GCTScriptReadScriptRequest + (*GCTScriptQueryRequest)(nil), // 116: gctrpc.GCTScriptQueryRequest + (*GCTScriptAutoLoadRequest)(nil), // 117: gctrpc.GCTScriptAutoLoadRequest + (*GCTScriptStatusResponse)(nil), // 118: gctrpc.GCTScriptStatusResponse + (*GCTScriptQueryResponse)(nil), // 119: gctrpc.GCTScriptQueryResponse + (*GenericResponse)(nil), // 120: gctrpc.GenericResponse + (*SetExchangeAssetRequest)(nil), // 121: gctrpc.SetExchangeAssetRequest + (*SetExchangeAllPairsRequest)(nil), // 122: gctrpc.SetExchangeAllPairsRequest + (*UpdateExchangeSupportedPairsRequest)(nil), // 123: gctrpc.UpdateExchangeSupportedPairsRequest + (*GetExchangeAssetsRequest)(nil), // 124: gctrpc.GetExchangeAssetsRequest + (*GetExchangeAssetsResponse)(nil), // 125: gctrpc.GetExchangeAssetsResponse + (*WebsocketGetInfoRequest)(nil), // 126: gctrpc.WebsocketGetInfoRequest + (*WebsocketGetInfoResponse)(nil), // 127: gctrpc.WebsocketGetInfoResponse + (*WebsocketSetEnabledRequest)(nil), // 128: gctrpc.WebsocketSetEnabledRequest + (*WebsocketGetSubscriptionsRequest)(nil), // 129: gctrpc.WebsocketGetSubscriptionsRequest + (*WebsocketSubscription)(nil), // 130: gctrpc.WebsocketSubscription + (*WebsocketGetSubscriptionsResponse)(nil), // 131: gctrpc.WebsocketGetSubscriptionsResponse + (*WebsocketSetProxyRequest)(nil), // 132: gctrpc.WebsocketSetProxyRequest + (*WebsocketSetURLRequest)(nil), // 133: gctrpc.WebsocketSetURLRequest + nil, // 134: gctrpc.GetInfoResponse.SubsystemStatusEntry + nil, // 135: gctrpc.GetInfoResponse.RpcEndpointsEntry + nil, // 136: gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry + nil, // 137: gctrpc.GetSusbsytemsResponse.SubsystemsStatusEntry + nil, // 138: gctrpc.GetRPCEndpointsResponse.EndpointsEntry + nil, // 139: gctrpc.GetExchangeOTPsResponse.OtpCodesEntry + nil, // 140: gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry + nil, // 141: gctrpc.OnlineCoins.CoinsEntry + nil, // 142: gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry + nil, // 143: gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry + (*CancelAllOrdersResponse_Orders)(nil), // 144: gctrpc.CancelAllOrdersResponse.Orders + nil, // 145: gctrpc.CancelAllOrdersResponse.Orders.OrderStatusEntry + nil, // 146: gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry + nil, // 147: gctrpc.GetExchangePairsResponse.SupportedAssetsEntry + (*timestamp.Timestamp)(nil), // 148: google.protobuf.Timestamp +} +var file_rpc_proto_depIdxs = []int32{ + 134, // 0: gctrpc.GetInfoResponse.subsystem_status:type_name -> gctrpc.GetInfoResponse.SubsystemStatusEntry + 135, // 1: gctrpc.GetInfoResponse.rpc_endpoints:type_name -> gctrpc.GetInfoResponse.RpcEndpointsEntry + 136, // 2: gctrpc.GetCommunicationRelayersResponse.communication_relayers:type_name -> gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry + 137, // 3: gctrpc.GetSusbsytemsResponse.subsystems_status:type_name -> gctrpc.GetSusbsytemsResponse.SubsystemsStatusEntry + 138, // 4: gctrpc.GetRPCEndpointsResponse.endpoints:type_name -> gctrpc.GetRPCEndpointsResponse.EndpointsEntry + 139, // 5: gctrpc.GetExchangeOTPsResponse.otp_codes:type_name -> gctrpc.GetExchangeOTPsResponse.OtpCodesEntry + 140, // 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 + 24, // 10: gctrpc.GetTickersResponse.tickers:type_name -> gctrpc.Tickers + 21, // 11: gctrpc.GetOrderbookRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 12: gctrpc.OrderbookResponse.pair:type_name -> gctrpc.CurrencyPair + 27, // 13: gctrpc.OrderbookResponse.bids:type_name -> gctrpc.OrderbookItem + 27, // 14: gctrpc.OrderbookResponse.asks:type_name -> gctrpc.OrderbookItem + 28, // 15: gctrpc.Orderbooks.orderbooks:type_name -> gctrpc.OrderbookResponse + 30, // 16: gctrpc.GetOrderbooksResponse.orderbooks:type_name -> gctrpc.Orderbooks + 34, // 17: gctrpc.Account.currencies:type_name -> gctrpc.AccountCurrencyInfo + 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 + 141, // 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 + 142, // 24: gctrpc.GetPortfolioSummaryResponse.coins_offline_summary:type_name -> gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry + 42, // 25: gctrpc.GetPortfolioSummaryResponse.coins_online:type_name -> gctrpc.Coin + 143, // 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 + 21, // 30: gctrpc.GetOrdersRequest.pair:type_name -> gctrpc.CurrencyPair + 56, // 31: gctrpc.GetOrdersResponse.orders:type_name -> gctrpc.OrderDetails + 21, // 32: gctrpc.SubmitOrderRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 33: gctrpc.SimulateOrderRequest.pair:type_name -> gctrpc.CurrencyPair + 27, // 34: gctrpc.SimulateOrderResponse.orders:type_name -> gctrpc.OrderbookItem + 21, // 35: gctrpc.WhaleBombRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 36: gctrpc.CancelOrderRequest.pair:type_name -> gctrpc.CurrencyPair + 144, // 37: gctrpc.CancelAllOrdersResponse.orders:type_name -> gctrpc.CancelAllOrdersResponse.Orders + 70, // 38: gctrpc.GetEventsResponse.condition_params:type_name -> gctrpc.ConditionParams + 21, // 39: gctrpc.GetEventsResponse.pair:type_name -> gctrpc.CurrencyPair + 70, // 40: gctrpc.AddEventRequest.condition_params:type_name -> gctrpc.ConditionParams + 21, // 41: gctrpc.AddEventRequest.pair:type_name -> gctrpc.CurrencyPair + 146, // 42: gctrpc.GetCryptocurrencyDepositAddressesResponse.addresses:type_name -> gctrpc.GetCryptocurrencyDepositAddressesResponse.AddressesEntry + 87, // 43: gctrpc.WithdrawalEventByIDResponse.event:type_name -> gctrpc.WithdrawalEventResponse + 87, // 44: gctrpc.WithdrawalEventsByExchangeResponse.event:type_name -> gctrpc.WithdrawalEventResponse + 88, // 45: gctrpc.WithdrawalEventResponse.exchange:type_name -> gctrpc.WithdrawlExchangeEvent + 89, // 46: gctrpc.WithdrawalEventResponse.request:type_name -> gctrpc.WithdrawalRequestEvent + 148, // 47: gctrpc.WithdrawalEventResponse.created_at:type_name -> google.protobuf.Timestamp + 148, // 48: gctrpc.WithdrawalEventResponse.updated_at:type_name -> google.protobuf.Timestamp + 90, // 49: gctrpc.WithdrawalRequestEvent.fiat:type_name -> gctrpc.FiatWithdrawalEvent + 91, // 50: gctrpc.WithdrawalRequestEvent.crypto:type_name -> gctrpc.CryptoWithdrawalEvent + 147, // 51: gctrpc.GetExchangePairsResponse.supported_assets:type_name -> gctrpc.GetExchangePairsResponse.SupportedAssetsEntry + 21, // 52: gctrpc.SetExchangePairRequest.pairs:type_name -> gctrpc.CurrencyPair + 21, // 53: gctrpc.GetOrderbookStreamRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 54: gctrpc.GetTickerStreamRequest.pair:type_name -> gctrpc.CurrencyPair + 107, // 55: gctrpc.GetAuditEventResponse.events:type_name -> gctrpc.AuditEvent + 21, // 56: gctrpc.GetHistoricCandlesRequest.pair:type_name -> gctrpc.CurrencyPair + 21, // 57: gctrpc.GetHistoricCandlesResponse.pair:type_name -> gctrpc.CurrencyPair + 106, // 58: gctrpc.GetHistoricCandlesResponse.candle:type_name -> gctrpc.Candle + 108, // 59: gctrpc.GCTScriptExecuteRequest.script:type_name -> gctrpc.GCTScript + 108, // 60: gctrpc.GCTScriptStopRequest.script:type_name -> gctrpc.GCTScript + 108, // 61: gctrpc.GCTScriptReadScriptRequest.script:type_name -> gctrpc.GCTScript + 108, // 62: gctrpc.GCTScriptQueryRequest.script:type_name -> gctrpc.GCTScript + 108, // 63: gctrpc.GCTScriptStatusResponse.scripts:type_name -> gctrpc.GCTScript + 108, // 64: gctrpc.GCTScriptQueryResponse.script:type_name -> gctrpc.GCTScript + 130, // 65: gctrpc.WebsocketGetSubscriptionsResponse.subscriptions:type_name -> gctrpc.WebsocketSubscription + 9, // 66: gctrpc.GetInfoResponse.RpcEndpointsEntry.value:type_name -> gctrpc.RPCEndpoint + 3, // 67: gctrpc.GetCommunicationRelayersResponse.CommunicationRelayersEntry.value:type_name -> gctrpc.CommunicationRelayer + 9, // 68: gctrpc.GetRPCEndpointsResponse.EndpointsEntry.value:type_name -> gctrpc.RPCEndpoint + 18, // 69: gctrpc.GetExchangeInfoResponse.SupportedAssetsEntry.value:type_name -> gctrpc.PairsSupported + 44, // 70: gctrpc.OnlineCoins.CoinsEntry.value:type_name -> gctrpc.OnlineCoinSummary + 45, // 71: gctrpc.GetPortfolioSummaryResponse.CoinsOfflineSummaryEntry.value:type_name -> gctrpc.OfflineCoins + 46, // 72: gctrpc.GetPortfolioSummaryResponse.CoinsOnlineSummaryEntry.value:type_name -> gctrpc.OnlineCoins + 145, // 73: gctrpc.CancelAllOrdersResponse.Orders.order_status:type_name -> gctrpc.CancelAllOrdersResponse.Orders.OrderStatusEntry + 18, // 74: gctrpc.GetExchangePairsResponse.SupportedAssetsEntry.value:type_name -> gctrpc.PairsSupported + 0, // 75: gctrpc.GoCryptoTrader.GetInfo:input_type -> gctrpc.GetInfoRequest + 6, // 76: gctrpc.GoCryptoTrader.GetSubsystems:input_type -> gctrpc.GetSubsystemsRequest + 5, // 77: gctrpc.GoCryptoTrader.EnableSubsystem:input_type -> gctrpc.GenericSubsystemRequest + 5, // 78: gctrpc.GoCryptoTrader.DisableSubsystem:input_type -> gctrpc.GenericSubsystemRequest + 8, // 79: gctrpc.GoCryptoTrader.GetRPCEndpoints:input_type -> gctrpc.GetRPCEndpointsRequest + 2, // 80: gctrpc.GoCryptoTrader.GetCommunicationRelayers:input_type -> gctrpc.GetCommunicationRelayersRequest + 12, // 81: gctrpc.GoCryptoTrader.GetExchanges:input_type -> gctrpc.GetExchangesRequest + 11, // 82: gctrpc.GoCryptoTrader.DisableExchange:input_type -> gctrpc.GenericExchangeNameRequest + 11, // 83: gctrpc.GoCryptoTrader.GetExchangeInfo:input_type -> gctrpc.GenericExchangeNameRequest + 11, // 84: gctrpc.GoCryptoTrader.GetExchangeOTPCode:input_type -> gctrpc.GenericExchangeNameRequest + 15, // 85: gctrpc.GoCryptoTrader.GetExchangeOTPCodes:input_type -> gctrpc.GetExchangeOTPsRequest + 11, // 86: gctrpc.GoCryptoTrader.EnableExchange:input_type -> gctrpc.GenericExchangeNameRequest + 20, // 87: gctrpc.GoCryptoTrader.GetTicker:input_type -> gctrpc.GetTickerRequest + 23, // 88: gctrpc.GoCryptoTrader.GetTickers:input_type -> gctrpc.GetTickersRequest + 26, // 89: gctrpc.GoCryptoTrader.GetOrderbook:input_type -> gctrpc.GetOrderbookRequest + 29, // 90: gctrpc.GoCryptoTrader.GetOrderbooks:input_type -> gctrpc.GetOrderbooksRequest + 32, // 91: gctrpc.GoCryptoTrader.GetAccountInfo:input_type -> gctrpc.GetAccountInfoRequest + 32, // 92: gctrpc.GoCryptoTrader.GetAccountInfoStream:input_type -> gctrpc.GetAccountInfoRequest + 36, // 93: gctrpc.GoCryptoTrader.GetConfig:input_type -> gctrpc.GetConfigRequest + 39, // 94: gctrpc.GoCryptoTrader.GetPortfolio:input_type -> gctrpc.GetPortfolioRequest + 41, // 95: gctrpc.GoCryptoTrader.GetPortfolioSummary:input_type -> gctrpc.GetPortfolioSummaryRequest + 48, // 96: gctrpc.GoCryptoTrader.AddPortfolioAddress:input_type -> gctrpc.AddPortfolioAddressRequest + 49, // 97: gctrpc.GoCryptoTrader.RemovePortfolioAddress:input_type -> gctrpc.RemovePortfolioAddressRequest + 50, // 98: gctrpc.GoCryptoTrader.GetForexProviders:input_type -> gctrpc.GetForexProvidersRequest + 53, // 99: gctrpc.GoCryptoTrader.GetForexRates:input_type -> gctrpc.GetForexRatesRequest + 58, // 100: gctrpc.GoCryptoTrader.GetOrders:input_type -> gctrpc.GetOrdersRequest + 60, // 101: gctrpc.GoCryptoTrader.GetOrder:input_type -> gctrpc.GetOrderRequest + 61, // 102: gctrpc.GoCryptoTrader.SubmitOrder:input_type -> gctrpc.SubmitOrderRequest + 63, // 103: gctrpc.GoCryptoTrader.SimulateOrder:input_type -> gctrpc.SimulateOrderRequest + 65, // 104: gctrpc.GoCryptoTrader.WhaleBomb:input_type -> gctrpc.WhaleBombRequest + 66, // 105: gctrpc.GoCryptoTrader.CancelOrder:input_type -> gctrpc.CancelOrderRequest + 67, // 106: gctrpc.GoCryptoTrader.CancelAllOrders:input_type -> gctrpc.CancelAllOrdersRequest + 69, // 107: gctrpc.GoCryptoTrader.GetEvents:input_type -> gctrpc.GetEventsRequest + 72, // 108: gctrpc.GoCryptoTrader.AddEvent:input_type -> gctrpc.AddEventRequest + 74, // 109: gctrpc.GoCryptoTrader.RemoveEvent:input_type -> gctrpc.RemoveEventRequest + 75, // 110: gctrpc.GoCryptoTrader.GetCryptocurrencyDepositAddresses:input_type -> gctrpc.GetCryptocurrencyDepositAddressesRequest + 77, // 111: gctrpc.GoCryptoTrader.GetCryptocurrencyDepositAddress:input_type -> gctrpc.GetCryptocurrencyDepositAddressRequest + 79, // 112: gctrpc.GoCryptoTrader.WithdrawFiatFunds:input_type -> gctrpc.WithdrawFiatRequest + 80, // 113: gctrpc.GoCryptoTrader.WithdrawCryptocurrencyFunds:input_type -> gctrpc.WithdrawCryptoRequest + 82, // 114: gctrpc.GoCryptoTrader.WithdrawalEventByID:input_type -> gctrpc.WithdrawalEventByIDRequest + 84, // 115: gctrpc.GoCryptoTrader.WithdrawalEventsByExchange:input_type -> gctrpc.WithdrawalEventsByExchangeRequest + 85, // 116: gctrpc.GoCryptoTrader.WithdrawalEventsByDate:input_type -> gctrpc.WithdrawalEventsByDateRequest + 92, // 117: gctrpc.GoCryptoTrader.GetLoggerDetails:input_type -> gctrpc.GetLoggerDetailsRequest + 94, // 118: gctrpc.GoCryptoTrader.SetLoggerDetails:input_type -> gctrpc.SetLoggerDetailsRequest + 95, // 119: gctrpc.GoCryptoTrader.GetExchangePairs:input_type -> gctrpc.GetExchangePairsRequest + 97, // 120: gctrpc.GoCryptoTrader.SetExchangePair:input_type -> gctrpc.SetExchangePairRequest + 98, // 121: gctrpc.GoCryptoTrader.GetOrderbookStream:input_type -> gctrpc.GetOrderbookStreamRequest + 99, // 122: gctrpc.GoCryptoTrader.GetExchangeOrderbookStream:input_type -> gctrpc.GetExchangeOrderbookStreamRequest + 100, // 123: gctrpc.GoCryptoTrader.GetTickerStream:input_type -> gctrpc.GetTickerStreamRequest + 101, // 124: gctrpc.GoCryptoTrader.GetExchangeTickerStream:input_type -> gctrpc.GetExchangeTickerStreamRequest + 102, // 125: gctrpc.GoCryptoTrader.GetAuditEvent:input_type -> gctrpc.GetAuditEventRequest + 109, // 126: gctrpc.GoCryptoTrader.GCTScriptExecute:input_type -> gctrpc.GCTScriptExecuteRequest + 114, // 127: gctrpc.GoCryptoTrader.GCTScriptUpload:input_type -> gctrpc.GCTScriptUploadRequest + 115, // 128: gctrpc.GoCryptoTrader.GCTScriptReadScript:input_type -> gctrpc.GCTScriptReadScriptRequest + 112, // 129: gctrpc.GoCryptoTrader.GCTScriptStatus:input_type -> gctrpc.GCTScriptStatusRequest + 116, // 130: gctrpc.GoCryptoTrader.GCTScriptQuery:input_type -> gctrpc.GCTScriptQueryRequest + 110, // 131: gctrpc.GoCryptoTrader.GCTScriptStop:input_type -> gctrpc.GCTScriptStopRequest + 111, // 132: gctrpc.GoCryptoTrader.GCTScriptStopAll:input_type -> gctrpc.GCTScriptStopAllRequest + 113, // 133: gctrpc.GoCryptoTrader.GCTScriptListAll:input_type -> gctrpc.GCTScriptListAllRequest + 117, // 134: gctrpc.GoCryptoTrader.GCTScriptAutoLoadToggle:input_type -> gctrpc.GCTScriptAutoLoadRequest + 104, // 135: gctrpc.GoCryptoTrader.GetHistoricCandles:input_type -> gctrpc.GetHistoricCandlesRequest + 121, // 136: gctrpc.GoCryptoTrader.SetExchangeAsset:input_type -> gctrpc.SetExchangeAssetRequest + 122, // 137: gctrpc.GoCryptoTrader.SetAllExchangePairs:input_type -> gctrpc.SetExchangeAllPairsRequest + 123, // 138: gctrpc.GoCryptoTrader.UpdateExchangeSupportedPairs:input_type -> gctrpc.UpdateExchangeSupportedPairsRequest + 124, // 139: gctrpc.GoCryptoTrader.GetExchangeAssets:input_type -> gctrpc.GetExchangeAssetsRequest + 126, // 140: gctrpc.GoCryptoTrader.WebsocketGetInfo:input_type -> gctrpc.WebsocketGetInfoRequest + 128, // 141: gctrpc.GoCryptoTrader.WebsocketSetEnabled:input_type -> gctrpc.WebsocketSetEnabledRequest + 129, // 142: gctrpc.GoCryptoTrader.WebsocketGetSubscriptions:input_type -> gctrpc.WebsocketGetSubscriptionsRequest + 132, // 143: gctrpc.GoCryptoTrader.WebsocketSetProxy:input_type -> gctrpc.WebsocketSetProxyRequest + 133, // 144: gctrpc.GoCryptoTrader.WebsocketSetURL:input_type -> gctrpc.WebsocketSetURLRequest + 1, // 145: gctrpc.GoCryptoTrader.GetInfo:output_type -> gctrpc.GetInfoResponse + 7, // 146: gctrpc.GoCryptoTrader.GetSubsystems:output_type -> gctrpc.GetSusbsytemsResponse + 120, // 147: gctrpc.GoCryptoTrader.EnableSubsystem:output_type -> gctrpc.GenericResponse + 120, // 148: gctrpc.GoCryptoTrader.DisableSubsystem:output_type -> gctrpc.GenericResponse + 10, // 149: gctrpc.GoCryptoTrader.GetRPCEndpoints:output_type -> gctrpc.GetRPCEndpointsResponse + 4, // 150: gctrpc.GoCryptoTrader.GetCommunicationRelayers:output_type -> gctrpc.GetCommunicationRelayersResponse + 13, // 151: gctrpc.GoCryptoTrader.GetExchanges:output_type -> gctrpc.GetExchangesResponse + 120, // 152: gctrpc.GoCryptoTrader.DisableExchange:output_type -> gctrpc.GenericResponse + 19, // 153: gctrpc.GoCryptoTrader.GetExchangeInfo:output_type -> gctrpc.GetExchangeInfoResponse + 14, // 154: gctrpc.GoCryptoTrader.GetExchangeOTPCode:output_type -> gctrpc.GetExchangeOTPReponse + 16, // 155: gctrpc.GoCryptoTrader.GetExchangeOTPCodes:output_type -> gctrpc.GetExchangeOTPsResponse + 120, // 156: gctrpc.GoCryptoTrader.EnableExchange:output_type -> gctrpc.GenericResponse + 22, // 157: gctrpc.GoCryptoTrader.GetTicker:output_type -> gctrpc.TickerResponse + 25, // 158: gctrpc.GoCryptoTrader.GetTickers:output_type -> gctrpc.GetTickersResponse + 28, // 159: gctrpc.GoCryptoTrader.GetOrderbook:output_type -> gctrpc.OrderbookResponse + 31, // 160: gctrpc.GoCryptoTrader.GetOrderbooks:output_type -> gctrpc.GetOrderbooksResponse + 35, // 161: gctrpc.GoCryptoTrader.GetAccountInfo:output_type -> gctrpc.GetAccountInfoResponse + 35, // 162: gctrpc.GoCryptoTrader.GetAccountInfoStream:output_type -> gctrpc.GetAccountInfoResponse + 37, // 163: gctrpc.GoCryptoTrader.GetConfig:output_type -> gctrpc.GetConfigResponse + 40, // 164: gctrpc.GoCryptoTrader.GetPortfolio:output_type -> gctrpc.GetPortfolioResponse + 47, // 165: gctrpc.GoCryptoTrader.GetPortfolioSummary:output_type -> gctrpc.GetPortfolioSummaryResponse + 120, // 166: gctrpc.GoCryptoTrader.AddPortfolioAddress:output_type -> gctrpc.GenericResponse + 120, // 167: gctrpc.GoCryptoTrader.RemovePortfolioAddress:output_type -> gctrpc.GenericResponse + 52, // 168: gctrpc.GoCryptoTrader.GetForexProviders:output_type -> gctrpc.GetForexProvidersResponse + 55, // 169: gctrpc.GoCryptoTrader.GetForexRates:output_type -> gctrpc.GetForexRatesResponse + 59, // 170: gctrpc.GoCryptoTrader.GetOrders:output_type -> gctrpc.GetOrdersResponse + 56, // 171: gctrpc.GoCryptoTrader.GetOrder:output_type -> gctrpc.OrderDetails + 62, // 172: gctrpc.GoCryptoTrader.SubmitOrder:output_type -> gctrpc.SubmitOrderResponse + 64, // 173: gctrpc.GoCryptoTrader.SimulateOrder:output_type -> gctrpc.SimulateOrderResponse + 64, // 174: gctrpc.GoCryptoTrader.WhaleBomb:output_type -> gctrpc.SimulateOrderResponse + 120, // 175: gctrpc.GoCryptoTrader.CancelOrder:output_type -> gctrpc.GenericResponse + 68, // 176: gctrpc.GoCryptoTrader.CancelAllOrders:output_type -> gctrpc.CancelAllOrdersResponse + 71, // 177: gctrpc.GoCryptoTrader.GetEvents:output_type -> gctrpc.GetEventsResponse + 73, // 178: gctrpc.GoCryptoTrader.AddEvent:output_type -> gctrpc.AddEventResponse + 120, // 179: gctrpc.GoCryptoTrader.RemoveEvent:output_type -> gctrpc.GenericResponse + 76, // 180: gctrpc.GoCryptoTrader.GetCryptocurrencyDepositAddresses:output_type -> gctrpc.GetCryptocurrencyDepositAddressesResponse + 78, // 181: gctrpc.GoCryptoTrader.GetCryptocurrencyDepositAddress:output_type -> gctrpc.GetCryptocurrencyDepositAddressResponse + 81, // 182: gctrpc.GoCryptoTrader.WithdrawFiatFunds:output_type -> gctrpc.WithdrawResponse + 81, // 183: gctrpc.GoCryptoTrader.WithdrawCryptocurrencyFunds:output_type -> gctrpc.WithdrawResponse + 83, // 184: gctrpc.GoCryptoTrader.WithdrawalEventByID:output_type -> gctrpc.WithdrawalEventByIDResponse + 86, // 185: gctrpc.GoCryptoTrader.WithdrawalEventsByExchange:output_type -> gctrpc.WithdrawalEventsByExchangeResponse + 86, // 186: gctrpc.GoCryptoTrader.WithdrawalEventsByDate:output_type -> gctrpc.WithdrawalEventsByExchangeResponse + 93, // 187: gctrpc.GoCryptoTrader.GetLoggerDetails:output_type -> gctrpc.GetLoggerDetailsResponse + 93, // 188: gctrpc.GoCryptoTrader.SetLoggerDetails:output_type -> gctrpc.GetLoggerDetailsResponse + 96, // 189: gctrpc.GoCryptoTrader.GetExchangePairs:output_type -> gctrpc.GetExchangePairsResponse + 120, // 190: gctrpc.GoCryptoTrader.SetExchangePair:output_type -> gctrpc.GenericResponse + 28, // 191: gctrpc.GoCryptoTrader.GetOrderbookStream:output_type -> gctrpc.OrderbookResponse + 28, // 192: gctrpc.GoCryptoTrader.GetExchangeOrderbookStream:output_type -> gctrpc.OrderbookResponse + 22, // 193: gctrpc.GoCryptoTrader.GetTickerStream:output_type -> gctrpc.TickerResponse + 22, // 194: gctrpc.GoCryptoTrader.GetExchangeTickerStream:output_type -> gctrpc.TickerResponse + 103, // 195: gctrpc.GoCryptoTrader.GetAuditEvent:output_type -> gctrpc.GetAuditEventResponse + 120, // 196: gctrpc.GoCryptoTrader.GCTScriptExecute:output_type -> gctrpc.GenericResponse + 120, // 197: gctrpc.GoCryptoTrader.GCTScriptUpload:output_type -> gctrpc.GenericResponse + 119, // 198: gctrpc.GoCryptoTrader.GCTScriptReadScript:output_type -> gctrpc.GCTScriptQueryResponse + 118, // 199: gctrpc.GoCryptoTrader.GCTScriptStatus:output_type -> gctrpc.GCTScriptStatusResponse + 119, // 200: gctrpc.GoCryptoTrader.GCTScriptQuery:output_type -> gctrpc.GCTScriptQueryResponse + 120, // 201: gctrpc.GoCryptoTrader.GCTScriptStop:output_type -> gctrpc.GenericResponse + 120, // 202: gctrpc.GoCryptoTrader.GCTScriptStopAll:output_type -> gctrpc.GenericResponse + 118, // 203: gctrpc.GoCryptoTrader.GCTScriptListAll:output_type -> gctrpc.GCTScriptStatusResponse + 120, // 204: gctrpc.GoCryptoTrader.GCTScriptAutoLoadToggle:output_type -> gctrpc.GenericResponse + 105, // 205: gctrpc.GoCryptoTrader.GetHistoricCandles:output_type -> gctrpc.GetHistoricCandlesResponse + 120, // 206: gctrpc.GoCryptoTrader.SetExchangeAsset:output_type -> gctrpc.GenericResponse + 120, // 207: gctrpc.GoCryptoTrader.SetAllExchangePairs:output_type -> gctrpc.GenericResponse + 120, // 208: gctrpc.GoCryptoTrader.UpdateExchangeSupportedPairs:output_type -> gctrpc.GenericResponse + 125, // 209: gctrpc.GoCryptoTrader.GetExchangeAssets:output_type -> gctrpc.GetExchangeAssetsResponse + 127, // 210: gctrpc.GoCryptoTrader.WebsocketGetInfo:output_type -> gctrpc.WebsocketGetInfoResponse + 120, // 211: gctrpc.GoCryptoTrader.WebsocketSetEnabled:output_type -> gctrpc.GenericResponse + 131, // 212: gctrpc.GoCryptoTrader.WebsocketGetSubscriptions:output_type -> gctrpc.WebsocketGetSubscriptionsResponse + 120, // 213: gctrpc.GoCryptoTrader.WebsocketSetProxy:output_type -> gctrpc.GenericResponse + 120, // 214: gctrpc.GoCryptoTrader.WebsocketSetURL:output_type -> gctrpc.GenericResponse + 145, // [145:215] is the sub-list for method output_type + 75, // [75:145] is the sub-list for method input_type + 75, // [75:75] is the sub-list for extension type_name + 75, // [75:75] is the sub-list for extension extendee + 0, // [0:75] is the sub-list for field type_name +} + +func init() { file_rpc_proto_init() } +func file_rpc_proto_init() { + if File_rpc_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_rpc_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetInfoRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetInfoResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCommunicationRelayersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CommunicationRelayer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCommunicationRelayersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenericSubsystemRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSubsystemsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetSusbsytemsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRPCEndpointsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RPCEndpoint); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRPCEndpointsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenericExchangeNameRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangeOTPReponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangeOTPsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangeOTPsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DisableExchangeRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PairsSupported); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangeInfoResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTickerRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CurrencyPair); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TickerResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTickersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Tickers); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTickersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbookRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OrderbookItem); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OrderbookResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbooksRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Orderbooks); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbooksResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAccountInfoRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Account); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AccountCurrencyInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAccountInfoResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetConfigRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetConfigResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PortfolioAddress); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetPortfolioRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetPortfolioResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetPortfolioSummaryRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Coin); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OfflineCoinSummary); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OnlineCoinSummary); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OfflineCoins); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OnlineCoins); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetPortfolioSummaryResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddPortfolioAddressRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RemovePortfolioAddressRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetForexProvidersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ForexProvider); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetForexProvidersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetForexRatesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ForexRatesConversion); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetForexRatesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OrderDetails); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TradeHistory); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrdersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrdersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SubmitOrderRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SubmitOrderResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SimulateOrderRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SimulateOrderResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WhaleBombRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CancelOrderRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CancelAllOrdersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CancelAllOrdersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetEventsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ConditionParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetEventsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddEventRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddEventResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RemoveEventRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCryptocurrencyDepositAddressesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCryptocurrencyDepositAddressesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCryptocurrencyDepositAddressRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetCryptocurrencyDepositAddressResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawFiatRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawCryptoRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawalEventByIDRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawalEventByIDResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawalEventsByExchangeRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawalEventsByDateRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawalEventsByExchangeResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawalEventResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawlExchangeEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawalRequestEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FiatWithdrawalEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CryptoWithdrawalEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetLoggerDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetLoggerDetailsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetLoggerDetailsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangePairsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangePairsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetExchangePairRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetOrderbookStreamRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangeOrderbookStreamRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetTickerStreamRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangeTickerStreamRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAuditEventRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAuditEventResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetHistoricCandlesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetHistoricCandlesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Candle); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AuditEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScript); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptExecuteRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptStopRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptStopAllRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptStatusRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptListAllRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptUploadRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptReadScriptRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptQueryRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptAutoLoadRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptStatusResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GCTScriptQueryResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenericResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetExchangeAssetRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetExchangeAllPairsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateExchangeSupportedPairsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangeAssetsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetExchangeAssetsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebsocketGetInfoRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[127].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebsocketGetInfoResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebsocketSetEnabledRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[129].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebsocketGetSubscriptionsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[130].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebsocketSubscription); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[131].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebsocketGetSubscriptionsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[132].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebsocketSetProxyRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[133].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WebsocketSetURLRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_rpc_proto_msgTypes[144].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CancelAllOrdersResponse_Orders); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_rpc_proto_rawDesc, + NumEnums: 0, + NumMessages: 148, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_rpc_proto_goTypes, + DependencyIndexes: file_rpc_proto_depIdxs, + MessageInfos: file_rpc_proto_msgTypes, + }.Build() + File_rpc_proto = out.File + file_rpc_proto_rawDesc = nil + file_rpc_proto_goTypes = nil + file_rpc_proto_depIdxs = nil } // Reference imports to suppress errors if they are not otherwise used. @@ -8535,214 +12619,214 @@ type GoCryptoTraderServer interface { type UnimplementedGoCryptoTraderServer struct { } -func (*UnimplementedGoCryptoTraderServer) GetInfo(ctx context.Context, req *GetInfoRequest) (*GetInfoResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetInfo not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetSubsystems(ctx context.Context, req *GetSubsystemsRequest) (*GetSusbsytemsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetSubsystems(context.Context, *GetSubsystemsRequest) (*GetSusbsytemsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetSubsystems not implemented") } -func (*UnimplementedGoCryptoTraderServer) EnableSubsystem(ctx context.Context, req *GenericSubsystemRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) EnableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method EnableSubsystem not implemented") } -func (*UnimplementedGoCryptoTraderServer) DisableSubsystem(ctx context.Context, req *GenericSubsystemRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) DisableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method DisableSubsystem not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetRPCEndpoints(ctx context.Context, req *GetRPCEndpointsRequest) (*GetRPCEndpointsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetRPCEndpoints(context.Context, *GetRPCEndpointsRequest) (*GetRPCEndpointsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetRPCEndpoints not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetCommunicationRelayers(ctx context.Context, req *GetCommunicationRelayersRequest) (*GetCommunicationRelayersResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetCommunicationRelayers(context.Context, *GetCommunicationRelayersRequest) (*GetCommunicationRelayersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetCommunicationRelayers not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetExchanges(ctx context.Context, req *GetExchangesRequest) (*GetExchangesResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetExchanges(context.Context, *GetExchangesRequest) (*GetExchangesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetExchanges not implemented") } -func (*UnimplementedGoCryptoTraderServer) DisableExchange(ctx context.Context, req *GenericExchangeNameRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) DisableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method DisableExchange not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetExchangeInfo(ctx context.Context, req *GenericExchangeNameRequest) (*GetExchangeInfoResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetExchangeInfo(context.Context, *GenericExchangeNameRequest) (*GetExchangeInfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetExchangeInfo not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetExchangeOTPCode(ctx context.Context, req *GenericExchangeNameRequest) (*GetExchangeOTPReponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetExchangeOTPCode(context.Context, *GenericExchangeNameRequest) (*GetExchangeOTPReponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetExchangeOTPCode not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetExchangeOTPCodes(ctx context.Context, req *GetExchangeOTPsRequest) (*GetExchangeOTPsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetExchangeOTPCodes(context.Context, *GetExchangeOTPsRequest) (*GetExchangeOTPsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetExchangeOTPCodes not implemented") } -func (*UnimplementedGoCryptoTraderServer) EnableExchange(ctx context.Context, req *GenericExchangeNameRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) EnableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method EnableExchange not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetTicker(ctx context.Context, req *GetTickerRequest) (*TickerResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetTicker(context.Context, *GetTickerRequest) (*TickerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetTicker not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetTickers(ctx context.Context, req *GetTickersRequest) (*GetTickersResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetTickers(context.Context, *GetTickersRequest) (*GetTickersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetTickers not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetOrderbook(ctx context.Context, req *GetOrderbookRequest) (*OrderbookResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetOrderbook(context.Context, *GetOrderbookRequest) (*OrderbookResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetOrderbook not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetOrderbooks(ctx context.Context, req *GetOrderbooksRequest) (*GetOrderbooksResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetOrderbooks(context.Context, *GetOrderbooksRequest) (*GetOrderbooksResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetOrderbooks not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetAccountInfo(ctx context.Context, req *GetAccountInfoRequest) (*GetAccountInfoResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetAccountInfo not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetAccountInfoStream(req *GetAccountInfoRequest, srv GoCryptoTrader_GetAccountInfoStreamServer) error { +func (*UnimplementedGoCryptoTraderServer) GetAccountInfoStream(*GetAccountInfoRequest, GoCryptoTrader_GetAccountInfoStreamServer) error { return status.Errorf(codes.Unimplemented, "method GetAccountInfoStream not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetConfig(ctx context.Context, req *GetConfigRequest) (*GetConfigResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetConfig not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetPortfolio(ctx context.Context, req *GetPortfolioRequest) (*GetPortfolioResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetPortfolio(context.Context, *GetPortfolioRequest) (*GetPortfolioResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetPortfolio not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetPortfolioSummary(ctx context.Context, req *GetPortfolioSummaryRequest) (*GetPortfolioSummaryResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetPortfolioSummary(context.Context, *GetPortfolioSummaryRequest) (*GetPortfolioSummaryResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetPortfolioSummary not implemented") } -func (*UnimplementedGoCryptoTraderServer) AddPortfolioAddress(ctx context.Context, req *AddPortfolioAddressRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) AddPortfolioAddress(context.Context, *AddPortfolioAddressRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AddPortfolioAddress not implemented") } -func (*UnimplementedGoCryptoTraderServer) RemovePortfolioAddress(ctx context.Context, req *RemovePortfolioAddressRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) RemovePortfolioAddress(context.Context, *RemovePortfolioAddressRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RemovePortfolioAddress not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetForexProviders(ctx context.Context, req *GetForexProvidersRequest) (*GetForexProvidersResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetForexProviders(context.Context, *GetForexProvidersRequest) (*GetForexProvidersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetForexProviders not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetForexRates(ctx context.Context, req *GetForexRatesRequest) (*GetForexRatesResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetForexRates(context.Context, *GetForexRatesRequest) (*GetForexRatesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetForexRates not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetOrders(ctx context.Context, req *GetOrdersRequest) (*GetOrdersResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetOrders not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetOrder(ctx context.Context, req *GetOrderRequest) (*OrderDetails, error) { +func (*UnimplementedGoCryptoTraderServer) GetOrder(context.Context, *GetOrderRequest) (*OrderDetails, error) { return nil, status.Errorf(codes.Unimplemented, "method GetOrder not implemented") } -func (*UnimplementedGoCryptoTraderServer) SubmitOrder(ctx context.Context, req *SubmitOrderRequest) (*SubmitOrderResponse, error) { +func (*UnimplementedGoCryptoTraderServer) SubmitOrder(context.Context, *SubmitOrderRequest) (*SubmitOrderResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SubmitOrder not implemented") } -func (*UnimplementedGoCryptoTraderServer) SimulateOrder(ctx context.Context, req *SimulateOrderRequest) (*SimulateOrderResponse, error) { +func (*UnimplementedGoCryptoTraderServer) SimulateOrder(context.Context, *SimulateOrderRequest) (*SimulateOrderResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SimulateOrder not implemented") } -func (*UnimplementedGoCryptoTraderServer) WhaleBomb(ctx context.Context, req *WhaleBombRequest) (*SimulateOrderResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WhaleBomb(context.Context, *WhaleBombRequest) (*SimulateOrderResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WhaleBomb not implemented") } -func (*UnimplementedGoCryptoTraderServer) CancelOrder(ctx context.Context, req *CancelOrderRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) CancelOrder(context.Context, *CancelOrderRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CancelOrder not implemented") } -func (*UnimplementedGoCryptoTraderServer) CancelAllOrders(ctx context.Context, req *CancelAllOrdersRequest) (*CancelAllOrdersResponse, error) { +func (*UnimplementedGoCryptoTraderServer) CancelAllOrders(context.Context, *CancelAllOrdersRequest) (*CancelAllOrdersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CancelAllOrders not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetEvents(ctx context.Context, req *GetEventsRequest) (*GetEventsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetEvents(context.Context, *GetEventsRequest) (*GetEventsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetEvents not implemented") } -func (*UnimplementedGoCryptoTraderServer) AddEvent(ctx context.Context, req *AddEventRequest) (*AddEventResponse, error) { +func (*UnimplementedGoCryptoTraderServer) AddEvent(context.Context, *AddEventRequest) (*AddEventResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AddEvent not implemented") } -func (*UnimplementedGoCryptoTraderServer) RemoveEvent(ctx context.Context, req *RemoveEventRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) RemoveEvent(context.Context, *RemoveEventRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RemoveEvent not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetCryptocurrencyDepositAddresses(ctx context.Context, req *GetCryptocurrencyDepositAddressesRequest) (*GetCryptocurrencyDepositAddressesResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetCryptocurrencyDepositAddresses(context.Context, *GetCryptocurrencyDepositAddressesRequest) (*GetCryptocurrencyDepositAddressesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetCryptocurrencyDepositAddresses not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetCryptocurrencyDepositAddress(ctx context.Context, req *GetCryptocurrencyDepositAddressRequest) (*GetCryptocurrencyDepositAddressResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetCryptocurrencyDepositAddress(context.Context, *GetCryptocurrencyDepositAddressRequest) (*GetCryptocurrencyDepositAddressResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetCryptocurrencyDepositAddress not implemented") } -func (*UnimplementedGoCryptoTraderServer) WithdrawFiatFunds(ctx context.Context, req *WithdrawFiatRequest) (*WithdrawResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WithdrawFiatFunds(context.Context, *WithdrawFiatRequest) (*WithdrawResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WithdrawFiatFunds not implemented") } -func (*UnimplementedGoCryptoTraderServer) WithdrawCryptocurrencyFunds(ctx context.Context, req *WithdrawCryptoRequest) (*WithdrawResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WithdrawCryptocurrencyFunds(context.Context, *WithdrawCryptoRequest) (*WithdrawResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WithdrawCryptocurrencyFunds not implemented") } -func (*UnimplementedGoCryptoTraderServer) WithdrawalEventByID(ctx context.Context, req *WithdrawalEventByIDRequest) (*WithdrawalEventByIDResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WithdrawalEventByID(context.Context, *WithdrawalEventByIDRequest) (*WithdrawalEventByIDResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventByID not implemented") } -func (*UnimplementedGoCryptoTraderServer) WithdrawalEventsByExchange(ctx context.Context, req *WithdrawalEventsByExchangeRequest) (*WithdrawalEventsByExchangeResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WithdrawalEventsByExchange(context.Context, *WithdrawalEventsByExchangeRequest) (*WithdrawalEventsByExchangeResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventsByExchange not implemented") } -func (*UnimplementedGoCryptoTraderServer) WithdrawalEventsByDate(ctx context.Context, req *WithdrawalEventsByDateRequest) (*WithdrawalEventsByExchangeResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WithdrawalEventsByDate(context.Context, *WithdrawalEventsByDateRequest) (*WithdrawalEventsByExchangeResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventsByDate not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetLoggerDetails(ctx context.Context, req *GetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetLoggerDetails(context.Context, *GetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetLoggerDetails not implemented") } -func (*UnimplementedGoCryptoTraderServer) SetLoggerDetails(ctx context.Context, req *SetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) SetLoggerDetails(context.Context, *SetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetLoggerDetails not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetExchangePairs(ctx context.Context, req *GetExchangePairsRequest) (*GetExchangePairsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetExchangePairs(context.Context, *GetExchangePairsRequest) (*GetExchangePairsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetExchangePairs not implemented") } -func (*UnimplementedGoCryptoTraderServer) SetExchangePair(ctx context.Context, req *SetExchangePairRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) SetExchangePair(context.Context, *SetExchangePairRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetExchangePair not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetOrderbookStream(req *GetOrderbookStreamRequest, srv GoCryptoTrader_GetOrderbookStreamServer) error { +func (*UnimplementedGoCryptoTraderServer) GetOrderbookStream(*GetOrderbookStreamRequest, GoCryptoTrader_GetOrderbookStreamServer) error { return status.Errorf(codes.Unimplemented, "method GetOrderbookStream not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetExchangeOrderbookStream(req *GetExchangeOrderbookStreamRequest, srv GoCryptoTrader_GetExchangeOrderbookStreamServer) error { +func (*UnimplementedGoCryptoTraderServer) GetExchangeOrderbookStream(*GetExchangeOrderbookStreamRequest, GoCryptoTrader_GetExchangeOrderbookStreamServer) error { return status.Errorf(codes.Unimplemented, "method GetExchangeOrderbookStream not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetTickerStream(req *GetTickerStreamRequest, srv GoCryptoTrader_GetTickerStreamServer) error { +func (*UnimplementedGoCryptoTraderServer) GetTickerStream(*GetTickerStreamRequest, GoCryptoTrader_GetTickerStreamServer) error { return status.Errorf(codes.Unimplemented, "method GetTickerStream not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetExchangeTickerStream(req *GetExchangeTickerStreamRequest, srv GoCryptoTrader_GetExchangeTickerStreamServer) error { +func (*UnimplementedGoCryptoTraderServer) GetExchangeTickerStream(*GetExchangeTickerStreamRequest, GoCryptoTrader_GetExchangeTickerStreamServer) error { return status.Errorf(codes.Unimplemented, "method GetExchangeTickerStream not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetAuditEvent(ctx context.Context, req *GetAuditEventRequest) (*GetAuditEventResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetAuditEvent(context.Context, *GetAuditEventRequest) (*GetAuditEventResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetAuditEvent not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptExecute(ctx context.Context, req *GCTScriptExecuteRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptExecute(context.Context, *GCTScriptExecuteRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptExecute not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptUpload(ctx context.Context, req *GCTScriptUploadRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptUpload(context.Context, *GCTScriptUploadRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptUpload not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptReadScript(ctx context.Context, req *GCTScriptReadScriptRequest) (*GCTScriptQueryResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptReadScript(context.Context, *GCTScriptReadScriptRequest) (*GCTScriptQueryResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptReadScript not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptStatus(ctx context.Context, req *GCTScriptStatusRequest) (*GCTScriptStatusResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptStatus(context.Context, *GCTScriptStatusRequest) (*GCTScriptStatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStatus not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptQuery(ctx context.Context, req *GCTScriptQueryRequest) (*GCTScriptQueryResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptQuery(context.Context, *GCTScriptQueryRequest) (*GCTScriptQueryResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptQuery not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptStop(ctx context.Context, req *GCTScriptStopRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptStop(context.Context, *GCTScriptStopRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStop not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptStopAll(ctx context.Context, req *GCTScriptStopAllRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptStopAll(context.Context, *GCTScriptStopAllRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStopAll not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptListAll(ctx context.Context, req *GCTScriptListAllRequest) (*GCTScriptStatusResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptListAll(context.Context, *GCTScriptListAllRequest) (*GCTScriptStatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptListAll not implemented") } -func (*UnimplementedGoCryptoTraderServer) GCTScriptAutoLoadToggle(ctx context.Context, req *GCTScriptAutoLoadRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GCTScriptAutoLoadToggle(context.Context, *GCTScriptAutoLoadRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GCTScriptAutoLoadToggle not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetHistoricCandles(ctx context.Context, req *GetHistoricCandlesRequest) (*GetHistoricCandlesResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetHistoricCandles(context.Context, *GetHistoricCandlesRequest) (*GetHistoricCandlesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetHistoricCandles not implemented") } -func (*UnimplementedGoCryptoTraderServer) SetExchangeAsset(ctx context.Context, req *SetExchangeAssetRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) SetExchangeAsset(context.Context, *SetExchangeAssetRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetExchangeAsset not implemented") } -func (*UnimplementedGoCryptoTraderServer) SetAllExchangePairs(ctx context.Context, req *SetExchangeAllPairsRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) SetAllExchangePairs(context.Context, *SetExchangeAllPairsRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetAllExchangePairs not implemented") } -func (*UnimplementedGoCryptoTraderServer) UpdateExchangeSupportedPairs(ctx context.Context, req *UpdateExchangeSupportedPairsRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) UpdateExchangeSupportedPairs(context.Context, *UpdateExchangeSupportedPairsRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateExchangeSupportedPairs not implemented") } -func (*UnimplementedGoCryptoTraderServer) GetExchangeAssets(ctx context.Context, req *GetExchangeAssetsRequest) (*GetExchangeAssetsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) GetExchangeAssets(context.Context, *GetExchangeAssetsRequest) (*GetExchangeAssetsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetExchangeAssets not implemented") } -func (*UnimplementedGoCryptoTraderServer) WebsocketGetInfo(ctx context.Context, req *WebsocketGetInfoRequest) (*WebsocketGetInfoResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WebsocketGetInfo(context.Context, *WebsocketGetInfoRequest) (*WebsocketGetInfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WebsocketGetInfo not implemented") } -func (*UnimplementedGoCryptoTraderServer) WebsocketSetEnabled(ctx context.Context, req *WebsocketSetEnabledRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WebsocketSetEnabled(context.Context, *WebsocketSetEnabledRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetEnabled not implemented") } -func (*UnimplementedGoCryptoTraderServer) WebsocketGetSubscriptions(ctx context.Context, req *WebsocketGetSubscriptionsRequest) (*WebsocketGetSubscriptionsResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WebsocketGetSubscriptions(context.Context, *WebsocketGetSubscriptionsRequest) (*WebsocketGetSubscriptionsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WebsocketGetSubscriptions not implemented") } -func (*UnimplementedGoCryptoTraderServer) WebsocketSetProxy(ctx context.Context, req *WebsocketSetProxyRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WebsocketSetProxy(context.Context, *WebsocketSetProxyRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetProxy not implemented") } -func (*UnimplementedGoCryptoTraderServer) WebsocketSetURL(ctx context.Context, req *WebsocketSetURLRequest) (*GenericResponse, error) { +func (*UnimplementedGoCryptoTraderServer) WebsocketSetURL(context.Context, *WebsocketSetURLRequest) (*GenericResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetURL not implemented") } diff --git a/gctrpc/rpc.pb.gw.go b/gctrpc/rpc.pb.gw.go index ae8bcfd6..6db69625 100644 --- a/gctrpc/rpc.pb.gw.go +++ b/gctrpc/rpc.pb.gw.go @@ -91,7 +91,10 @@ func local_request_GoCryptoTrader_EnableSubsystem_0(ctx context.Context, marshal var protoReq GenericSubsystemRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_EnableSubsystem_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_EnableSubsystem_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -124,7 +127,10 @@ func local_request_GoCryptoTrader_DisableSubsystem_0(ctx context.Context, marsha var protoReq GenericSubsystemRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_DisableSubsystem_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_DisableSubsystem_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -193,7 +199,10 @@ func local_request_GoCryptoTrader_GetExchanges_0(ctx context.Context, marshaler var protoReq GetExchangesRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GetExchanges_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GetExchanges_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -260,7 +269,10 @@ func local_request_GoCryptoTrader_GetExchangeInfo_0(ctx context.Context, marshal var protoReq GenericExchangeNameRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GetExchangeInfo_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GetExchangeInfo_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -293,7 +305,10 @@ func local_request_GoCryptoTrader_GetExchangeOTPCode_0(ctx context.Context, mars var protoReq GenericExchangeNameRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GetExchangeOTPCode_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GetExchangeOTPCode_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -482,7 +497,10 @@ func local_request_GoCryptoTrader_GetAccountInfo_0(ctx context.Context, marshale var protoReq GetAccountInfoRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GetAccountInfo_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GetAccountInfo_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1263,7 +1281,10 @@ func local_request_GoCryptoTrader_GetLoggerDetails_0(ctx context.Context, marsha var protoReq GetLoggerDetailsRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GetLoggerDetails_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GetLoggerDetails_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1510,7 +1531,10 @@ func local_request_GoCryptoTrader_GetAuditEvent_0(ctx context.Context, marshaler var protoReq GetAuditEventRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GetAuditEvent_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GetAuditEvent_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1543,7 +1567,10 @@ func local_request_GoCryptoTrader_GCTScriptExecute_0(ctx context.Context, marsha var protoReq GCTScriptExecuteRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GCTScriptExecute_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GCTScriptExecute_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1662,7 +1689,10 @@ func local_request_GoCryptoTrader_GCTScriptQuery_0(ctx context.Context, marshale var protoReq GCTScriptQueryRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GCTScriptQuery_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GCTScriptQuery_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1831,7 +1861,10 @@ func local_request_GoCryptoTrader_GetHistoricCandles_0(ctx context.Context, mars var protoReq GetHistoricCandlesRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GetHistoricCandles_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GetHistoricCandles_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1864,7 +1897,10 @@ func local_request_GoCryptoTrader_SetExchangeAsset_0(ctx context.Context, marsha var protoReq SetExchangeAssetRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_SetExchangeAsset_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_SetExchangeAsset_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1897,7 +1933,10 @@ func local_request_GoCryptoTrader_SetAllExchangePairs_0(ctx context.Context, mar var protoReq SetExchangeAllPairsRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_SetAllExchangePairs_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_SetAllExchangePairs_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1930,7 +1969,10 @@ func local_request_GoCryptoTrader_UpdateExchangeSupportedPairs_0(ctx context.Con var protoReq UpdateExchangeSupportedPairsRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_UpdateExchangeSupportedPairs_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_UpdateExchangeSupportedPairs_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1963,7 +2005,10 @@ func local_request_GoCryptoTrader_GetExchangeAssets_0(ctx context.Context, marsh var protoReq GetExchangeAssetsRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_GetExchangeAssets_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_GetExchangeAssets_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -1996,7 +2041,10 @@ func local_request_GoCryptoTrader_WebsocketGetInfo_0(ctx context.Context, marsha var protoReq WebsocketGetInfoRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_WebsocketGetInfo_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_WebsocketGetInfo_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -2029,7 +2077,10 @@ func local_request_GoCryptoTrader_WebsocketSetEnabled_0(ctx context.Context, mar var protoReq WebsocketSetEnabledRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_WebsocketSetEnabled_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_WebsocketSetEnabled_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -2062,7 +2113,10 @@ func local_request_GoCryptoTrader_WebsocketGetSubscriptions_0(ctx context.Contex var protoReq WebsocketGetSubscriptionsRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_WebsocketGetSubscriptions_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_WebsocketGetSubscriptions_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -2095,7 +2149,10 @@ func local_request_GoCryptoTrader_WebsocketSetProxy_0(ctx context.Context, marsh var protoReq WebsocketSetProxyRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_WebsocketSetProxy_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_WebsocketSetProxy_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } @@ -2128,7 +2185,10 @@ func local_request_GoCryptoTrader_WebsocketSetURL_0(ctx context.Context, marshal var protoReq WebsocketSetURLRequest var metadata runtime.ServerMetadata - if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_GoCryptoTrader_WebsocketSetURL_0); err != nil { + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GoCryptoTrader_WebsocketSetURL_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } diff --git a/gctrpc/rpc.proto b/gctrpc/rpc.proto index fe9292ce..cc993553 100644 --- a/gctrpc/rpc.proto +++ b/gctrpc/rpc.proto @@ -596,6 +596,8 @@ message GetHistoricCandlesRequest { int64 end = 5; int64 time_interval = 6; bool ex_request = 7; + bool sync = 8; + bool use_db = 9; } message GetHistoricCandlesResponse { diff --git a/gctrpc/rpc.swagger.json b/gctrpc/rpc.swagger.json index 45b0f0f6..a20e911e 100644 --- a/gctrpc/rpc.swagger.json +++ b/gctrpc/rpc.swagger.json @@ -13,7 +13,7 @@ "paths": { "/v1/addevent": { "post": { - "operationId": "AddEvent", + "operationId": "GoCryptoTrader_AddEvent", "responses": { "200": { "description": "A successful response.", @@ -45,7 +45,7 @@ }, "/v1/addportfolioaddress": { "post": { - "operationId": "AddPortfolioAddress", + "operationId": "GoCryptoTrader_AddPortfolioAddress", "responses": { "200": { "description": "A successful response.", @@ -77,7 +77,7 @@ }, "/v1/cancelallorders": { "post": { - "operationId": "CancelAllOrders", + "operationId": "GoCryptoTrader_CancelAllOrders", "responses": { "200": { "description": "A successful response.", @@ -109,7 +109,7 @@ }, "/v1/cancelorder": { "post": { - "operationId": "CancelOrder", + "operationId": "GoCryptoTrader_CancelOrder", "responses": { "200": { "description": "A successful response.", @@ -141,7 +141,7 @@ }, "/v1/disableexchange": { "post": { - "operationId": "DisableExchange", + "operationId": "GoCryptoTrader_DisableExchange", "responses": { "200": { "description": "A successful response.", @@ -173,7 +173,7 @@ }, "/v1/disablesubsystem": { "get": { - "operationId": "DisableSubsystem", + "operationId": "GoCryptoTrader_DisableSubsystem", "responses": { "200": { "description": "A successful response.", @@ -203,7 +203,7 @@ }, "/v1/enableexchange": { "post": { - "operationId": "EnableExchange", + "operationId": "GoCryptoTrader_EnableExchange", "responses": { "200": { "description": "A successful response.", @@ -235,7 +235,7 @@ }, "/v1/enablesubsystem": { "get": { - "operationId": "EnableSubsystem", + "operationId": "GoCryptoTrader_EnableSubsystem", "responses": { "200": { "description": "A successful response.", @@ -265,7 +265,7 @@ }, "/v1/gctscript/autoload": { "post": { - "operationId": "GCTScriptAutoLoadToggle", + "operationId": "GoCryptoTrader_GCTScriptAutoLoadToggle", "responses": { "200": { "description": "A successful response.", @@ -297,7 +297,7 @@ }, "/v1/gctscript/execute": { "get": { - "operationId": "GCTScriptExecute", + "operationId": "GoCryptoTrader_GCTScriptExecute", "responses": { "200": { "description": "A successful response.", @@ -345,7 +345,7 @@ }, "/v1/gctscript/query": { "get": { - "operationId": "GCTScriptQuery", + "operationId": "GoCryptoTrader_GCTScriptQuery", "responses": { "200": { "description": "A successful response.", @@ -393,7 +393,7 @@ }, "/v1/gctscript/read": { "post": { - "operationId": "GCTScriptReadScript", + "operationId": "GoCryptoTrader_GCTScriptReadScript", "responses": { "200": { "description": "A successful response.", @@ -425,7 +425,7 @@ }, "/v1/gctscript/status": { "get": { - "operationId": "GCTScriptStatus", + "operationId": "GoCryptoTrader_GCTScriptStatus", "responses": { "200": { "description": "A successful response.", @@ -447,7 +447,7 @@ }, "/v1/gctscript/stop": { "post": { - "operationId": "GCTScriptListAll", + "operationId": "GoCryptoTrader_GCTScriptListAll", "responses": { "200": { "description": "A successful response.", @@ -479,7 +479,7 @@ }, "/v1/gctscript/upload": { "post": { - "operationId": "GCTScriptUpload", + "operationId": "GoCryptoTrader_GCTScriptUpload", "responses": { "200": { "description": "A successful response.", @@ -511,7 +511,7 @@ }, "/v1/getaccountinfo": { "get": { - "operationId": "GetAccountInfo", + "operationId": "GoCryptoTrader_GetAccountInfo", "responses": { "200": { "description": "A successful response.", @@ -541,7 +541,7 @@ }, "/v1/getaccountinfostream": { "get": { - "operationId": "GetAccountInfoStream", + "operationId": "GoCryptoTrader_GetAccountInfoStream", "responses": { "200": { "description": "A successful response.(streaming responses)", @@ -580,7 +580,7 @@ }, "/v1/getauditevent": { "get": { - "operationId": "GetAuditEvent", + "operationId": "GoCryptoTrader_GetAuditEvent", "responses": { "200": { "description": "A successful response.", @@ -636,7 +636,7 @@ }, "/v1/getcommunicationrelayers": { "get": { - "operationId": "GetCommunicationRelayers", + "operationId": "GoCryptoTrader_GetCommunicationRelayers", "responses": { "200": { "description": "A successful response.", @@ -658,7 +658,7 @@ }, "/v1/getconfig": { "get": { - "operationId": "GetConfig", + "operationId": "GoCryptoTrader_GetConfig", "responses": { "200": { "description": "A successful response.", @@ -680,7 +680,7 @@ }, "/v1/getcryptodepositaddress": { "post": { - "operationId": "GetCryptocurrencyDepositAddress", + "operationId": "GoCryptoTrader_GetCryptocurrencyDepositAddress", "responses": { "200": { "description": "A successful response.", @@ -712,7 +712,7 @@ }, "/v1/getcryptodepositaddresses": { "post": { - "operationId": "GetCryptocurrencyDepositAddresses", + "operationId": "GoCryptoTrader_GetCryptocurrencyDepositAddresses", "responses": { "200": { "description": "A successful response.", @@ -744,7 +744,7 @@ }, "/v1/getevents": { "get": { - "operationId": "GetEvents", + "operationId": "GoCryptoTrader_GetEvents", "responses": { "200": { "description": "A successful response.", @@ -766,7 +766,7 @@ }, "/v1/getexchangeassets": { "get": { - "operationId": "GetExchangeAssets", + "operationId": "GoCryptoTrader_GetExchangeAssets", "responses": { "200": { "description": "A successful response.", @@ -796,7 +796,7 @@ }, "/v1/getexchangeinfo": { "get": { - "operationId": "GetExchangeInfo", + "operationId": "GoCryptoTrader_GetExchangeInfo", "responses": { "200": { "description": "A successful response.", @@ -826,7 +826,7 @@ }, "/v1/getexchangeorderbookstream": { "get": { - "operationId": "GetExchangeOrderbookStream", + "operationId": "GoCryptoTrader_GetExchangeOrderbookStream", "responses": { "200": { "description": "A successful response.(streaming responses)", @@ -865,7 +865,7 @@ }, "/v1/getexchangeotp": { "get": { - "operationId": "GetExchangeOTPCode", + "operationId": "GoCryptoTrader_GetExchangeOTPCode", "responses": { "200": { "description": "A successful response.", @@ -895,7 +895,7 @@ }, "/v1/getexchangeotps": { "get": { - "operationId": "GetExchangeOTPCodes", + "operationId": "GoCryptoTrader_GetExchangeOTPCodes", "responses": { "200": { "description": "A successful response.", @@ -917,7 +917,7 @@ }, "/v1/getexchangepairs": { "post": { - "operationId": "GetExchangePairs", + "operationId": "GoCryptoTrader_GetExchangePairs", "responses": { "200": { "description": "A successful response.", @@ -949,7 +949,7 @@ }, "/v1/getexchanges": { "get": { - "operationId": "GetExchanges", + "operationId": "GoCryptoTrader_GetExchanges", "responses": { "200": { "description": "A successful response.", @@ -980,7 +980,7 @@ }, "/v1/getexchangetickerstream": { "get": { - "operationId": "GetExchangeTickerStream", + "operationId": "GoCryptoTrader_GetExchangeTickerStream", "responses": { "200": { "description": "A successful response.(streaming responses)", @@ -1019,7 +1019,7 @@ }, "/v1/getforexproviders": { "get": { - "operationId": "GetForexProviders", + "operationId": "GoCryptoTrader_GetForexProviders", "responses": { "200": { "description": "A successful response.", @@ -1041,7 +1041,7 @@ }, "/v1/getforexrates": { "get": { - "operationId": "GetForexRates", + "operationId": "GoCryptoTrader_GetForexRates", "responses": { "200": { "description": "A successful response.", @@ -1063,7 +1063,7 @@ }, "/v1/gethistoriccandles": { "get": { - "operationId": "GetHistoricCandles", + "operationId": "GoCryptoTrader_GetHistoricCandles", "responses": { "200": { "description": "A successful response.", @@ -1136,6 +1136,20 @@ "required": false, "type": "boolean", "format": "boolean" + }, + { + "name": "sync", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + }, + { + "name": "use_db", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" } ], "tags": [ @@ -1145,7 +1159,7 @@ }, "/v1/getinfo": { "get": { - "operationId": "GetInfo", + "operationId": "GoCryptoTrader_GetInfo", "responses": { "200": { "description": "A successful response.", @@ -1167,7 +1181,7 @@ }, "/v1/getloggerdetails": { "get": { - "operationId": "GetLoggerDetails", + "operationId": "GoCryptoTrader_GetLoggerDetails", "responses": { "200": { "description": "A successful response.", @@ -1197,7 +1211,7 @@ }, "/v1/getorder": { "post": { - "operationId": "GetOrder", + "operationId": "GoCryptoTrader_GetOrder", "responses": { "200": { "description": "A successful response.", @@ -1229,7 +1243,7 @@ }, "/v1/getorderbook": { "post": { - "operationId": "GetOrderbook", + "operationId": "GoCryptoTrader_GetOrderbook", "responses": { "200": { "description": "A successful response.", @@ -1261,7 +1275,7 @@ }, "/v1/getorderbooks": { "get": { - "operationId": "GetOrderbooks", + "operationId": "GoCryptoTrader_GetOrderbooks", "responses": { "200": { "description": "A successful response.", @@ -1283,7 +1297,7 @@ }, "/v1/getorderbookstream": { "get": { - "operationId": "GetOrderbookStream", + "operationId": "GoCryptoTrader_GetOrderbookStream", "responses": { "200": { "description": "A successful response.(streaming responses)", @@ -1346,7 +1360,7 @@ }, "/v1/getorders": { "post": { - "operationId": "GetOrders", + "operationId": "GoCryptoTrader_GetOrders", "responses": { "200": { "description": "A successful response.", @@ -1378,7 +1392,7 @@ }, "/v1/getportfolio": { "get": { - "operationId": "GetPortfolio", + "operationId": "GoCryptoTrader_GetPortfolio", "responses": { "200": { "description": "A successful response.", @@ -1400,7 +1414,7 @@ }, "/v1/getportfoliosummary": { "get": { - "operationId": "GetPortfolioSummary", + "operationId": "GoCryptoTrader_GetPortfolioSummary", "responses": { "200": { "description": "A successful response.", @@ -1422,7 +1436,7 @@ }, "/v1/getrpcendpoints": { "get": { - "operationId": "GetRPCEndpoints", + "operationId": "GoCryptoTrader_GetRPCEndpoints", "responses": { "200": { "description": "A successful response.", @@ -1444,7 +1458,7 @@ }, "/v1/getsubsystems": { "get": { - "operationId": "GetSubsystems", + "operationId": "GoCryptoTrader_GetSubsystems", "responses": { "200": { "description": "A successful response.", @@ -1466,7 +1480,7 @@ }, "/v1/getticker": { "post": { - "operationId": "GetTicker", + "operationId": "GoCryptoTrader_GetTicker", "responses": { "200": { "description": "A successful response.", @@ -1498,7 +1512,7 @@ }, "/v1/gettickers": { "get": { - "operationId": "GetTickers", + "operationId": "GoCryptoTrader_GetTickers", "responses": { "200": { "description": "A successful response.", @@ -1520,7 +1534,7 @@ }, "/v1/gettickerstream": { "get": { - "operationId": "GetTickerStream", + "operationId": "GoCryptoTrader_GetTickerStream", "responses": { "200": { "description": "A successful response.(streaming responses)", @@ -1583,7 +1597,7 @@ }, "/v1/removeevent": { "post": { - "operationId": "RemoveEvent", + "operationId": "GoCryptoTrader_RemoveEvent", "responses": { "200": { "description": "A successful response.", @@ -1615,7 +1629,7 @@ }, "/v1/removeportfolioaddress": { "post": { - "operationId": "RemovePortfolioAddress", + "operationId": "GoCryptoTrader_RemovePortfolioAddress", "responses": { "200": { "description": "A successful response.", @@ -1647,7 +1661,7 @@ }, "/v1/setallexchangepairs": { "get": { - "operationId": "SetAllExchangePairs", + "operationId": "GoCryptoTrader_SetAllExchangePairs", "responses": { "200": { "description": "A successful response.", @@ -1684,7 +1698,7 @@ }, "/v1/setexchangeasset": { "get": { - "operationId": "SetExchangeAsset", + "operationId": "GoCryptoTrader_SetExchangeAsset", "responses": { "200": { "description": "A successful response.", @@ -1727,7 +1741,7 @@ }, "/v1/setexchangepair": { "post": { - "operationId": "SetExchangePair", + "operationId": "GoCryptoTrader_SetExchangePair", "responses": { "200": { "description": "A successful response.", @@ -1759,7 +1773,7 @@ }, "/v1/setloggerdetails": { "post": { - "operationId": "SetLoggerDetails", + "operationId": "GoCryptoTrader_SetLoggerDetails", "responses": { "200": { "description": "A successful response.", @@ -1791,7 +1805,7 @@ }, "/v1/simulateorder": { "post": { - "operationId": "SimulateOrder", + "operationId": "GoCryptoTrader_SimulateOrder", "responses": { "200": { "description": "A successful response.", @@ -1823,7 +1837,7 @@ }, "/v1/submitorder": { "post": { - "operationId": "SubmitOrder", + "operationId": "GoCryptoTrader_SubmitOrder", "responses": { "200": { "description": "A successful response.", @@ -1855,7 +1869,7 @@ }, "/v1/updateexchangesupportedpairs": { "get": { - "operationId": "UpdateExchangeSupportedPairs", + "operationId": "GoCryptoTrader_UpdateExchangeSupportedPairs", "responses": { "200": { "description": "A successful response.", @@ -1885,7 +1899,7 @@ }, "/v1/websocketgetinfo": { "get": { - "operationId": "WebsocketGetInfo", + "operationId": "GoCryptoTrader_WebsocketGetInfo", "responses": { "200": { "description": "A successful response.", @@ -1915,7 +1929,7 @@ }, "/v1/websocketgetsubscriptions": { "get": { - "operationId": "WebsocketGetSubscriptions", + "operationId": "GoCryptoTrader_WebsocketGetSubscriptions", "responses": { "200": { "description": "A successful response.", @@ -1945,7 +1959,7 @@ }, "/v1/websocketsetenabled": { "get": { - "operationId": "WebsocketSetEnabled", + "operationId": "GoCryptoTrader_WebsocketSetEnabled", "responses": { "200": { "description": "A successful response.", @@ -1982,7 +1996,7 @@ }, "/v1/websocketsetproxy": { "get": { - "operationId": "WebsocketSetProxy", + "operationId": "GoCryptoTrader_WebsocketSetProxy", "responses": { "200": { "description": "A successful response.", @@ -2018,7 +2032,7 @@ }, "/v1/websocketseturl": { "get": { - "operationId": "WebsocketSetURL", + "operationId": "GoCryptoTrader_WebsocketSetURL", "responses": { "200": { "description": "A successful response.", @@ -2054,7 +2068,7 @@ }, "/v1/whalebomb": { "post": { - "operationId": "WhaleBomb", + "operationId": "GoCryptoTrader_WhaleBomb", "responses": { "200": { "description": "A successful response.", @@ -2086,7 +2100,7 @@ }, "/v1/withdrawaleventbydate": { "post": { - "operationId": "WithdrawalEventsByDate", + "operationId": "GoCryptoTrader_WithdrawalEventsByDate", "responses": { "200": { "description": "A successful response.", @@ -2118,7 +2132,7 @@ }, "/v1/withdrawaleventbyid": { "post": { - "operationId": "WithdrawalEventsByExchange", + "operationId": "GoCryptoTrader_WithdrawalEventsByExchange", "responses": { "200": { "description": "A successful response.", @@ -2150,7 +2164,7 @@ }, "/v1/withdrawfiatfunds": { "post": { - "operationId": "WithdrawFiatFunds", + "operationId": "GoCryptoTrader_WithdrawFiatFunds", "responses": { "200": { "description": "A successful response.", @@ -2182,7 +2196,7 @@ }, "/v1/withdrawithdrawcryptofundswfiatfunds": { "post": { - "operationId": "WithdrawCryptocurrencyFunds", + "operationId": "GoCryptoTrader_WithdrawCryptocurrencyFunds", "responses": { "200": { "description": "A successful response.", diff --git a/gctscript/modules/gct/exchange.go b/gctscript/modules/gct/exchange.go index c108f30c..f19f500a 100644 --- a/gctscript/modules/gct/exchange.go +++ b/gctscript/modules/gct/exchange.go @@ -575,7 +575,7 @@ func exchangeOHLCV(args ...objects.Object) (objects.Object, error) { var candles objects.Array for x := range ret.Candles { candle := &objects.Array{} - candle.Value = append(candle.Value, &objects.Time{Value: ret.Candles[x].Time}, + candle.Value = append(candle.Value, &objects.Int{Value: ret.Candles[x].Time.Unix()}, &objects.Float{Value: ret.Candles[x].Open}, &objects.Float{Value: ret.Candles[x].High}, &objects.Float{Value: ret.Candles[x].Low}, diff --git a/gctscript/wrappers/gct/exchange/exchange.go b/gctscript/wrappers/gct/exchange/exchange.go index b46996e6..64300a2c 100644 --- a/gctscript/wrappers/gct/exchange/exchange.go +++ b/gctscript/wrappers/gct/exchange/exchange.go @@ -222,7 +222,7 @@ func (e Exchange) OHLCV(exch string, pair currency.Pair, item asset.Item, start, if err != nil { return kline.Item{}, err } - ret, err := ex.GetHistoricCandles(pair, item, start, end, interval) + ret, err := ex.GetHistoricCandlesExtended(pair, item, start, end, interval) if err != nil { return kline.Item{}, err } @@ -231,5 +231,7 @@ func (e Exchange) OHLCV(exch string, pair currency.Pair, item asset.Item, start, return ret.Candles[i].Time.Before(ret.Candles[j].Time) }) + ret.FormatDates() + return ret, nil } diff --git a/go.mod b/go.mod index 89981dc2..8da3ebdc 100644 --- a/go.mod +++ b/go.mod @@ -32,6 +32,7 @@ require ( github.com/thrasher-corp/sqlboiler v1.0.1-0.20191001234224-71e17f37a85e github.com/toorop/go-pusher v0.0.0-20180521062818-4521e2eb39fb github.com/urfave/cli v1.22.4 + github.com/urfave/cli/v2 v2.2.0 github.com/volatiletech/inflect v0.0.1 // indirect github.com/volatiletech/null v8.0.0+incompatible github.com/volatiletech/sqlboiler v3.7.1+incompatible // indirect @@ -41,6 +42,7 @@ require ( google.golang.org/genproto v0.0.0-20200806141610-86f49bd18e98 google.golang.org/grpc v1.31.1 google.golang.org/grpc/examples v0.0.0-20200825214159-c4ba4cc6af4a // indirect + google.golang.org/protobuf v1.25.0 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect gopkg.in/ini.v1 v1.60.0 // indirect gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 // indirect diff --git a/go.sum b/go.sum index 18f37583..4b5bed52 100644 --- a/go.sum +++ b/go.sum @@ -93,6 +93,7 @@ github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymF github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/ericlagergren/decimal v0.0.0-20180907214518-0bb163153a5d h1:v7ysy5ZQGOuSI0wr0Wgk/b9FPD3Jv1arYX4V9xR6pl4= github.com/ericlagergren/decimal v0.0.0-20180907214518-0bb163153a5d/go.mod h1:1yj25TwtUlJ+pfOu9apAVaM1RWfZGg+aFpd4hPQZekQ= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/friendsofgo/errors v0.9.2 h1:X6NYxef4efCBdwI7BgS820zFaN7Cphrmb+Pljdzjtgk= @@ -240,8 +241,6 @@ github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzR github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mattn/go-sqlite3 v1.14.1 h1:AHx9Ra40wIzl+GelgX2X6AWxmT5tfxhI1PL0523HcSw= -github.com/mattn/go-sqlite3 v1.14.1/go.mod h1:JIl7NbARA7phWnGvh0LKTyg7S9BA+6gx71ShQilpsus= github.com/mattn/go-sqlite3 v1.14.2 h1:A2EQLwjYf/hfYaM20FVjs1UewCTTFR7RmjEHkLjldIA= github.com/mattn/go-sqlite3 v1.14.2/go.mod h1:JIl7NbARA7phWnGvh0LKTyg7S9BA+6gx71ShQilpsus= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= @@ -355,6 +354,8 @@ github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGr github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= github.com/urfave/cli v1.22.4 h1:u7tSpNPPswAFymm8IehJhy4uJMlUuU/GmqSkvJ1InXA= github.com/urfave/cli v1.22.4/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= +github.com/urfave/cli/v2 v2.2.0 h1:JTTnM6wKzdA0Jqodd966MVj4vWbbquZykeX1sKbe2C4= +github.com/urfave/cli/v2 v2.2.0/go.mod h1:SE9GqnLQmjVa0iPEY0f1w3ygNIYcIJ0OKPMoW2caLfQ= github.com/volatiletech/inflect v0.0.0-20170731032912-e7201282ae8d h1:gI4/tqP6lCY5k6Sg+4k9qSoBXmPwG+xXgMpK7jivD4M= github.com/volatiletech/inflect v0.0.0-20170731032912-e7201282ae8d/go.mod h1:jspfvgf53t5NLUT4o9L1IX0kIBNKamGq1tWc/MgWK9Q= github.com/volatiletech/inflect v0.0.1 h1:2a6FcMQyhmPZcLa+uet3VJ8gLn/9svWhJxJYwvE8KsU= diff --git a/portfolio/withdraw/withdraw_types.go b/portfolio/withdraw/withdraw_types.go index 5d5522d3..14e41483 100644 --- a/portfolio/withdraw/withdraw_types.go +++ b/portfolio/withdraw/withdraw_types.go @@ -112,6 +112,7 @@ type Response struct { // ExchangeResponse holds information returned from an exchange type ExchangeResponse struct { Name string `json:"name"` + UUID uuid.UUID ID string `json:"id"` Status string `json:"status"` } diff --git a/testdata/binance_BTCUSDT_24h_2019_01_01_2020_01_01.csv b/testdata/binance_BTCUSDT_24h_2019_01_01_2020_01_01.csv new file mode 100644 index 00000000..7248eedb --- /dev/null +++ b/testdata/binance_BTCUSDT_24h_2019_01_01_2020_01_01.csv @@ -0,0 +1,365 @@ +1546300800,23741.687033,3701.23,3797.14,3642,3797.14 +1546387200,35156.463369,3796.45,3858.56,3750.45,3858.56 +1546473600,29406.948359,3857.57,3766.78,3730,3766.78 +1546560000,29519.554671,3767.2,3792.01,3703.57,3792.01 +1546646400,30490.667751,3790.09,3770.96,3751,3770.96 +1546732800,36553.806709,3771.12,3987.6,3740,3987.6 +1546819200,31869.846264,3987.62,3975.45,3921.53,3975.45 +1546905600,38901.423122,3976.76,3955.13,3903,3955.13 +1546992000,28989.439511,3955.45,3966.65,3930.04,3966.65 +1547078400,59402.22851,3966.06,3585.88,3540,3585.88 +1547164800,38338.654733,3585.88,3601.31,3465,3601.31 +1547251200,21999.928354,3601.31,3583.13,3530,3583.13 +1547337600,26385.757454,3584.1,3476.81,3441.3,3476.81 +1547424000,35235.211215,3477.56,3626.09,3467.02,3626.09 +1547510400,34137.997459,3626.08,3553.06,3516.62,3553.06 +1547596800,27480.179977,3553.06,3591.84,3543.51,3591.84 +1547683200,29755.440838,3591.84,3616.21,3530.39,3616.21 +1547769600,22713.446755,3613.32,3594.87,3565.75,3594.87 +1547856000,22171.578123,3594.87,3665.3,3594.23,3665.3 +1547942400,27901.938598,3665.75,3539.28,3475,3539.28 +1548028800,19644.436839,3539.26,3526.9,3475.5,3526.9 +1548115200,29336.442967,3526.88,3570.93,3434.85,3570.93 +1548201600,24938.842698,3570.41,3552.82,3514.5,3552.82 +1548288000,20826.25118,3552.97,3569.62,3529.22,3569.62 +1548374400,17608.346671,3569.07,3565.29,3522.51,3565.29 +1548460800,19476.532344,3566.69,3565.25,3545,3565.25 +1548547200,22735.598162,3565.62,3550.84,3486,3550.84 +1548633600,40405.111401,3550.05,3434.15,3380.27,3434.15 +1548720000,29544.928977,3434,3411.04,3349.92,3411.04 +1548806400,23968.260243,3410.04,3458.18,3387.1,3458.18 +1548892800,29607.190253,3457.5,3434.1,3418.8,3434.1 +1548979200,25260.476159,3434.1,3462.07,3401.2,3462.07 +1549065600,17920.802,3462.2,3504.77,3440.29,3504.77 +1549152000,19867.33639,3504.06,3458.11,3426,3458.11 +1549238400,23131.981108,3458.11,3463.22,3433.31,3463.22 +1549324800,25264.41503,3463.22,3471.59,3448.43,3471.59 +1549411200,35310.244846,3471.57,3405.37,3380,3405.37 +1549497600,18665.538638,3407,3398.4,3390,3398.4 +1549584000,47968.058013,3398.4,3659.04,3373.1,3659.04 +1549670400,24759.833719,3660.27,3665.18,3625.13,3665.18 +1549756800,23250.602634,3665.18,3680.06,3609.76,3680.06 +1549843200,24954.614571,3679.75,3631.05,3615.53,3631.05 +1549929600,29479.59823,3631.05,3631.46,3582.34,3631.46 +1550016000,25773.997648,3631.51,3609.4,3591.75,3609.4 +1550102400,21753.501261,3608.34,3590.56,3568.11,3590.56 +1550188800,20777.872899,3590.57,3602.47,3573.45,3602.47 +1550275200,19565.992751,3602.49,3618.41,3597.91,3618.41 +1550361600,25690.227779,3617.22,3667.58,3604.4,3667.58 +1550448000,64042.730492,3667.62,3898.6,3655,3898.6 +1550534400,50207.172667,3897.35,3907.79,3856,3907.79 +1550620800,36205.14085,3907.35,3969.74,3870.66,3969.74 +1550707200,31103.884728,3969.74,3937.31,3901.03,3937.31 +1550793600,23943.16375,3937.31,3962,3926.65,3962 +1550880000,33657.942883,3962,4117.76,3933.15,4117.76 +1550966400,62224.18689,4118,3743.56,3712.66,3743.56 +1551052800,38102.966245,3743.56,3827.92,3740,3827.92 +1551139200,28838.748036,3828.44,3809.23,3777,3809.23 +1551225600,31500.995466,3809.31,3818.07,3677.17,3818.07 +1551312000,32561.961044,3818.04,3813.69,3763.87,3813.69 +1551398400,23174.57217,3814.26,3823,3813.01,3823 +1551484800,19445.838355,3822.17,3819.93,3772.25,3819.93 +1551571200,16718.16541,3819.97,3807.75,3781.32,3807.75 +1551657600,34742.84166,3807.32,3715.3,3670.69,3715.3 +1551744000,32962.536162,3716.1,3857.73,3703.55,3857.73 +1551830400,24775.11883,3857.58,3861.84,3813.09,3861.84 +1551916800,26455.257661,3861.84,3873.64,3840.4,3873.64 +1552003200,34730.366592,3873.63,3864.89,3800,3864.89 +1552089600,30979.747653,3864.88,3943.04,3854.75,3943.04 +1552176000,23187.561412,3943.43,3916.82,3881.69,3916.82 +1552262400,38066.885705,3915.99,3871.61,3830,3871.61 +1552348800,26921.008622,3871.61,3882.73,3826.06,3882.73 +1552435200,24461.008757,3882.69,3866,3840,3866 +1552521600,27048.74853,3866,3877.12,3810.43,3877.12 +1552608000,21740.061498,3877.12,3923.76,3872.2,3923.76 +1552694400,28568.376124,3924.46,4005.98,3921.98,4005.98 +1552780800,18814.255577,4005.98,3981.14,3950.01,3981.14 +1552867200,22454.47801,3981.85,3987.81,3953.33,3987.81 +1552953600,19893.741815,3987.83,4015.53,3970,4015.53 +1553040000,23432.300255,4017.48,4043.04,3980.5,4043.04 +1553126400,35997.682119,4043.04,3980.64,3880.01,3980.64 +1553212800,20022.606318,3980.85,3986.93,3968.25,3986.93 +1553299200,17302.604318,3987.89,4006.01,3978.01,4006.01 +1553385600,17179.850648,4006.01,3992.18,3950,3992.18 +1553472000,33192.890217,3991.35,3936.12,3888.71,3936.12 +1553558400,29349.537627,3935.47,3948.55,3894,3948.55 +1553644800,32364.555852,3948.77,4038.05,3936.15,4038.05 +1553731200,20089.293875,4039.58,4027.81,4002,4027.81 +1553817600,30084.217444,4028.22,4103.25,4024.03,4103.25 +1553904000,19509.292601,4104.24,4106.97,4052,4106.97 +1553990400,13525.087433,4106.99,4103.95,4082.57,4103.95 +1554076800,25507.067641,4102.44,4144.56,4067,4144.56 +1554163200,105383.639263,4144.54,4857.29,4140.54,4857.29 +1554249600,109890.125743,4857.19,4932.6,4753.5,4932.6 +1554336000,61054.254168,4932.59,4898.66,4777,4898.66 +1554422400,39768.552806,4898.64,5004.95,4880.62,5004.95 +1554508800,41770.842313,5004.96,5043.89,4928.59,5043.89 +1554595200,37615.486804,5042.07,5170.27,5026,5170.27 +1554681600,50178.430782,5170.27,5236.9,5039,5236.9 +1554768000,34067.012311,5238.38,5150,5076.68,5150 +1554854400,40073.620471,5150,5308.25,5135,5308.25 +1554940800,54696.600686,5307.86,5017.37,4927,5017.37 +1555027200,33276.678614,5017.37,5048.01,4861.22,5048.01 +1555113600,17292.456802,5047,5045.22,5004,5045.22 +1555200000,18281.607739,5047.45,5131.3,5000,5131.3 +1555286400,29057.191581,5131.28,5024.95,4950,5024.95 +1555372800,24242.229493,5024.95,5173.72,5003.94,5173.72 +1555459200,23307.536134,5173.72,5202.82,5146.8,5202.82 +1555545600,22619.239001,5202.41,5258.44,5198.8,5258.44 +1555632000,24611.236323,5258.44,5258.68,5175,5258.68 +1555718400,19168.908274,5258.68,5291.73,5230.1,5291.73 +1555804800,25549.570939,5292.91,5256.14,5165,5256.14 +1555891200,29563.852309,5257.41,5357.14,5208.35,5357.14 +1555977600,41262.103917,5357.14,5493.31,5332.41,5493.31 +1556064000,48224.152413,5490.91,5415,5333.35,5415 +1556150400,49636.089948,5415,5219.9,5102,5219.9 +1556236800,48912.294513,5220.47,5314.1,5161.62,5314.1 +1556323200,15422.896935,5315,5295.69,5257.67,5295.69 +1556409600,14371.433869,5295.69,5307.52,5259.48,5307.52 +1556496000,19918.135079,5309.81,5238.14,5178.8,5238.14 +1556582400,22238.06823,5238.14,5320.81,5192.15,5320.81 +1556668800,17217.473216,5321.94,5383.2,5316.2,5383.2 +1556755200,22795.787835,5383.2,5492.87,5370,5492.87 +1556841600,46297.172849,5494.81,5772.69,5477.57,5772.69 +1556928000,39682.408991,5770.62,5829.45,5587.45,5829.45 +1557014400,23822.543775,5829.83,5775.62,5696,5775.62 +1557100800,25256.596325,5773.18,5747.79,5619.14,5747.79 +1557187200,39905.064422,5749.92,5846.34,5747.74,5846.34 +1557273600,23074.05152,5846.34,5987.29,5772.2,5987.29 +1557360000,27453.011436,5986.66,6209.18,5983.71,6209.18 +1557446400,36623.61079,6209.95,6373.33,6172,6373.33 +1557532800,74022.424393,6375.16,7076.22,6372.85,7076.22 +1557619200,86948.975339,7076.24,6967.31,6750,6967.31 +1557705600,85804.735333,6968.24,7790.71,6870,7790.71 +1557792000,76583.722603,7795.62,7947.56,7599.56,7947.56 +1557878400,37884.327211,7945.26,8169.87,7850,8169.87 +1557964800,69630.513996,8169.08,7866.59,7705,7866.59 +1558051200,88752.008159,7868.67,7355.26,6913,7355.26 +1558137600,37054.944779,7355.28,7257.45,7156.61,7257.45 +1558224000,65577.442058,7257.32,8148.48,7243.08,8148.48 +1558310400,65859.208564,8147.94,7938.15,7553,7938.15 +1558396800,52301.752247,7937.16,7904.87,7771,7904.87 +1558483200,49136.994589,7904.48,7628.43,7465,7628.43 +1558569600,49648.184701,7627.8,7851.51,7461,7851.51 +1558656000,46664.785325,7849.95,7964.87,7766,7964.87 +1558742400,28414.328817,7964.52,8025.41,7908.34,8025.41 +1558828800,49652.144567,8023,8614.43,7833.42,8614.43 +1558915200,51886.768793,8612.54,8756.32,8589,8756.32 +1559001600,31470.551534,8752.52,8715.64,8510.63,8715.64 +1559088000,33880.865922,8716.87,8645.68,8406.6,8645.68 +1559174400,70379.998521,8646.5,8269.54,8005,8269.54 +1559260800,44727.49162,8267.1,8555,8108.5,8555 +1559347200,31868.234157,8555,8544.07,8442.36,8544.07 +1559433600,27835.133265,8545.1,8725.98,8524,8725.98 +1559520000,45692.965104,8726,8115.82,8080.8,8115.82 +1559606400,74143.948941,8115.66,7687.03,7481.02,7687.03 +1559692800,48679.656455,7687.04,7776.5,7572.78,7776.5 +1559779200,36624.118747,7778.08,7786.7,7444.58,7786.7 +1559865600,33942.225658,7787.57,7980.53,7737.49,7980.53 +1559952000,22657.329634,7978.94,7893.62,7751,7893.62 +1560038400,31568.465157,7895.28,7628.13,7506.66,7628.13 +1560124800,36756.078468,7627.57,7982.75,7511,7982.75 +1560211200,30334.999427,7981,7884.9,7692.23,7884.9 +1560297600,41597.082622,7884.9,8127.64,7788.99,8127.64 +1560384000,30467.764341,8127.64,8218.54,8010.03,8218.54 +1560470400,39835.246255,8216.44,8650,8144.32,8650 +1560556800,31791.636039,8650.88,8808.7,8567.63,8808.7 +1560643200,63289.251219,8810.77,8953.33,8760,8953.33 +1560729600,47895.485374,8953,9313.96,8950,9313.96 +1560816000,51554.569401,9312.13,9081.55,8950,9081.55 +1560902400,32147.706495,9081.97,9255.49,8960,9255.49 +1560988800,34556.053982,9253.76,9517.12,9175.2,9517.12 +1561075200,50484.415892,9518.06,10159.86,9518.06,10159.86 +1561161600,104169.447976,10159.86,10729.5,9921.72,10729.5 +1561248000,57445.323945,10729,10906.07,10555.18,10906.07 +1561334400,43101.045285,10905.95,11056.59,10620.8,11056.59 +1561420800,61276.686648,11056.59,11820.86,11026,11820.86 +1561507200,155930.147386,11821.28,13093.8,11741,13093.8 +1561593600,173894.820889,13098.38,11329.99,10525.1,11329.99 +1561680000,95795.203964,11329.99,12400.63,10982.88,12400.63 +1561766400,69642.074157,12407.06,11903.13,11475.02,11903.13 +1561852800,84512.530443,11903.13,10854.1,10766.03,10854.1 +1561939200,90962.268271,10854.1,10624.93,10030,10624.93 +1562025600,109561.038728,10624.9,10842.85,9727,10842.85 +1562112000,96815.90029,10844.98,11940,10841.04,11940 +1562198400,66512.221892,11940,11145.67,11055,11145.67 +1562284800,63534.350582,11145.67,10970.73,10796.44,10970.73 +1562371200,51469.496331,10982.41,11256.49,10964.51,11256.49 +1562457600,38884.795599,11256.45,11406.24,11094.37,11406.24 +1562544000,52182.367215,11410,12238.6,11220,12238.6 +1562630400,78442.130343,12238.6,12543.41,12068,12543.41 +1562716800,109246.044997,12548.51,12108.37,11569,12108.37 +1562803200,87506.461058,12108.11,11342.89,11000,11342.89 +1562889600,56321.858281,11342.88,11757.22,11073,11757.22 +1562976000,54245.594548,11757.22,11355.76,10830,11355.76 +1563062400,72517.579236,11355.78,10174.18,10103,10174.18 +1563148800,81922.426332,10174.18,10838.72,9860,10838.72 +1563235200,97219.443413,10833.78,9439.59,9350.01,9439.59 +1563321600,84942.672717,9430.17,9667.92,9060,9667.92 +1563408000,80283.310252,9668.86,10627.16,9252,10627.16 +1563494400,56546.932133,10628.64,10504.29,10121.84,10504.29 +1563580800,47331.899848,10505.78,10740.23,10350,10740.23 +1563667200,38834.287935,10740.27,10589.45,10288,10589.45 +1563753600,40467.954839,10590.15,10340.31,10100,10340.31 +1563840000,47624.37071,10343.08,9864.91,9822,9864.91 +1563926400,43475.380377,9864.78,9763.28,9525,9763.28 +1564012800,37873.354728,9763.4,9879.87,9720.03,9879.87 +1564099200,27167.463217,9882.15,9824,9637,9824 +1564185600,43809.778301,9824,9476.52,9333,9476.52 +1564272000,29401.022937,9478.92,9541.54,9165,9541.54 +1564358400,29021.937411,9541.54,9507.64,9395,9507.64 +1564444800,32536.368834,9509.07,9574.21,9402,9574.21 +1564531200,39515.35456,9575,10080.53,9555,10080.53 +1564617600,41727.637028,10080.53,10374.99,9863.46,10374.99 +1564704000,42990.444221,10375,10523.75,10281.35,10523.75 +1564790400,33802.318824,10523.75,10816.86,10497.93,10816.86 +1564876800,39924.745141,10816.86,10929.23,10552,10929.23 +1564963200,65153.673713,10929.99,11828.8,10927.8,11828.8 +1565049600,76705.389875,11830,11481.69,11226.7,11481.69 +1565136000,69173.390353,11481.69,11975.03,11382.84,11975.03 +1565222400,51207.257174,11975.04,11999.77,11521,11999.77 +1565308800,39427.152588,11994.17,11879.99,11700,11879.99 +1565395200,42633.087048,11879.98,11309.31,11270,11309.31 +1565481600,26772.90691,11309.24,11549.97,11112.11,11549.97 +1565568000,17568.227075,11539.08,11396.08,11235.32,11396.08 +1565654400,33234.72968,11398.35,10892.71,10788.45,10892.71 +1565740800,54451.847499,10893.36,10050.37,9928.1,10050.37 +1565827200,38174.45112,10055.16,10293.93,9911,10293.93 +1565913600,51758.142918,10296.77,10331.54,9750,10331.54 +1566000000,29000.581201,10331.15,10216.02,10000,10216.02 +1566086400,24085.395172,10216.05,10306.78,10080,10306.78 +1566172800,37243.319217,10306.17,10915.54,10258.6,10915.54 +1566259200,32298.921679,10914.73,10760.51,10560,10760.51 +1566345600,47355.719282,10760.51,10142.57,9858,10142.57 +1566432000,34059.642738,10140.82,10099.88,9762,10099.88 +1566518400,27550.336173,10099.9,10389.55,10019.79,10389.55 +1566604800,27692.456844,10388.16,10134.35,9890,10134.35 +1566691200,26271.657398,10134.61,10142.69,9906.97,10142.69 +1566777600,41687.511599,10142.69,10372.25,10137.93,10372.25 +1566864000,28402.775383,10373.6,10185.05,10051.08,10185.05 +1566950400,42110.555375,10185.69,9721,9601.01,9721 +1567036800,35532.69491,9721,9498.44,9320,9498.44 +1567123200,26834.318104,9499.01,9584.54,9350.41,9584.54 +1567209600,17130.290074,9582.76,9587.47,9420.75,9587.47 +1567296000,19545.404843,9588.74,9724.98,9520,9724.98 +1567382400,44740.248093,9723.59,10340,9712.5,10340 +1567468800,47998.376781,10340,10615.28,10272,10615.28 +1567555200,43943.889026,10611.85,10567.02,10369.89,10567.02 +1567641600,33970.960639,10565.92,10564.49,10450,10564.49 +1567728000,58799.640959,10563.13,10298.73,10150,10298.73 +1567814400,27637.877392,10298.71,10455.88,10288.57,10455.88 +1567900800,23984.672018,10455.9,10381.18,10208,10381.18 +1567987200,39835.727608,10381.24,10303.12,10068.5,10303.12 +1568073600,28915.412225,10302.58,10098.15,9953,10098.15 +1568160000,31953.824562,10098.19,10158.33,9880,10158.33 +1568246400,34511.162755,10158.75,10415.01,10040,10415.01 +1568332800,30280.339776,10415.01,10342.06,10153,10342.06 +1568419200,23621.533519,10344.13,10335.02,10222.33,10335.02 +1568505600,18047.654013,10332.81,10302.01,10252.15,10302.01 +1568592000,28971.401657,10303.34,10251.31,10078,10251.31 +1568678400,22914.324563,10249.68,10187.82,10128.01,10187.82 +1568764800,24250.249303,10187.48,10156.99,10100,10156.99 +1568851200,44826.282579,10156.41,10244.29,9653,10244.29 +1568937600,25088.491069,10243.7,10168.59,10061.39,10168.59 +1569024000,20544.175196,10167.92,9986.39,9900,9986.39 +1569110400,22049.275256,9985.15,10028.87,9853.97,10028.87 +1569196800,31937.232356,10028.05,9702.25,9615.77,9702.25 +1569283200,94007.345203,9702.2,8493.14,7800,8493.14 +1569369600,60783.892258,8497.55,8430.05,8215.64,8430.05 +1569456000,67930.853749,8430.05,8063.73,7750,8063.73 +1569542400,43882.924625,8063.49,8177.91,7852.15,8177.91 +1569628800,34473.605165,8177.47,8198.81,8001.09,8198.81 +1569715200,31544.211388,8199.38,8043.82,7890,8043.82 +1569801600,55865.48726,8043.04,8289.34,7710,8289.34 +1569888000,43472.418091,8289.97,8292.44,8173.05,8292.44 +1569974400,26243.386644,8292.67,8359.94,8151.22,8359.94 +1570060800,30488.284058,8360,8223.96,8060,8223.96 +1570147200,26476.330404,8224.43,8137.13,8005,8137.13 +1570233600,21907.615564,8137.09,8126.19,8012.98,8126.19 +1570320000,34676.104049,8127.55,7854.25,7785,7854.25 +1570406400,52202.072297,7855.3,8190.09,7762,8190.09 +1570492800,35452.657423,8190.82,8168.39,8088.75,8168.39 +1570579200,55038.704378,8170.79,8560.74,8115,8560.74 +1570665600,39137.946167,8562.15,8558.03,8414.52,8558.03 +1570752000,50405.284418,8557.82,8258.5,8212.38,8258.5 +1570838400,21339.334098,8257.95,8300.09,8250,8300.09 +1570924800,27840.739953,8301.98,8275.01,8160,8275.01 +1571011200,29810.663253,8275.24,8348.2,8203,8348.2 +1571097600,32773.062476,8346.86,8159.29,8090,8159.29 +1571184000,34733.593966,8159.3,7991.74,7917,7991.74 +1571270400,29656.949158,7995.02,8070.58,7929.03,8070.58 +1571356800,31353.181416,8070.71,7947.01,7816.01,7947.01 +1571443200,26627.889388,7946.89,7948.01,7866.92,7948.01 +1571529600,34286.452654,7949.87,8223.35,7870,8223.35 +1571616000,30448.679539,8223.35,8197.27,8142.03,8197.27 +1571702400,34651.828663,8197.28,8020,8000,8020 +1571788800,63897.457098,8020.06,7466.62,7300,7466.62 +1571875200,32714.383265,7468.47,7412.41,7337.99,7412.41 +1571961600,90748.218174,7412.41,8655.02,7361,8655.02 +1572048000,162588.585413,8655.88,9230,8470.38,9230 +1572134400,93833.541604,9230,9529.93,9074.34,9529.93 +1572220800,80174.217323,9528.23,9205.14,9160,9205.14 +1572307200,64158.462446,9204.45,9407.62,9072,9407.62 +1572393600,55241.786434,9407.62,9154.72,9001.01,9154.72 +1572480000,54376.024902,9154.02,9140.85,8913,9140.85 +1572566400,43594.814115,9140.86,9231.61,9030,9231.61 +1572652800,28923.060828,9231.4,9289.52,9186.21,9289.52 +1572739200,27894.378279,9289.85,9194.71,9066.14,9194.71 +1572825600,45894.456277,9196.46,9393.35,9115.84,9393.35 +1572912000,45935.873665,9392.4,9308.66,9175.76,9308.66 +1572998400,37336.170372,9307.73,9339.05,9250.01,9339.05 +1573084800,39117.470853,9339.16,9216.2,9101,9216.2 +1573171200,62107.289243,9214,8773.73,8696,8773.73 +1573257600,29469.481405,8773.74,8809.41,8724.88,8809.41 +1573344000,34422.029797,8809.18,9039.47,8750,9039.47 +1573430400,44888.053545,9040.16,8733.27,8618.68,8733.27 +1573516800,40366.629471,8733.36,8821.94,8567.6,8821.94 +1573603200,26810.116918,8821.91,8777.12,8702,8777.12 +1573689600,33468.468961,8777.54,8646.68,8582.6,8646.68 +1573776000,46087.417751,8646.38,8471.73,8400,8471.73 +1573862400,20902.299752,8471.62,8491.02,8400,8491.02 +1573948800,27009.037082,8490.74,8502.4,8350.68,8502.4 +1574035200,43017.69094,8502.87,8187.17,8060,8187.17 +1574121600,43556.061025,8186.5,8133.64,8003,8133.64 +1574208000,32466.23098,8133.83,8098.01,8038.4,8098.01 +1574294400,58418.780261,8098.56,7627.74,7500,7627.74 +1574380800,126603.140259,7627.79,7268.23,6790,7268.23 +1574467200,50449.894755,7268.23,7311.57,7080.01,7311.57 +1574553600,67890.206483,7311.1,6903.28,6861,6903.28 +1574640000,119645.735197,6900.23,7109.57,6515,7109.57 +1574726400,65722.39769,7109.99,7156.14,7017.48,7156.14 +1574812800,92452.87349,7154.75,7508.52,6840,7508.52 +1574899200,56933.981109,7507.9,7419.49,7360,7419.49 +1574985600,60745.300873,7418.52,7739.68,7362.3,7739.68 +1575072000,46989.433619,7740.99,7541.89,7441,7541.89 +1575158400,60769.342313,7540.63,7390.89,7210,7390.89 +1575244800,46330.25604,7391.5,7294.28,7151.1,7294.28 +1575331200,33149.477487,7294.42,7292.71,7241.35,7292.71 +1575417600,83147.149142,7292.71,7194.32,7067,7194.32 +1575504000,59306.678855,7194.59,7389,7150,7389 +1575590400,48189.087944,7389,7527.47,7305,7527.47 +1575676800,31498.684173,7527.8,7488.21,7470.16,7488.21 +1575763200,29856.897631,7487.31,7510.11,7374.86,7510.11 +1575849600,46621.887493,7510.11,7338.64,7273,7338.64 +1575936000,49723.76214,7338.64,7224.13,7157.1,7224.13 +1576022400,30093.091944,7224.15,7210,7125.66,7210 +1576108800,42288.600932,7210,7198.08,7080.3,7198.08 +1576195200,27609.873795,7197.76,7258.48,7190.76,7258.48 +1576281600,29561.985967,7257.37,7064.05,7012,7064.05 +1576368000,26395.778137,7064.14,7118.59,7008.35,7118.59 +1576454400,43863.993059,7119.6,6891.72,6836,6891.72 +1576540800,53865.069929,6891.44,6623.82,6560,6623.82 +1576627200,95636.651251,6623.84,7277.83,6435,7277.83 +1576713600,55509.049075,7277.83,7150.3,7038.31,7150.3 +1576800000,32132.069205,7151.31,7187.83,7079.5,7187.83 +1576886400,19467.174028,7188.01,7132.75,7105,7132.75 +1576972800,39137.45515,7131.59,7501.44,7122.47,7501.44 +1577059200,68051.997203,7500.71,7317.09,7265.84,7317.09 +1577145600,43629.494188,7317.3,7255.77,7157.04,7255.77 +1577232000,27492.044323,7255.77,7204.63,7128.86,7204.63 +1577318400,36259.761076,7205.01,7202,7157.12,7202 +1577404800,33642.701861,7202,7254.74,7076.42,7254.74 +1577491200,26848.982199,7254.77,7316.14,7238.67,7316.14 +1577577600,31387.106085,7315.36,7388.24,7288,7388.24 +1577664000,29605.911782,7388.43,7246,7220,7246 +1577750400,25954.453533,7246,7195.23,7145.01,7195.23 diff --git a/testdata/configtest.json b/testdata/configtest.json index 95cc256c..57da70e6 100644 --- a/testdata/configtest.json +++ b/testdata/configtest.json @@ -3,7 +3,7 @@ "encryptConfig": -1, "globalHTTPTimeout": 15000000000, "database": { - "enabled": false, + "enabled": true, "verbose": false, "driver": "sqlite3", "connectionDetails": { diff --git a/testdata/exchangelist.csv b/testdata/exchangelist.csv new file mode 100644 index 00000000..b9abd82e --- /dev/null +++ b/testdata/exchangelist.csv @@ -0,0 +1,28 @@ +binance, +bitfinex, +bitflyer, +bithumb, +bitmex, +bitstamp, +bittrex, +btc markets, +btse, +coinbasepro, +coinbene, +coinut, +exmo, +ftx, +gateio, +gemini, +hitbtc, +huobi, +itbit, +kraken, +lakebtc, +lbank, +localbitcoins, +okcoin international, +okex, +poloniex, +yobit, +zb, \ No newline at end of file diff --git a/testdata/http_mock/poloniex/poloniex.json b/testdata/http_mock/poloniex/poloniex.json index e9031840..30099cc3 100644 --- a/testdata/http_mock/poloniex/poloniex.json +++ b/testdata/http_mock/poloniex/poloniex.json @@ -8374,23 +8374,6 @@ "bodyParams": "", "headers": {} }, - { - "data": [ - { - "close": 0.00403997, - "date": 1405699200, - "high": 0.00413615, - "low": 0.00403986, - "open": 0.00404545, - "quoteVolume": 1205.10503896, - "volume": 4.95713239, - "weightedAverage": 0.00411344 - } - ], - "queryString": "command=returnChartData\u0026currencyPair=BTC_XMR\u0026end=1405699400\u0026period=300\u0026start=1405699200", - "bodyParams": "", - "headers": {} - }, { "data": { "asks": [ @@ -8803,6 +8786,168 @@ "queryString": "command=returnOrderBook\u0026currencyPair=BTC_XMR\u0026depth=50", "bodyParams": "", "headers": {} + }, + { + "data": [ + { + "close": 0.00518763, + "date": 1588741200, + "high": 0.00518763, + "low": 0.005187, + "open": 0.00518701, + "quoteVolume": 25.95091903, + "volume": 0.13460756, + "weightedAverage": 0.005187 + }, + { + "close": 0.00518401, + "date": 1588741500, + "high": 0.00518818, + "low": 0.00518401, + "open": 0.00518818, + "quoteVolume": 65.00109374, + "volume": 0.33723736, + "weightedAverage": 0.00518817 + }, + { + "close": 0.0051839, + "date": 1588741800, + "high": 0.00518444, + "low": 0.0051839, + "open": 0.00518444, + "quoteVolume": 0.43601529, + "volume": 0.00226025, + "weightedAverage": 0.0051839 + }, + { + "close": 0.00518201, + "date": 1588742100, + "high": 0.00518614, + "low": 0.00518201, + "open": 0.00518401, + "quoteVolume": 90.59918563, + "volume": 0.46972322, + "weightedAverage": 0.00518462 + }, + { + "close": 0.00518373, + "date": 1588742400, + "high": 0.0051847, + "low": 0.00517971, + "open": 0.00517972, + "quoteVolume": 8.6152343, + "volume": 0.04465903, + "weightedAverage": 0.00518372 + }, + { + "close": 0.00519266, + "date": 1588742700, + "high": 0.00519266, + "low": 0.00518553, + "open": 0.00518553, + "quoteVolume": 81.37365353, + "volume": 0.42217513, + "weightedAverage": 0.0051881 + }, + { + "close": 0.00519104, + "date": 1588743000, + "high": 0.00519597, + "low": 0.00519104, + "open": 0.00519597, + "quoteVolume": 1.10021375, + "volume": 0.0057163, + "weightedAverage": 0.00519562 + }, + { + "close": 0.00518988, + "date": 1588743300, + "high": 0.00518988, + "low": 0.00518905, + "open": 0.00518905, + "quoteVolume": 0.00086904, + "volume": 0.0000045, + "weightedAverage": 0.00518961 + }, + { + "close": 0.00519395, + "date": 1588743600, + "high": 0.00519395, + "low": 0.00518901, + "open": 0.00518903, + "quoteVolume": 0.03395903, + "volume": 0.0001763, + "weightedAverage": 0.00519181 + }, + { + "close": 0.00519098, + "date": 1588743900, + "high": 0.00519526, + "low": 0.00519098, + "open": 0.00519126, + "quoteVolume": 209.14700529, + "volume": 1.08631528, + "weightedAverage": 0.00519402 + }, + { + "close": 0.00518534, + "date": 1588744200, + "high": 0.00519198, + "low": 0.00518534, + "open": 0.00519179, + "quoteVolume": 176.01313731, + "volume": 0.91303131, + "weightedAverage": 0.00518729 + }, + { + "close": 0.00518573, + "date": 1588744500, + "high": 0.00518752, + "low": 0.00518572, + "open": 0.00518752, + "quoteVolume": 97.1672869, + "volume": 0.50399966, + "weightedAverage": 0.00518692 + }, + { + "close": 0.00518864, + "date": 1588744800, + "high": 0.00519153, + "low": 0.00518657, + "open": 0.00518826, + "quoteVolume": 74.95742178, + "volume": 0.38903394, + "weightedAverage": 0.00519006 + } + ], + "queryString": "command=returnChartData\u0026currencyPair=BTC_LTC\u0026end=1588745003\u0026period=300\u0026start=1588741200", + "bodyParams": "", + "headers": {} + }, + { + "data": { + "error": "Invalid currency pair." + }, + "queryString": "command=returnChartData\u0026currencyPair=BTC_LTCC\u0026end=1588745003\u0026period=300\u0026start=1588741200", + "bodyParams": "", + "headers": {} + }, + { + "data": [ + { + "close": 0.00403997, + "date": 1405699200, + "high": 0.00413615, + "low": 0.00403986, + "open": 0.00404545, + "quoteVolume": 1205.10503896, + "volume": 4.95713239, + "weightedAverage": 0.00411344 + } + ], + "queryString": "command=returnChartData\u0026currencyPair=BTC_XMR\u0026end=1405699400\u0026period=300\u0026start=1405699200", + "bodyParams": "", + "headers": {} } ] },