From 8814ed58da8a12260beb879ef0c567d3fadedb2b Mon Sep 17 00:00:00 2001 From: rsercano Date: Sun, 8 Nov 2020 23:06:09 +0300 Subject: [PATCH] feat: new grpc call for subscribring alerts such as low balance (#864) --- docs/api.md | 75 +++ lib/cli/commands/subscribealerts.ts | 72 ++ lib/connextclient/ConnextClient.ts | 35 +- lib/constants/enums.ts | 9 + lib/grpc/GrpcService.ts | 29 +- lib/lndclient/LndClient.ts | 45 +- lib/proto/annotations_grpc_pb.js | 2 +- lib/proto/xudp2p_grpc_pb.js | 2 +- lib/proto/xudrpc.swagger.json | 88 +++ lib/proto/xudrpc_grpc_pb.d.ts | 15 + lib/proto/xudrpc_grpc_pb.js | 34 + lib/proto/xudrpc_pb.d.ts | 107 +++ lib/proto/xudrpc_pb.js | 624 ++++++++++++++++++ lib/service/Service.ts | 27 +- lib/swaps/SwapClient.ts | 9 + lib/swaps/types.ts | 17 +- proto/xudrpc.proto | 41 ++ test/simulation/xudrpc/xudrpc.pb.go | 991 ++++++++++++++++++---------- 18 files changed, 1871 insertions(+), 351 deletions(-) create mode 100644 lib/cli/commands/subscribealerts.ts diff --git a/docs/api.md b/docs/api.md index d5ecc2be7..2ff404800 100644 --- a/docs/api.md +++ b/docs/api.md @@ -7,10 +7,12 @@ - [AddCurrencyResponse](#xudrpc.AddCurrencyResponse) - [AddPairRequest](#xudrpc.AddPairRequest) - [AddPairResponse](#xudrpc.AddPairResponse) + - [Alert](#xudrpc.Alert) - [Balance](#xudrpc.Balance) - [BanRequest](#xudrpc.BanRequest) - [BanResponse](#xudrpc.BanResponse) - [Chain](#xudrpc.Chain) + - [ChannelBalanceAlert](#xudrpc.ChannelBalanceAlert) - [Channels](#xudrpc.Channels) - [CloseChannelRequest](#xudrpc.CloseChannelRequest) - [CloseChannelResponse](#xudrpc.CloseChannelResponse) @@ -71,6 +73,7 @@ - [SetLogLevelResponse](#xudrpc.SetLogLevelResponse) - [ShutdownRequest](#xudrpc.ShutdownRequest) - [ShutdownResponse](#xudrpc.ShutdownResponse) + - [SubscribeAlertsRequest](#xudrpc.SubscribeAlertsRequest) - [SubscribeOrdersRequest](#xudrpc.SubscribeOrdersRequest) - [SubscribeSwapsAcceptedRequest](#xudrpc.SubscribeSwapsAcceptedRequest) - [SubscribeSwapsRequest](#xudrpc.SubscribeSwapsRequest) @@ -91,6 +94,8 @@ - [WithdrawRequest](#xudrpc.WithdrawRequest) - [WithdrawResponse](#xudrpc.WithdrawResponse) + - [Alert.AlertType](#xudrpc.Alert.AlertType) + - [ChannelBalanceAlert.Side](#xudrpc.ChannelBalanceAlert.Side) - [Currency.SwapClient](#xudrpc.Currency.SwapClient) - [ListOrdersRequest.Owner](#xudrpc.ListOrdersRequest.Owner) - [LogLevel](#xudrpc.LogLevel) @@ -147,6 +152,23 @@ + + +### Alert + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| type | [Alert.AlertType](#xudrpc.Alert.AlertType) | | | +| message | [string](#string) | | The human readable alert message. | +| balance_alert | [ChannelBalanceAlert](#xudrpc.ChannelBalanceAlert) | | | + + + + + + ### Balance @@ -208,6 +230,25 @@ + + +### ChannelBalanceAlert + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| total_balance | [uint64](#uint64) | | The total balance of the channel. | +| side | [ChannelBalanceAlert.Side](#xudrpc.ChannelBalanceAlert.Side) | | | +| bound | [uint32](#uint32) | | The bound of the low balance in percentage. | +| side_balance | [uint64](#uint64) | | The current side balance. | +| channel_point | [string](#string) | | The point of the channel. | + + + + + + ### Channels @@ -1143,6 +1184,16 @@ + + +### SubscribeAlertsRequest + + + + + + + ### SubscribeOrdersRequest @@ -1465,6 +1516,29 @@ + + +### Alert.AlertType +The type of the alert. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| LOW_BALANCE | 0 | | + + + + + +### ChannelBalanceAlert.Side +The side of the low balance. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| REMOTE | 0 | | +| LOCAL | 1 | | + + + ### Currency.SwapClient @@ -1569,6 +1643,7 @@ The primary service for interacting with a running xud node. | SetLogLevel | [SetLogLevelRequest](#xudrpc.SetLogLevelRequest) | [SetLogLevelResponse](#xudrpc.SetLogLevelResponse) | Set the logging level. shell: xucli loglevel <level> | | Shutdown | [ShutdownRequest](#xudrpc.ShutdownRequest) | [ShutdownResponse](#xudrpc.ShutdownResponse) | Begin gracefully shutting down xud. shell: xucli shutdown | | SubscribeOrders | [SubscribeOrdersRequest](#xudrpc.SubscribeOrdersRequest) | [OrderUpdate](#xudrpc.OrderUpdate) stream | Subscribes to orders being added to and removed from the order book. This call allows the client to maintain an up-to-date view of the order book. For example, an exchange that wants to show its users a real time view of the orders available to them would subscribe to this streaming call to be alerted as new orders are added and expired orders are removed. | +| SubscribeAlerts | [SubscribeAlertsRequest](#xudrpc.SubscribeAlertsRequest) | [Alert](#xudrpc.Alert) stream | Subscribes to alerts such as low balance. | | SubscribeSwapFailures | [SubscribeSwapsRequest](#xudrpc.SubscribeSwapsRequest) | [SwapFailure](#xudrpc.SwapFailure) stream | Subscribes to failed swaps. By default, only swaps that are initiated by a remote peer are transmitted unless a flag is set to include swaps initiated by the local node. This call allows the client to get real-time notifications when swap attempts are failing. It can be used for status monitoring, debugging, and testing purposes. | | SubscribeSwaps | [SubscribeSwapsRequest](#xudrpc.SubscribeSwapsRequest) | [SwapSuccess](#xudrpc.SwapSuccess) stream | Subscribes to completed swaps. By default, only swaps that are initiated by a remote peer are transmitted unless a flag is set to include swaps initiated by the local node. This call allows the client to get real-time notifications when its orders are filled by a peer. It can be used for tracking order executions, updating balances, and informing a trader when one of their orders is settled through the Exchange Union network. | | SubscribeSwapsAccepted | [SubscribeSwapsAcceptedRequest](#xudrpc.SubscribeSwapsAcceptedRequest) | [SwapAccepted](#xudrpc.SwapAccepted) stream | Subscribes to accepted swaps. This stream emits a message when the local xud node accepts a swap request from a peer, but before the swap has actually succeeded. | diff --git a/lib/cli/commands/subscribealerts.ts b/lib/cli/commands/subscribealerts.ts new file mode 100644 index 000000000..83f6a2158 --- /dev/null +++ b/lib/cli/commands/subscribealerts.ts @@ -0,0 +1,72 @@ +import { ServiceError, status } from 'grpc'; +import { Arguments, Argv } from 'yargs'; +import { XudClient } from '../../proto/xudrpc_grpc_pb'; +import * as xudrpc from '../../proto/xudrpc_pb'; +import { setTimeoutPromise } from '../../utils/utils'; +import { loadXudClient } from '../command'; +import { AlertType } from '../../constants/enums'; + +export const command = 'subscribealerts [--pretty]'; + +export const describe = 'subscribe alerts such as low balance'; + +export const builder = (argv: Argv) => argv + .option('pretty', { + type: 'boolean', + }) + .example('$0 subscribealerts', 'prints alert payload in a JSON structure') + .example('$0 subscribealerts --pretty', 'prints alert message only'); + +export const handler = async (argv: Arguments) => { + await ensureConnection(argv, true); +}; + +let client: XudClient; + +const ensureConnection = async (argv: Arguments, printError?: boolean) => { + if (!client) { + client = await loadXudClient(argv); + } + client.waitForReady(Date.now() + 3000, (error: Error | null) => { + if (error) { + if (error.message === 'Failed to connect before the deadline') { + console.error(`could not connect to xud at ${argv.rpchost}:${argv.rpcport}, is xud running?`); + process.exit(1); + } + + if (printError) console.error(`${error.name}: ${error.message}`); + setTimeout(ensureConnection.bind(undefined, argv, printError), 3000); + } else { + console.log('Successfully connected, subscribing for alerts'); + subscribeAlerts(argv); + } + }); +}; + +const subscribeAlerts = (argv: Arguments) => { + const request = new xudrpc.SubscribeAlertsRequest(); + const alertsSubscription = client.subscribeAlerts(request); + + alertsSubscription.on('data', (alert: xudrpc.Alert) => { + if (argv.pretty) { + console.log(`${AlertType[alert.getType()]}: ${alert.getMessage()}`); + } else { + console.log(JSON.stringify(alert, undefined, 2)); + } + }); + alertsSubscription.on('end', reconnect.bind(undefined, argv)); + alertsSubscription.on('error', async (err: ServiceError) => { + if (err.code === status.UNIMPLEMENTED) { + console.error("xud is locked, run 'xucli unlock', 'xucli create', or 'xucli restore' then try again"); + process.exit(1); + } + console.warn(`Unexpected error occured: ${err.message}, reconnecting in 1 second`); + await setTimeoutPromise(1000); + await ensureConnection(argv); + }); +}; + +const reconnect = async (argv: Arguments) => { + console.log('Stream has closed, trying to reconnect'); + await ensureConnection(argv, false); +}; diff --git a/lib/connextclient/ConnextClient.ts b/lib/connextclient/ConnextClient.ts index ebd45f4d7..f13d3bc05 100644 --- a/lib/connextclient/ConnextClient.ts +++ b/lib/connextclient/ConnextClient.ts @@ -1,6 +1,6 @@ import assert from 'assert'; import http from 'http'; -import { SwapClientType, SwapRole, SwapState } from '../constants/enums'; +import { ChannelBalanceSide, SwapClientType, SwapRole, SwapState } from '../constants/enums'; import { CurrencyInstance } from '../db/types'; import { XudError } from '../types'; import Logger from '../Logger'; @@ -14,7 +14,7 @@ import SwapClient, { PaymentStatus, WithdrawArguments, } from '../swaps/SwapClient'; -import { SwapDeal, CloseChannelParams, OpenChannelParams, SwapCapacities } from '../swaps/types'; +import { SwapDeal, CloseChannelParams, OpenChannelParams, SwapCapacities, ChannelBalanceAlert } from '../swaps/types'; import { UnitConverter } from '../utils/UnitConverter'; import errors, { errorCodes } from './errors'; import { @@ -46,6 +46,7 @@ interface ConnextClient { on(event: 'htlcAccepted', listener: (rHash: string, amount: number, currency: string) => void): this; on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; on(event: 'depositConfirmed', listener: (hash: string) => void): this; + on(event: 'lowBalance', listener: (alert: ChannelBalanceAlert) => void): this; once(event: 'initialized', listener: () => void): this; emit(event: 'htlcAccepted', rHash: string, amount: number, currency: string): boolean; emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; @@ -53,6 +54,7 @@ interface ConnextClient { emit(event: 'preimage', preimageRequest: ProvidePreimageEvent): void; emit(event: 'transferReceived', transferReceivedRequest: TransferReceivedEvent): void; emit(event: 'depositConfirmed', hash: string): void; + emit(event: 'lowBalance', alert: ChannelBalanceAlert): boolean; } /** @@ -332,6 +334,35 @@ class ConnextClient extends SwapClient { channelBalancePromises.push(this.channelBalance(currency)); } await Promise.all(channelBalancePromises); + + for (const [currency, address] of this.tokenAddresses) { + const remoteBalance = this.inboundAmounts.get(currency) || 0; + const localBalance = this.outboundAmounts.get(currency) || 0; + const totalBalance = remoteBalance + localBalance; + const alertThreshold = totalBalance * 0.1; + + if (localBalance < alertThreshold) { + this.emit('lowBalance', { + totalBalance, + currency, + channelPoint: address, + side: ChannelBalanceSide.Local, + sideBalance: localBalance, + bound: 10, + }); + } + + if (remoteBalance < alertThreshold) { + this.emit('lowBalance', { + totalBalance, + currency, + channelPoint: address, + side: ChannelBalanceSide.Remote, + sideBalance: remoteBalance, + bound: 10, + }); + } + } } catch (e) { this.logger.error('failed to update total outbound capacity', e); } diff --git a/lib/constants/enums.ts b/lib/constants/enums.ts index e86a12080..a808a8e82 100644 --- a/lib/constants/enums.ts +++ b/lib/constants/enums.ts @@ -180,3 +180,12 @@ export enum DisconnectionReason { AuthFailureInvalidSignature = 12, WireProtocolErr = 13, } + +export enum AlertType { + LowBalance = 0, +} + +export enum ChannelBalanceSide { + Remote = 0, + Local = 1, +} diff --git a/lib/grpc/GrpcService.ts b/lib/grpc/GrpcService.ts index ea20c455b..a1c794d7e 100644 --- a/lib/grpc/GrpcService.ts +++ b/lib/grpc/GrpcService.ts @@ -2,13 +2,13 @@ import grpc, { ServerWritableStream, status } from 'grpc'; import { fromEvent } from 'rxjs'; import { take } from 'rxjs/operators'; -import { SwapFailureReason } from '../constants/enums'; +import { AlertType, SwapFailureReason } from '../constants/enums'; import { LndInfo } from '../lndclient/types'; import { isOwnOrder, Order, OrderPortion, PlaceOrderEventType, PlaceOrderResult } from '../orderbook/types'; import * as xudrpc from '../proto/xudrpc_pb'; import Service from '../service/Service'; import { ServiceOrder, ServicePlaceOrderEvent } from '../service/types'; -import { SwapAccepted, SwapFailure, SwapSuccess } from '../swaps/types'; +import { ChannelBalanceAlert, SwapAccepted, SwapFailure, SwapSuccess } from '../swaps/types'; import getGrpcError from './getGrpcError'; /** @@ -870,6 +870,31 @@ class GrpcService { } } + /* + * See [[Service.subscribeAlerts]] + */ + public subscribeAlerts: grpc.handleServerStreamingCall = (call) => { + if (!this.isReady(this.service, call)) { + return; + } + + const cancelled$ = getCancelled$(call); + this.service.subscribeAlerts((type: AlertType, message: string, payload: ChannelBalanceAlert) => { + const alert = new xudrpc.Alert(); + alert.setType(type as number); + alert.setMessage(message); + const channelBalanceAlert = new xudrpc.ChannelBalanceAlert(); + channelBalanceAlert.setBound(payload.bound); + channelBalanceAlert.setChannelPoint(payload.channelPoint); + channelBalanceAlert.setSide(payload.side as number); + channelBalanceAlert.setSideBalance(payload.sideBalance); + channelBalanceAlert.setTotalBalance(payload.totalBalance); + alert.setBalanceAlert(channelBalanceAlert); + call.write(alert); + }, + cancelled$); + } + /* * See [[Service.subscribeOrders]] */ diff --git a/lib/lndclient/LndClient.ts b/lib/lndclient/LndClient.ts index 9e50391ac..7141da331 100644 --- a/lib/lndclient/LndClient.ts +++ b/lib/lndclient/LndClient.ts @@ -3,15 +3,15 @@ import crypto from 'crypto'; import { promises as fs, watch } from 'fs'; import grpc, { ChannelCredentials, ClientReadableStream } from 'grpc'; import path from 'path'; -import { SwapClientType, SwapRole, SwapState } from '../constants/enums'; +import { ChannelBalanceSide, SwapClientType, SwapRole, SwapState } from '../constants/enums'; import Logger from '../Logger'; import { InvoicesClient } from '../proto/lndinvoices_grpc_pb'; import * as lndinvoices from '../proto/lndinvoices_pb'; import { LightningClient, WalletUnlockerClient } from '../proto/lndrpc_grpc_pb'; import * as lndrpc from '../proto/lndrpc_pb'; import swapErrors from '../swaps/errors'; -import SwapClient, { ChannelBalance, ClientStatus, PaymentState, SwapClientInfo, WithdrawArguments } from '../swaps/SwapClient'; -import { CloseChannelParams, OpenChannelParams, SwapCapacities, SwapDeal } from '../swaps/types'; +import SwapClient, { Balance, ChannelBalance, ClientStatus, PaymentState, SwapClientInfo, WithdrawArguments } from '../swaps/SwapClient'; +import { ChannelBalanceAlert, CloseChannelParams, OpenChannelParams, SwapCapacities, SwapDeal } from '../swaps/types'; import { deriveChild } from '../utils/seedutil'; import { base64ToHex, hexToUint8Array } from '../utils/utils'; import errors from './errors'; @@ -23,6 +23,7 @@ interface LndClient { on(event: 'channelBackup', listener: (channelBackup: Uint8Array) => void): this; on(event: 'channelBackupEnd', listener: () => void): this; on(event: 'locked', listener: () => void): this; + on(event: 'lowBalance', listener: (alert: ChannelBalanceAlert) => void): this; once(event: 'initialized', listener: () => void): this; @@ -32,6 +33,7 @@ interface LndClient { emit(event: 'channelBackupEnd'): boolean; emit(event: 'locked'): boolean; emit(event: 'initialized'): boolean; + emit(event: 'lowBalance', alert: ChannelBalanceAlert): boolean; } const MAXFEE = 0.03; @@ -230,7 +232,33 @@ class LndClient extends SwapClient { } protected updateCapacity = async () => { - await this.channelBalance().catch(async (err) => { + await this.channelBalance().then(({ balancePerChannel }: ChannelBalance) => { + balancePerChannel?.forEach((balance, channelPoint) => { + const totalBalance = balance.localBalance + balance.remoteBalance; + const alertThreshold = totalBalance * 0.1; + if (balance.localBalance < alertThreshold) { + this.emit('lowBalance', { + totalBalance, + channelPoint, + side: ChannelBalanceSide.Local, + sideBalance: balance.localBalance, + bound: 10, + currency: this.currency, + }); + } + + if (balance.remoteBalance < alertThreshold) { + this.emit('lowBalance', { + totalBalance, + channelPoint, + side: ChannelBalanceSide.Remote, + sideBalance: balance.remoteBalance, + bound: 10, + currency: this.currency, + }); + } + }); + }).catch(async (err) => { this.logger.error('failed to update total outbound capacity', err); }); } @@ -705,8 +733,11 @@ class LndClient extends SwapClient { let inactiveBalance = 0; let totalOutboundAmount = 0; let totalInboundAmount = 0; + const balancePerChannel = new Map(); channels.toObject().channelsList.forEach((channel) => { if (channel.active) { + balancePerChannel.set(channel.channelPoint, { localBalance: channel.localBalance, remoteBalance: channel.remoteBalance }); + balance += channel.localBalance; const outbound = channel.localBalance - channel.localChanReserveSat; totalOutboundAmount += outbound; @@ -719,6 +750,7 @@ class LndClient extends SwapClient { if (maxInbound < inbound) { maxInbound = inbound; } + } else { inactiveBalance += channel.localBalance; } @@ -755,12 +787,13 @@ class LndClient extends SwapClient { balance, inactiveBalance, pendingOpenBalance, + balancePerChannel, }; } public channelBalance = async (): Promise => { - const { balance, inactiveBalance, pendingOpenBalance } = await this.updateChannelBalances(); - return { balance, inactiveBalance, pendingOpenBalance }; + const { balance, inactiveBalance, pendingOpenBalance, balancePerChannel } = await this.updateChannelBalances(); + return { balance, inactiveBalance, pendingOpenBalance, balancePerChannel }; } public swapCapacities = async (): Promise => { diff --git a/lib/proto/annotations_grpc_pb.js b/lib/proto/annotations_grpc_pb.js index 97b3a2461..51b4d6959 100644 --- a/lib/proto/annotations_grpc_pb.js +++ b/lib/proto/annotations_grpc_pb.js @@ -1 +1 @@ -// GENERATED CODE -- NO SERVICES IN PROTO \ No newline at end of file +// GENERATED CODE -- NO SERVICES IN PROTO diff --git a/lib/proto/xudp2p_grpc_pb.js b/lib/proto/xudp2p_grpc_pb.js index 97b3a2461..51b4d6959 100644 --- a/lib/proto/xudp2p_grpc_pb.js +++ b/lib/proto/xudp2p_grpc_pb.js @@ -1 +1 @@ -// GENERATED CODE -- NO SERVICES IN PROTO \ No newline at end of file +// GENERATED CODE -- NO SERVICES IN PROTO diff --git a/lib/proto/xudrpc.swagger.json b/lib/proto/xudrpc.swagger.json index 6acc4205c..c92d465b5 100644 --- a/lib/proto/xudrpc.swagger.json +++ b/lib/proto/xudrpc.swagger.json @@ -602,6 +602,23 @@ ] } }, + "/v1/subscribealerts": { + "get": { + "summary": "Subscribes to alerts such as low balance.", + "operationId": "SubscribeAlerts", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "$ref": "#/x-stream-definitions/xudrpcAlert" + } + } + }, + "tags": [ + "Xud" + ] + } + }, "/v1/subscribeorders": { "get": { "summary": "Subscribes to orders being added to and removed from the order book. This call allows the client\nto maintain an up-to-date view of the order book. For example, an exchange that wants to show\nits users a real time view of the orders available to them would subscribe to this streaming\ncall to be alerted as new orders are added and expired orders are removed.", @@ -836,6 +853,23 @@ } }, "definitions": { + "AlertAlertType": { + "type": "string", + "enum": [ + "LOW_BALANCE" + ], + "default": "LOW_BALANCE", + "description": "The type of the alert." + }, + "ChannelBalanceAlertSide": { + "type": "string", + "enum": [ + "REMOTE", + "LOCAL" + ], + "default": "REMOTE", + "description": "The side of the low balance." + }, "CurrencySwapClient": { "type": "string", "enum": [ @@ -909,6 +943,21 @@ "xudrpcAddPairResponse": { "type": "object" }, + "xudrpcAlert": { + "type": "object", + "properties": { + "type": { + "$ref": "#/definitions/AlertAlertType" + }, + "message": { + "type": "string", + "description": "The human readable alert message." + }, + "balance_alert": { + "$ref": "#/definitions/xudrpcChannelBalanceAlert" + } + } + }, "xudrpcBalance": { "type": "object", "properties": { @@ -969,6 +1018,33 @@ } } }, + "xudrpcChannelBalanceAlert": { + "type": "object", + "properties": { + "total_balance": { + "type": "string", + "format": "uint64", + "description": "The total balance of the channel." + }, + "side": { + "$ref": "#/definitions/ChannelBalanceAlertSide" + }, + "bound": { + "type": "integer", + "format": "int64", + "description": "The bound of the low balance in percentage." + }, + "side_balance": { + "type": "string", + "format": "uint64", + "description": "The current side balance." + }, + "channel_point": { + "type": "string", + "description": "The point of the channel." + } + } + }, "xudrpcChannels": { "type": "object", "properties": { @@ -2038,6 +2114,18 @@ } }, "x-stream-definitions": { + "xudrpcAlert": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/xudrpcAlert" + }, + "error": { + "$ref": "#/definitions/runtimeStreamError" + } + }, + "title": "Stream result of xudrpcAlert" + }, "xudrpcOrderUpdate": { "type": "object", "properties": { diff --git a/lib/proto/xudrpc_grpc_pb.d.ts b/lib/proto/xudrpc_grpc_pb.d.ts index 4a888d1b2..728b430fe 100644 --- a/lib/proto/xudrpc_grpc_pb.d.ts +++ b/lib/proto/xudrpc_grpc_pb.d.ts @@ -100,6 +100,7 @@ interface IXudService extends grpc.ServiceDefinition; responseDeserialize: grpc.deserialize; } +interface IXudService_ISubscribeAlerts extends grpc.MethodDefinition { + path: string; // "/xudrpc.Xud/SubscribeAlerts" + requestStream: boolean; // false + responseStream: boolean; // true + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} interface IXudService_ISubscribeSwapFailures extends grpc.MethodDefinition { path: string; // "/xudrpc.Xud/SubscribeSwapFailures" requestStream: boolean; // false @@ -426,6 +436,7 @@ export interface IXudServer { setLogLevel: grpc.handleUnaryCall; shutdown: grpc.handleUnaryCall; subscribeOrders: grpc.handleServerStreamingCall; + subscribeAlerts: grpc.handleServerStreamingCall; subscribeSwapFailures: grpc.handleServerStreamingCall; subscribeSwaps: grpc.handleServerStreamingCall; subscribeSwapsAccepted: grpc.handleServerStreamingCall; @@ -509,6 +520,8 @@ export interface IXudClient { shutdown(request: xudrpc_pb.ShutdownRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.ShutdownResponse) => void): grpc.ClientUnaryCall; subscribeOrders(request: xudrpc_pb.SubscribeOrdersRequest, options?: Partial): grpc.ClientReadableStream; subscribeOrders(request: xudrpc_pb.SubscribeOrdersRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; + subscribeAlerts(request: xudrpc_pb.SubscribeAlertsRequest, options?: Partial): grpc.ClientReadableStream; + subscribeAlerts(request: xudrpc_pb.SubscribeAlertsRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; subscribeSwapFailures(request: xudrpc_pb.SubscribeSwapsRequest, options?: Partial): grpc.ClientReadableStream; subscribeSwapFailures(request: xudrpc_pb.SubscribeSwapsRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; subscribeSwaps(request: xudrpc_pb.SubscribeSwapsRequest, options?: Partial): grpc.ClientReadableStream; @@ -604,6 +617,8 @@ export class XudClient extends grpc.Client implements IXudClient { public shutdown(request: xudrpc_pb.ShutdownRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.ShutdownResponse) => void): grpc.ClientUnaryCall; public subscribeOrders(request: xudrpc_pb.SubscribeOrdersRequest, options?: Partial): grpc.ClientReadableStream; public subscribeOrders(request: xudrpc_pb.SubscribeOrdersRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; + public subscribeAlerts(request: xudrpc_pb.SubscribeAlertsRequest, options?: Partial): grpc.ClientReadableStream; + public subscribeAlerts(request: xudrpc_pb.SubscribeAlertsRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; public subscribeSwapFailures(request: xudrpc_pb.SubscribeSwapsRequest, options?: Partial): grpc.ClientReadableStream; public subscribeSwapFailures(request: xudrpc_pb.SubscribeSwapsRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; public subscribeSwaps(request: xudrpc_pb.SubscribeSwapsRequest, options?: Partial): grpc.ClientReadableStream; diff --git a/lib/proto/xudrpc_grpc_pb.js b/lib/proto/xudrpc_grpc_pb.js index d7d8d3997..7c04fe4fb 100644 --- a/lib/proto/xudrpc_grpc_pb.js +++ b/lib/proto/xudrpc_grpc_pb.js @@ -59,6 +59,17 @@ function deserialize_xudrpc_AddPairResponse(buffer_arg) { return xudrpc_pb.AddPairResponse.deserializeBinary(new Uint8Array(buffer_arg)); } +function serialize_xudrpc_Alert(arg) { + if (!(arg instanceof xudrpc_pb.Alert)) { + throw new Error('Expected argument of type xudrpc.Alert'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_xudrpc_Alert(buffer_arg) { + return xudrpc_pb.Alert.deserializeBinary(new Uint8Array(buffer_arg)); +} + function serialize_xudrpc_BanRequest(arg) { if (!(arg instanceof xudrpc_pb.BanRequest)) { throw new Error('Expected argument of type xudrpc.BanRequest'); @@ -587,6 +598,17 @@ function deserialize_xudrpc_ShutdownResponse(buffer_arg) { return xudrpc_pb.ShutdownResponse.deserializeBinary(new Uint8Array(buffer_arg)); } +function serialize_xudrpc_SubscribeAlertsRequest(arg) { + if (!(arg instanceof xudrpc_pb.SubscribeAlertsRequest)) { + throw new Error('Expected argument of type xudrpc.SubscribeAlertsRequest'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_xudrpc_SubscribeAlertsRequest(buffer_arg) { + return xudrpc_pb.SubscribeAlertsRequest.deserializeBinary(new Uint8Array(buffer_arg)); +} + function serialize_xudrpc_SubscribeOrdersRequest(arg) { if (!(arg instanceof xudrpc_pb.SubscribeOrdersRequest)) { throw new Error('Expected argument of type xudrpc.SubscribeOrdersRequest'); @@ -1157,6 +1179,18 @@ var XudService = exports.XudService = { responseSerialize: serialize_xudrpc_OrderUpdate, responseDeserialize: deserialize_xudrpc_OrderUpdate, }, + // Subscribes to alerts such as low balance. + subscribeAlerts: { + path: '/xudrpc.Xud/SubscribeAlerts', + requestStream: false, + responseStream: true, + requestType: xudrpc_pb.SubscribeAlertsRequest, + responseType: xudrpc_pb.Alert, + requestSerialize: serialize_xudrpc_SubscribeAlertsRequest, + requestDeserialize: deserialize_xudrpc_SubscribeAlertsRequest, + responseSerialize: serialize_xudrpc_Alert, + responseDeserialize: deserialize_xudrpc_Alert, + }, // Subscribes to failed swaps. By default, only swaps that are initiated by a remote peer are // transmitted unless a flag is set to include swaps initiated by the local node. This call allows // the client to get real-time notifications when swap attempts are failing. It can be used for diff --git a/lib/proto/xudrpc_pb.d.ts b/lib/proto/xudrpc_pb.d.ts index 880e1960d..b06bcd52f 100644 --- a/lib/proto/xudrpc_pb.d.ts +++ b/lib/proto/xudrpc_pb.d.ts @@ -65,6 +65,53 @@ export namespace AddPairResponse { } } +export class Alert extends jspb.Message { + getType(): Alert.AlertType; + setType(value: Alert.AlertType): void; + + getMessage(): string; + setMessage(value: string): void; + + + hasBalanceAlert(): boolean; + clearBalanceAlert(): void; + getBalanceAlert(): ChannelBalanceAlert | undefined; + setBalanceAlert(value?: ChannelBalanceAlert): void; + + + getPayloadCase(): Alert.PayloadCase; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Alert.AsObject; + static toObject(includeInstance: boolean, msg: Alert): Alert.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: Alert, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Alert; + static deserializeBinaryFromReader(message: Alert, reader: jspb.BinaryReader): Alert; +} + +export namespace Alert { + export type AsObject = { + type: Alert.AlertType, + message: string, + balanceAlert?: ChannelBalanceAlert.AsObject, + } + + export enum AlertType { + LOW_BALANCE = 0, + } + + + export enum PayloadCase { + PAYLOAD_NOT_SET = 0, + + BALANCE_ALERT = 3, + + } + +} + export class Balance extends jspb.Message { getTotalBalance(): number; setTotalBalance(value: number): void; @@ -202,6 +249,49 @@ export namespace Channels { } } +export class ChannelBalanceAlert extends jspb.Message { + getTotalBalance(): number; + setTotalBalance(value: number): void; + + getSide(): ChannelBalanceAlert.Side; + setSide(value: ChannelBalanceAlert.Side): void; + + getBound(): number; + setBound(value: number): void; + + getSideBalance(): number; + setSideBalance(value: number): void; + + getChannelPoint(): string; + setChannelPoint(value: string): void; + + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ChannelBalanceAlert.AsObject; + static toObject(includeInstance: boolean, msg: ChannelBalanceAlert): ChannelBalanceAlert.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ChannelBalanceAlert, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ChannelBalanceAlert; + static deserializeBinaryFromReader(message: ChannelBalanceAlert, reader: jspb.BinaryReader): ChannelBalanceAlert; +} + +export namespace ChannelBalanceAlert { + export type AsObject = { + totalBalance: number, + side: ChannelBalanceAlert.Side, + bound: number, + sideBalance: number, + channelPoint: string, + } + + export enum Side { + REMOTE = 0, + LOCAL = 1, + } + +} + export class CloseChannelRequest extends jspb.Message { getNodeIdentifier(): string; setNodeIdentifier(value: string): void; @@ -1767,6 +1857,23 @@ export namespace SubscribeOrdersRequest { } } +export class SubscribeAlertsRequest extends jspb.Message { + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SubscribeAlertsRequest.AsObject; + static toObject(includeInstance: boolean, msg: SubscribeAlertsRequest): SubscribeAlertsRequest.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: SubscribeAlertsRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SubscribeAlertsRequest; + static deserializeBinaryFromReader(message: SubscribeAlertsRequest, reader: jspb.BinaryReader): SubscribeAlertsRequest; +} + +export namespace SubscribeAlertsRequest { + export type AsObject = { + } +} + export class SubscribeSwapsAcceptedRequest extends jspb.Message { serializeBinary(): Uint8Array; diff --git a/lib/proto/xudrpc_pb.js b/lib/proto/xudrpc_pb.js index f2f59ddde..ffa5365e5 100644 --- a/lib/proto/xudrpc_pb.js +++ b/lib/proto/xudrpc_pb.js @@ -16,10 +16,14 @@ goog.object.extend(proto, annotations_pb); goog.exportSymbol('proto.xudrpc.AddCurrencyResponse', null, global); goog.exportSymbol('proto.xudrpc.AddPairRequest', null, global); goog.exportSymbol('proto.xudrpc.AddPairResponse', null, global); +goog.exportSymbol('proto.xudrpc.Alert', null, global); +goog.exportSymbol('proto.xudrpc.Alert.AlertType', null, global); goog.exportSymbol('proto.xudrpc.Balance', null, global); goog.exportSymbol('proto.xudrpc.BanRequest', null, global); goog.exportSymbol('proto.xudrpc.BanResponse', null, global); goog.exportSymbol('proto.xudrpc.Chain', null, global); +goog.exportSymbol('proto.xudrpc.ChannelBalanceAlert', null, global); +goog.exportSymbol('proto.xudrpc.ChannelBalanceAlert.Side', null, global); goog.exportSymbol('proto.xudrpc.Channels', null, global); goog.exportSymbol('proto.xudrpc.CloseChannelRequest', null, global); goog.exportSymbol('proto.xudrpc.CloseChannelResponse', null, global); @@ -80,6 +84,7 @@ goog.exportSymbol('proto.xudrpc.SetLogLevelRequest', null, global); goog.exportSymbol('proto.xudrpc.SetLogLevelResponse', null, global); goog.exportSymbol('proto.xudrpc.ShutdownRequest', null, global); goog.exportSymbol('proto.xudrpc.ShutdownResponse', null, global); +goog.exportSymbol('proto.xudrpc.SubscribeAlertsRequest', null, global); goog.exportSymbol('proto.xudrpc.SubscribeOrdersRequest', null, global); goog.exportSymbol('proto.xudrpc.SubscribeSwapsAcceptedRequest', null, global); goog.exportSymbol('proto.xudrpc.SubscribeSwapsRequest', null, global); @@ -500,6 +505,251 @@ proto.xudrpc.AddPairResponse.serializeBinaryToWriter = function(message, writer) +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.xudrpc.Alert = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, proto.xudrpc.Alert.oneofGroups_); +}; +goog.inherits(proto.xudrpc.Alert, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.xudrpc.Alert.displayName = 'proto.xudrpc.Alert'; +} +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.xudrpc.Alert.oneofGroups_ = [[3]]; + +/** + * @enum {number} + */ +proto.xudrpc.Alert.PayloadCase = { + PAYLOAD_NOT_SET: 0, + BALANCE_ALERT: 3 +}; + +/** + * @return {proto.xudrpc.Alert.PayloadCase} + */ +proto.xudrpc.Alert.prototype.getPayloadCase = function() { + return /** @type {proto.xudrpc.Alert.PayloadCase} */(jspb.Message.computeOneofCase(this, proto.xudrpc.Alert.oneofGroups_[0])); +}; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.xudrpc.Alert.prototype.toObject = function(opt_includeInstance) { + return proto.xudrpc.Alert.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.xudrpc.Alert} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.Alert.toObject = function(includeInstance, msg) { + var f, obj = { + type: jspb.Message.getFieldWithDefault(msg, 1, 0), + message: jspb.Message.getFieldWithDefault(msg, 2, ""), + balanceAlert: (f = msg.getBalanceAlert()) && proto.xudrpc.ChannelBalanceAlert.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.xudrpc.Alert} + */ +proto.xudrpc.Alert.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.xudrpc.Alert; + return proto.xudrpc.Alert.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.xudrpc.Alert} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.xudrpc.Alert} + */ +proto.xudrpc.Alert.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!proto.xudrpc.Alert.AlertType} */ (reader.readEnum()); + msg.setType(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setMessage(value); + break; + case 3: + var value = new proto.xudrpc.ChannelBalanceAlert; + reader.readMessage(value,proto.xudrpc.ChannelBalanceAlert.deserializeBinaryFromReader); + msg.setBalanceAlert(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.xudrpc.Alert.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.xudrpc.Alert.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.xudrpc.Alert} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.Alert.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getType(); + if (f !== 0.0) { + writer.writeEnum( + 1, + f + ); + } + f = message.getMessage(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getBalanceAlert(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.xudrpc.ChannelBalanceAlert.serializeBinaryToWriter + ); + } +}; + + +/** + * @enum {number} + */ +proto.xudrpc.Alert.AlertType = { + LOW_BALANCE: 0 +}; + +/** + * optional AlertType type = 1; + * @return {!proto.xudrpc.Alert.AlertType} + */ +proto.xudrpc.Alert.prototype.getType = function() { + return /** @type {!proto.xudrpc.Alert.AlertType} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** @param {!proto.xudrpc.Alert.AlertType} value */ +proto.xudrpc.Alert.prototype.setType = function(value) { + jspb.Message.setProto3EnumField(this, 1, value); +}; + + +/** + * optional string message = 2; + * @return {string} + */ +proto.xudrpc.Alert.prototype.getMessage = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** @param {string} value */ +proto.xudrpc.Alert.prototype.setMessage = function(value) { + jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional ChannelBalanceAlert balance_alert = 3; + * @return {?proto.xudrpc.ChannelBalanceAlert} + */ +proto.xudrpc.Alert.prototype.getBalanceAlert = function() { + return /** @type{?proto.xudrpc.ChannelBalanceAlert} */ ( + jspb.Message.getWrapperField(this, proto.xudrpc.ChannelBalanceAlert, 3)); +}; + + +/** @param {?proto.xudrpc.ChannelBalanceAlert|undefined} value */ +proto.xudrpc.Alert.prototype.setBalanceAlert = function(value) { + jspb.Message.setOneofWrapperField(this, 3, proto.xudrpc.Alert.oneofGroups_[0], value); +}; + + +proto.xudrpc.Alert.prototype.clearBalanceAlert = function() { + this.setBalanceAlert(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.xudrpc.Alert.prototype.hasBalanceAlert = function() { + return jspb.Message.getField(this, 3) != null; +}; + + + /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -1427,6 +1677,264 @@ proto.xudrpc.Channels.prototype.setClosed = function(value) { +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.xudrpc.ChannelBalanceAlert = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.xudrpc.ChannelBalanceAlert, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.xudrpc.ChannelBalanceAlert.displayName = 'proto.xudrpc.ChannelBalanceAlert'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.xudrpc.ChannelBalanceAlert.prototype.toObject = function(opt_includeInstance) { + return proto.xudrpc.ChannelBalanceAlert.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.xudrpc.ChannelBalanceAlert} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.ChannelBalanceAlert.toObject = function(includeInstance, msg) { + var f, obj = { + totalBalance: jspb.Message.getFieldWithDefault(msg, 1, 0), + side: jspb.Message.getFieldWithDefault(msg, 2, 0), + bound: jspb.Message.getFieldWithDefault(msg, 3, 0), + sideBalance: jspb.Message.getFieldWithDefault(msg, 4, 0), + channelPoint: jspb.Message.getFieldWithDefault(msg, 5, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.xudrpc.ChannelBalanceAlert} + */ +proto.xudrpc.ChannelBalanceAlert.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.xudrpc.ChannelBalanceAlert; + return proto.xudrpc.ChannelBalanceAlert.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.xudrpc.ChannelBalanceAlert} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.xudrpc.ChannelBalanceAlert} + */ +proto.xudrpc.ChannelBalanceAlert.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readUint64()); + msg.setTotalBalance(value); + break; + case 2: + var value = /** @type {!proto.xudrpc.ChannelBalanceAlert.Side} */ (reader.readEnum()); + msg.setSide(value); + break; + case 3: + var value = /** @type {number} */ (reader.readUint32()); + msg.setBound(value); + break; + case 4: + var value = /** @type {number} */ (reader.readUint64()); + msg.setSideBalance(value); + break; + case 5: + var value = /** @type {string} */ (reader.readString()); + msg.setChannelPoint(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.xudrpc.ChannelBalanceAlert.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.xudrpc.ChannelBalanceAlert.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.xudrpc.ChannelBalanceAlert} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.ChannelBalanceAlert.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTotalBalance(); + if (f !== 0) { + writer.writeUint64( + 1, + f + ); + } + f = message.getSide(); + if (f !== 0.0) { + writer.writeEnum( + 2, + f + ); + } + f = message.getBound(); + if (f !== 0) { + writer.writeUint32( + 3, + f + ); + } + f = message.getSideBalance(); + if (f !== 0) { + writer.writeUint64( + 4, + f + ); + } + f = message.getChannelPoint(); + if (f.length > 0) { + writer.writeString( + 5, + f + ); + } +}; + + +/** + * @enum {number} + */ +proto.xudrpc.ChannelBalanceAlert.Side = { + REMOTE: 0, + LOCAL: 1 +}; + +/** + * optional uint64 total_balance = 1; + * @return {number} + */ +proto.xudrpc.ChannelBalanceAlert.prototype.getTotalBalance = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** @param {number} value */ +proto.xudrpc.ChannelBalanceAlert.prototype.setTotalBalance = function(value) { + jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional Side side = 2; + * @return {!proto.xudrpc.ChannelBalanceAlert.Side} + */ +proto.xudrpc.ChannelBalanceAlert.prototype.getSide = function() { + return /** @type {!proto.xudrpc.ChannelBalanceAlert.Side} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** @param {!proto.xudrpc.ChannelBalanceAlert.Side} value */ +proto.xudrpc.ChannelBalanceAlert.prototype.setSide = function(value) { + jspb.Message.setProto3EnumField(this, 2, value); +}; + + +/** + * optional uint32 bound = 3; + * @return {number} + */ +proto.xudrpc.ChannelBalanceAlert.prototype.getBound = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** @param {number} value */ +proto.xudrpc.ChannelBalanceAlert.prototype.setBound = function(value) { + jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional uint64 side_balance = 4; + * @return {number} + */ +proto.xudrpc.ChannelBalanceAlert.prototype.getSideBalance = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** @param {number} value */ +proto.xudrpc.ChannelBalanceAlert.prototype.setSideBalance = function(value) { + jspb.Message.setProto3IntField(this, 4, value); +}; + + +/** + * optional string channel_point = 5; + * @return {string} + */ +proto.xudrpc.ChannelBalanceAlert.prototype.getChannelPoint = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +}; + + +/** @param {string} value */ +proto.xudrpc.ChannelBalanceAlert.prototype.setChannelPoint = function(value) { + jspb.Message.setProto3StringField(this, 5, value); +}; + + + /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -11888,6 +12396,122 @@ proto.xudrpc.SubscribeOrdersRequest.prototype.setExisting = function(value) { +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.xudrpc.SubscribeAlertsRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.xudrpc.SubscribeAlertsRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.xudrpc.SubscribeAlertsRequest.displayName = 'proto.xudrpc.SubscribeAlertsRequest'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.xudrpc.SubscribeAlertsRequest.prototype.toObject = function(opt_includeInstance) { + return proto.xudrpc.SubscribeAlertsRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.xudrpc.SubscribeAlertsRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.SubscribeAlertsRequest.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.xudrpc.SubscribeAlertsRequest} + */ +proto.xudrpc.SubscribeAlertsRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.xudrpc.SubscribeAlertsRequest; + return proto.xudrpc.SubscribeAlertsRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.xudrpc.SubscribeAlertsRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.xudrpc.SubscribeAlertsRequest} + */ +proto.xudrpc.SubscribeAlertsRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.xudrpc.SubscribeAlertsRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.xudrpc.SubscribeAlertsRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.xudrpc.SubscribeAlertsRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.SubscribeAlertsRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a diff --git a/lib/service/Service.ts b/lib/service/Service.ts index 1b09ad706..99f71798c 100644 --- a/lib/service/Service.ts +++ b/lib/service/Service.ts @@ -2,7 +2,7 @@ import { EventEmitter } from 'events'; import { fromEvent, merge, Observable } from 'rxjs'; import { takeUntil } from 'rxjs/operators'; import { ProvidePreimageEvent, TransferReceivedEvent } from '../connextclient/types'; -import { OrderSide, Owner, SwapClientType, SwapRole } from '../constants/enums'; +import { AlertType, OrderSide, Owner, SwapClientType, SwapRole } from '../constants/enums'; import { OrderAttributes, TradeInstance } from '../db/types'; import Logger, { Level, LevelPriority } from '../Logger'; import OrderBook from '../orderbook/OrderBook'; @@ -12,7 +12,7 @@ import swapsErrors from '../swaps/errors'; import { ChannelBalance } from '../swaps/SwapClient'; import SwapClientManager from '../swaps/SwapClientManager'; import Swaps from '../swaps/Swaps'; -import { ResolveRequest, SwapAccepted, SwapDeal, SwapFailure, SwapSuccess, TradingLimits } from '../swaps/types'; +import { ChannelBalanceAlert, ResolveRequest, SwapAccepted, SwapDeal, SwapFailure, SwapSuccess, TradingLimits } from '../swaps/types'; import { isNodePubKey } from '../utils/aliasUtils'; import { parseUri, toUri, UriParts } from '../utils/uriUtils'; import { checkDecimalPlaces, sortOrders, toEip55Address } from '../utils/utils'; @@ -693,6 +693,29 @@ class Service extends EventEmitter { const nodePubKey = isNodePubKey(args.nodeIdentifier) ? args.nodeIdentifier : this.pool.resolveAlias(args.nodeIdentifier); return this.pool.discoverNodes(nodePubKey); } + /* + * Subscribe to alerts. + */ + public subscribeAlerts = ( + callback: (type: AlertType, message: string, payload: ChannelBalanceAlert) => void, + cancelled$: Observable, + ) => { + const noBalanceObservables: Observable[] = []; + this.swapClientManager.swapClients.forEach((swapClient) => { + noBalanceObservables.push(fromEvent(swapClient, 'lowBalance')); + }); + + const noBalance$ = merge(...noBalanceObservables).pipe(takeUntil(cancelled$)); // cleanup listeners when cancelled$ emits a value + noBalance$.subscribe({ + next: (alert) => { + callback( + AlertType.LowBalance, + `${alert.side} channel balance is lower than ${alert.totalBalance} for ${alert.currency} by ${alert.bound}%`, + alert); + }, + error: this.logger.error, + }); + } /* * Subscribe to orders being added to the order book. diff --git a/lib/swaps/SwapClient.ts b/lib/swaps/SwapClient.ts index 8eb61526e..d3fda615e 100644 --- a/lib/swaps/SwapClient.ts +++ b/lib/swaps/SwapClient.ts @@ -34,6 +34,8 @@ type ChannelBalance = { pendingOpenBalance: number, /** The cumulative balance of inactive channels denominated in satoshis. */ inactiveBalance: number, + /** The channel balances by channel point. */ + balancePerChannel?: Map, }; type WalletBalance = { @@ -69,6 +71,13 @@ export type WithdrawArguments = { fee?: number, }; +export type Balance = { + /** The local balance of the channel. */ + localBalance: number, + /** The remote balance of the channel. */ + remoteBalance: number, +}; + interface SwapClient { on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; once(event: 'initialized', listener: () => void): this; diff --git a/lib/swaps/types.ts b/lib/swaps/types.ts index 50fe23222..c84075ff9 100644 --- a/lib/swaps/types.ts +++ b/lib/swaps/types.ts @@ -2,7 +2,7 @@ import { SwapRole, SwapPhase, SwapState, - SwapFailureReason, + SwapFailureReason, ChannelBalanceSide, } from '../constants/enums'; export type SwapDeal = { @@ -172,3 +172,18 @@ export type OpenChannelParams = { /** The fee in sat per byte. */ fee?: number, }; + +export type ChannelBalanceAlert = { + /** The total balance of the channel when the alert is triggered. */ + totalBalance: number, + /** The side of the balance either local or remote. */ + side: ChannelBalanceSide, + /** The balance that triggered the alert. */ + sideBalance: number, + /** The alert threshold in percentage, e.g. 10 means %10. */ + bound: number, + /** The point of the channel. */ + channelPoint: string, + /** The currency of the channel. */ + currency: string, +}; diff --git a/proto/xudrpc.proto b/proto/xudrpc.proto index cc18bba6a..e549fda59 100644 --- a/proto/xudrpc.proto +++ b/proto/xudrpc.proto @@ -279,6 +279,13 @@ service Xud { }; } + /* Subscribes to alerts such as low balance. */ + rpc SubscribeAlerts(SubscribeAlertsRequest) returns (stream Alert) { + option (google.api.http) = { + get: "/v1/subscribealerts" + }; + } + /* Subscribes to failed swaps. By default, only swaps that are initiated by a remote peer are * transmitted unless a flag is set to include swaps initiated by the local node. This call allows * the client to get real-time notifications when swap attempts are failing. It can be used for @@ -376,6 +383,20 @@ message AddPairRequest { } message AddPairResponse {} +message Alert { + // The type of the alert. + enum AlertType { + LOW_BALANCE = 0; + } + AlertType type = 1 [json_name = "type"]; + // The human readable alert message. + string message = 2 [json_name = "message"]; + // The structured payload. + oneof payload { + ChannelBalanceAlert balance_alert = 3 [json_name = "balance_alert"]; + } +} + message Balance { // Total balance denominated in satoshis. uint64 total_balance = 1 [json_name = "total_balance"]; @@ -415,6 +436,23 @@ message Channels { uint32 closed = 4 [json_name = "closed"]; } +message ChannelBalanceAlert { + // The total balance of the channel. + uint64 total_balance = 1 [json_name = "total_balance"]; + // The side of the low balance. + enum Side { + REMOTE = 0; + LOCAL = 1; + } + Side side = 2 [json_name = "side"]; + // The bound of the low balance in percentage. + uint32 bound = 3 [json_name = "bound"]; + // The current side balance. + uint64 side_balance = 4 [json_name = "side_balance"]; + // The point of the channel. + string channel_point = 5 [json_name = "channel_point"]; +} + message CloseChannelRequest { // The node pub key or alias of the peer with which to close any channels with. string node_identifier = 1 [json_name = "node_identifier"]; @@ -818,6 +856,9 @@ message SubscribeOrdersRequest { bool existing = 1 [json_name = "existing"]; } +message SubscribeAlertsRequest { +} + message SubscribeSwapsAcceptedRequest { } message SubscribeSwapsRequest { diff --git a/test/simulation/xudrpc/xudrpc.pb.go b/test/simulation/xudrpc/xudrpc.pb.go index c2964e9d8..50c1a8dc1 100644 --- a/test/simulation/xudrpc/xudrpc.pb.go +++ b/test/simulation/xudrpc/xudrpc.pb.go @@ -119,6 +119,55 @@ func (LogLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor_6960a02cc0a63cf6, []int{2} } +// The type of the alert. +type Alert_AlertType int32 + +const ( + Alert_LOW_BALANCE Alert_AlertType = 0 +) + +var Alert_AlertType_name = map[int32]string{ + 0: "LOW_BALANCE", +} + +var Alert_AlertType_value = map[string]int32{ + "LOW_BALANCE": 0, +} + +func (x Alert_AlertType) String() string { + return proto.EnumName(Alert_AlertType_name, int32(x)) +} + +func (Alert_AlertType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{3, 0} +} + +// The side of the low balance. +type ChannelBalanceAlert_Side int32 + +const ( + ChannelBalanceAlert_REMOTE ChannelBalanceAlert_Side = 0 + ChannelBalanceAlert_LOCAL ChannelBalanceAlert_Side = 1 +) + +var ChannelBalanceAlert_Side_name = map[int32]string{ + 0: "REMOTE", + 1: "LOCAL", +} + +var ChannelBalanceAlert_Side_value = map[string]int32{ + "REMOTE": 0, + "LOCAL": 1, +} + +func (x ChannelBalanceAlert_Side) String() string { + return proto.EnumName(ChannelBalanceAlert_Side_name, int32(x)) +} + +func (ChannelBalanceAlert_Side) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{9, 0} +} + type Currency_SwapClient int32 const ( @@ -141,7 +190,7 @@ func (x Currency_SwapClient) String() string { } func (Currency_SwapClient) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{14, 0} + return fileDescriptor_6960a02cc0a63cf6, []int{16, 0} } type ListOrdersRequest_Owner int32 @@ -169,7 +218,7 @@ func (x ListOrdersRequest_Owner) String() string { } func (ListOrdersRequest_Owner) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{28, 0} + return fileDescriptor_6960a02cc0a63cf6, []int{30, 0} } type AddCurrencyResponse struct { @@ -283,6 +332,90 @@ func (m *AddPairResponse) XXX_DiscardUnknown() { var xxx_messageInfo_AddPairResponse proto.InternalMessageInfo +type Alert struct { + Type Alert_AlertType `protobuf:"varint,1,opt,name=type,proto3,enum=xudrpc.Alert_AlertType" json:"type,omitempty"` + // The human readable alert message. + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + // The structured payload. + // + // Types that are valid to be assigned to Payload: + // *Alert_BalanceAlert + Payload isAlert_Payload `protobuf_oneof:"payload"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Alert) Reset() { *m = Alert{} } +func (m *Alert) String() string { return proto.CompactTextString(m) } +func (*Alert) ProtoMessage() {} +func (*Alert) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{3} +} + +func (m *Alert) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Alert.Unmarshal(m, b) +} +func (m *Alert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Alert.Marshal(b, m, deterministic) +} +func (m *Alert) XXX_Merge(src proto.Message) { + xxx_messageInfo_Alert.Merge(m, src) +} +func (m *Alert) XXX_Size() int { + return xxx_messageInfo_Alert.Size(m) +} +func (m *Alert) XXX_DiscardUnknown() { + xxx_messageInfo_Alert.DiscardUnknown(m) +} + +var xxx_messageInfo_Alert proto.InternalMessageInfo + +func (m *Alert) GetType() Alert_AlertType { + if m != nil { + return m.Type + } + return Alert_LOW_BALANCE +} + +func (m *Alert) GetMessage() string { + if m != nil { + return m.Message + } + return "" +} + +type isAlert_Payload interface { + isAlert_Payload() +} + +type Alert_BalanceAlert struct { + BalanceAlert *ChannelBalanceAlert `protobuf:"bytes,3,opt,name=balance_alert,proto3,oneof"` +} + +func (*Alert_BalanceAlert) isAlert_Payload() {} + +func (m *Alert) GetPayload() isAlert_Payload { + if m != nil { + return m.Payload + } + return nil +} + +func (m *Alert) GetBalanceAlert() *ChannelBalanceAlert { + if x, ok := m.GetPayload().(*Alert_BalanceAlert); ok { + return x.BalanceAlert + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*Alert) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*Alert_BalanceAlert)(nil), + } +} + type Balance struct { // Total balance denominated in satoshis. TotalBalance uint64 `protobuf:"varint,1,opt,name=total_balance,proto3" json:"total_balance,omitempty"` @@ -305,7 +438,7 @@ func (m *Balance) Reset() { *m = Balance{} } func (m *Balance) String() string { return proto.CompactTextString(m) } func (*Balance) ProtoMessage() {} func (*Balance) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{3} + return fileDescriptor_6960a02cc0a63cf6, []int{4} } func (m *Balance) XXX_Unmarshal(b []byte) error { @@ -380,7 +513,7 @@ func (m *BanRequest) Reset() { *m = BanRequest{} } func (m *BanRequest) String() string { return proto.CompactTextString(m) } func (*BanRequest) ProtoMessage() {} func (*BanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{4} + return fileDescriptor_6960a02cc0a63cf6, []int{5} } func (m *BanRequest) XXX_Unmarshal(b []byte) error { @@ -418,7 +551,7 @@ func (m *BanResponse) Reset() { *m = BanResponse{} } func (m *BanResponse) String() string { return proto.CompactTextString(m) } func (*BanResponse) ProtoMessage() {} func (*BanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{5} + return fileDescriptor_6960a02cc0a63cf6, []int{6} } func (m *BanResponse) XXX_Unmarshal(b []byte) error { @@ -453,7 +586,7 @@ func (m *Chain) Reset() { *m = Chain{} } func (m *Chain) String() string { return proto.CompactTextString(m) } func (*Chain) ProtoMessage() {} func (*Chain) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{6} + return fileDescriptor_6960a02cc0a63cf6, []int{7} } func (m *Chain) XXX_Unmarshal(b []byte) error { @@ -506,7 +639,7 @@ func (m *Channels) Reset() { *m = Channels{} } func (m *Channels) String() string { return proto.CompactTextString(m) } func (*Channels) ProtoMessage() {} func (*Channels) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{7} + return fileDescriptor_6960a02cc0a63cf6, []int{8} } func (m *Channels) XXX_Unmarshal(b []byte) error { @@ -555,6 +688,81 @@ func (m *Channels) GetClosed() uint32 { return 0 } +type ChannelBalanceAlert struct { + // The total balance of the channel. + TotalBalance uint64 `protobuf:"varint,1,opt,name=total_balance,proto3" json:"total_balance,omitempty"` + Side ChannelBalanceAlert_Side `protobuf:"varint,2,opt,name=side,proto3,enum=xudrpc.ChannelBalanceAlert_Side" json:"side,omitempty"` + // The bound of the low balance in percentage. + Bound uint32 `protobuf:"varint,3,opt,name=bound,proto3" json:"bound,omitempty"` + // The current side balance. + SideBalance uint64 `protobuf:"varint,4,opt,name=side_balance,proto3" json:"side_balance,omitempty"` + // The point of the channel. + ChannelPoint string `protobuf:"bytes,5,opt,name=channel_point,proto3" json:"channel_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelBalanceAlert) Reset() { *m = ChannelBalanceAlert{} } +func (m *ChannelBalanceAlert) String() string { return proto.CompactTextString(m) } +func (*ChannelBalanceAlert) ProtoMessage() {} +func (*ChannelBalanceAlert) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{9} +} + +func (m *ChannelBalanceAlert) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelBalanceAlert.Unmarshal(m, b) +} +func (m *ChannelBalanceAlert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelBalanceAlert.Marshal(b, m, deterministic) +} +func (m *ChannelBalanceAlert) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelBalanceAlert.Merge(m, src) +} +func (m *ChannelBalanceAlert) XXX_Size() int { + return xxx_messageInfo_ChannelBalanceAlert.Size(m) +} +func (m *ChannelBalanceAlert) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelBalanceAlert.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelBalanceAlert proto.InternalMessageInfo + +func (m *ChannelBalanceAlert) GetTotalBalance() uint64 { + if m != nil { + return m.TotalBalance + } + return 0 +} + +func (m *ChannelBalanceAlert) GetSide() ChannelBalanceAlert_Side { + if m != nil { + return m.Side + } + return ChannelBalanceAlert_REMOTE +} + +func (m *ChannelBalanceAlert) GetBound() uint32 { + if m != nil { + return m.Bound + } + return 0 +} + +func (m *ChannelBalanceAlert) GetSideBalance() uint64 { + if m != nil { + return m.SideBalance + } + return 0 +} + +func (m *ChannelBalanceAlert) GetChannelPoint() string { + if m != nil { + return m.ChannelPoint + } + return "" +} + type CloseChannelRequest struct { // The node pub key or alias of the peer with which to close any channels with. NodeIdentifier string `protobuf:"bytes,1,opt,name=node_identifier,proto3" json:"node_identifier,omitempty"` @@ -580,7 +788,7 @@ func (m *CloseChannelRequest) Reset() { *m = CloseChannelRequest{} } func (m *CloseChannelRequest) String() string { return proto.CompactTextString(m) } func (*CloseChannelRequest) ProtoMessage() {} func (*CloseChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{8} + return fileDescriptor_6960a02cc0a63cf6, []int{10} } func (m *CloseChannelRequest) XXX_Unmarshal(b []byte) error { @@ -655,7 +863,7 @@ func (m *CloseChannelResponse) Reset() { *m = CloseChannelResponse{} } func (m *CloseChannelResponse) String() string { return proto.CompactTextString(m) } func (*CloseChannelResponse) ProtoMessage() {} func (*CloseChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{9} + return fileDescriptor_6960a02cc0a63cf6, []int{11} } func (m *CloseChannelResponse) XXX_Unmarshal(b []byte) error { @@ -695,7 +903,7 @@ func (m *ConnectRequest) Reset() { *m = ConnectRequest{} } func (m *ConnectRequest) String() string { return proto.CompactTextString(m) } func (*ConnectRequest) ProtoMessage() {} func (*ConnectRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{10} + return fileDescriptor_6960a02cc0a63cf6, []int{12} } func (m *ConnectRequest) XXX_Unmarshal(b []byte) error { @@ -733,7 +941,7 @@ func (m *ConnectResponse) Reset() { *m = ConnectResponse{} } func (m *ConnectResponse) String() string { return proto.CompactTextString(m) } func (*ConnectResponse) ProtoMessage() {} func (*ConnectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{11} + return fileDescriptor_6960a02cc0a63cf6, []int{13} } func (m *ConnectResponse) XXX_Unmarshal(b []byte) error { @@ -767,7 +975,7 @@ func (m *CreateNodeRequest) Reset() { *m = CreateNodeRequest{} } func (m *CreateNodeRequest) String() string { return proto.CompactTextString(m) } func (*CreateNodeRequest) ProtoMessage() {} func (*CreateNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{12} + return fileDescriptor_6960a02cc0a63cf6, []int{14} } func (m *CreateNodeRequest) XXX_Unmarshal(b []byte) error { @@ -811,7 +1019,7 @@ func (m *CreateNodeResponse) Reset() { *m = CreateNodeResponse{} } func (m *CreateNodeResponse) String() string { return proto.CompactTextString(m) } func (*CreateNodeResponse) ProtoMessage() {} func (*CreateNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{13} + return fileDescriptor_6960a02cc0a63cf6, []int{15} } func (m *CreateNodeResponse) XXX_Unmarshal(b []byte) error { @@ -875,7 +1083,7 @@ func (m *Currency) Reset() { *m = Currency{} } func (m *Currency) String() string { return proto.CompactTextString(m) } func (*Currency) ProtoMessage() {} func (*Currency) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{14} + return fileDescriptor_6960a02cc0a63cf6, []int{16} } func (m *Currency) XXX_Unmarshal(b []byte) error { @@ -936,7 +1144,7 @@ func (m *DepositRequest) Reset() { *m = DepositRequest{} } func (m *DepositRequest) String() string { return proto.CompactTextString(m) } func (*DepositRequest) ProtoMessage() {} func (*DepositRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{15} + return fileDescriptor_6960a02cc0a63cf6, []int{17} } func (m *DepositRequest) XXX_Unmarshal(b []byte) error { @@ -976,7 +1184,7 @@ func (m *DepositResponse) Reset() { *m = DepositResponse{} } func (m *DepositResponse) String() string { return proto.CompactTextString(m) } func (*DepositResponse) ProtoMessage() {} func (*DepositResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{16} + return fileDescriptor_6960a02cc0a63cf6, []int{18} } func (m *DepositResponse) XXX_Unmarshal(b []byte) error { @@ -1016,7 +1224,7 @@ func (m *DiscoverNodesRequest) Reset() { *m = DiscoverNodesRequest{} } func (m *DiscoverNodesRequest) String() string { return proto.CompactTextString(m) } func (*DiscoverNodesRequest) ProtoMessage() {} func (*DiscoverNodesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{17} + return fileDescriptor_6960a02cc0a63cf6, []int{19} } func (m *DiscoverNodesRequest) XXX_Unmarshal(b []byte) error { @@ -1055,7 +1263,7 @@ func (m *DiscoverNodesResponse) Reset() { *m = DiscoverNodesResponse{} } func (m *DiscoverNodesResponse) String() string { return proto.CompactTextString(m) } func (*DiscoverNodesResponse) ProtoMessage() {} func (*DiscoverNodesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{18} + return fileDescriptor_6960a02cc0a63cf6, []int{20} } func (m *DiscoverNodesResponse) XXX_Unmarshal(b []byte) error { @@ -1101,7 +1309,7 @@ func (m *ExecuteSwapRequest) Reset() { *m = ExecuteSwapRequest{} } func (m *ExecuteSwapRequest) String() string { return proto.CompactTextString(m) } func (*ExecuteSwapRequest) ProtoMessage() {} func (*ExecuteSwapRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{19} + return fileDescriptor_6960a02cc0a63cf6, []int{21} } func (m *ExecuteSwapRequest) XXX_Unmarshal(b []byte) error { @@ -1163,7 +1371,7 @@ func (m *GetBalanceRequest) Reset() { *m = GetBalanceRequest{} } func (m *GetBalanceRequest) String() string { return proto.CompactTextString(m) } func (*GetBalanceRequest) ProtoMessage() {} func (*GetBalanceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{20} + return fileDescriptor_6960a02cc0a63cf6, []int{22} } func (m *GetBalanceRequest) XXX_Unmarshal(b []byte) error { @@ -1203,7 +1411,7 @@ func (m *GetBalanceResponse) Reset() { *m = GetBalanceResponse{} } func (m *GetBalanceResponse) String() string { return proto.CompactTextString(m) } func (*GetBalanceResponse) ProtoMessage() {} func (*GetBalanceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{21} + return fileDescriptor_6960a02cc0a63cf6, []int{23} } func (m *GetBalanceResponse) XXX_Unmarshal(b []byte) error { @@ -1241,7 +1449,7 @@ func (m *GetInfoRequest) Reset() { *m = GetInfoRequest{} } func (m *GetInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetInfoRequest) ProtoMessage() {} func (*GetInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{22} + return fileDescriptor_6960a02cc0a63cf6, []int{24} } func (m *GetInfoRequest) XXX_Unmarshal(b []byte) error { @@ -1291,7 +1499,7 @@ func (m *GetInfoResponse) Reset() { *m = GetInfoResponse{} } func (m *GetInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetInfoResponse) ProtoMessage() {} func (*GetInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{23} + return fileDescriptor_6960a02cc0a63cf6, []int{25} } func (m *GetInfoResponse) XXX_Unmarshal(b []byte) error { @@ -1401,7 +1609,7 @@ func (m *GetNodeInfoRequest) Reset() { *m = GetNodeInfoRequest{} } func (m *GetNodeInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetNodeInfoRequest) ProtoMessage() {} func (*GetNodeInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{24} + return fileDescriptor_6960a02cc0a63cf6, []int{26} } func (m *GetNodeInfoRequest) XXX_Unmarshal(b []byte) error { @@ -1444,7 +1652,7 @@ func (m *GetNodeInfoResponse) Reset() { *m = GetNodeInfoResponse{} } func (m *GetNodeInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetNodeInfoResponse) ProtoMessage() {} func (*GetNodeInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{25} + return fileDescriptor_6960a02cc0a63cf6, []int{27} } func (m *GetNodeInfoResponse) XXX_Unmarshal(b []byte) error { @@ -1489,7 +1697,7 @@ func (m *ListCurrenciesRequest) Reset() { *m = ListCurrenciesRequest{} } func (m *ListCurrenciesRequest) String() string { return proto.CompactTextString(m) } func (*ListCurrenciesRequest) ProtoMessage() {} func (*ListCurrenciesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{26} + return fileDescriptor_6960a02cc0a63cf6, []int{28} } func (m *ListCurrenciesRequest) XXX_Unmarshal(b []byte) error { @@ -1522,7 +1730,7 @@ func (m *ListCurrenciesResponse) Reset() { *m = ListCurrenciesResponse{} func (m *ListCurrenciesResponse) String() string { return proto.CompactTextString(m) } func (*ListCurrenciesResponse) ProtoMessage() {} func (*ListCurrenciesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{27} + return fileDescriptor_6960a02cc0a63cf6, []int{29} } func (m *ListCurrenciesResponse) XXX_Unmarshal(b []byte) error { @@ -1568,7 +1776,7 @@ func (m *ListOrdersRequest) Reset() { *m = ListOrdersRequest{} } func (m *ListOrdersRequest) String() string { return proto.CompactTextString(m) } func (*ListOrdersRequest) ProtoMessage() {} func (*ListOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{28} + return fileDescriptor_6960a02cc0a63cf6, []int{30} } func (m *ListOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -1629,7 +1837,7 @@ func (m *ListOrdersResponse) Reset() { *m = ListOrdersResponse{} } func (m *ListOrdersResponse) String() string { return proto.CompactTextString(m) } func (*ListOrdersResponse) ProtoMessage() {} func (*ListOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{29} + return fileDescriptor_6960a02cc0a63cf6, []int{31} } func (m *ListOrdersResponse) XXX_Unmarshal(b []byte) error { @@ -1667,7 +1875,7 @@ func (m *ListPairsRequest) Reset() { *m = ListPairsRequest{} } func (m *ListPairsRequest) String() string { return proto.CompactTextString(m) } func (*ListPairsRequest) ProtoMessage() {} func (*ListPairsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{30} + return fileDescriptor_6960a02cc0a63cf6, []int{32} } func (m *ListPairsRequest) XXX_Unmarshal(b []byte) error { @@ -1700,7 +1908,7 @@ func (m *ListPairsResponse) Reset() { *m = ListPairsResponse{} } func (m *ListPairsResponse) String() string { return proto.CompactTextString(m) } func (*ListPairsResponse) ProtoMessage() {} func (*ListPairsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{31} + return fileDescriptor_6960a02cc0a63cf6, []int{33} } func (m *ListPairsResponse) XXX_Unmarshal(b []byte) error { @@ -1738,7 +1946,7 @@ func (m *ListPeersRequest) Reset() { *m = ListPeersRequest{} } func (m *ListPeersRequest) String() string { return proto.CompactTextString(m) } func (*ListPeersRequest) ProtoMessage() {} func (*ListPeersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{32} + return fileDescriptor_6960a02cc0a63cf6, []int{34} } func (m *ListPeersRequest) XXX_Unmarshal(b []byte) error { @@ -1771,7 +1979,7 @@ func (m *ListPeersResponse) Reset() { *m = ListPeersResponse{} } func (m *ListPeersResponse) String() string { return proto.CompactTextString(m) } func (*ListPeersResponse) ProtoMessage() {} func (*ListPeersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{33} + return fileDescriptor_6960a02cc0a63cf6, []int{35} } func (m *ListPeersResponse) XXX_Unmarshal(b []byte) error { @@ -1816,7 +2024,7 @@ func (m *LndInfo) Reset() { *m = LndInfo{} } func (m *LndInfo) String() string { return proto.CompactTextString(m) } func (*LndInfo) ProtoMessage() {} func (*LndInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{34} + return fileDescriptor_6960a02cc0a63cf6, []int{36} } func (m *LndInfo) XXX_Unmarshal(b []byte) error { @@ -1900,7 +2108,7 @@ func (m *NodeIdentifier) Reset() { *m = NodeIdentifier{} } func (m *NodeIdentifier) String() string { return proto.CompactTextString(m) } func (*NodeIdentifier) ProtoMessage() {} func (*NodeIdentifier) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{35} + return fileDescriptor_6960a02cc0a63cf6, []int{37} } func (m *NodeIdentifier) XXX_Unmarshal(b []byte) error { @@ -1955,7 +2163,7 @@ func (m *OpenChannelRequest) Reset() { *m = OpenChannelRequest{} } func (m *OpenChannelRequest) String() string { return proto.CompactTextString(m) } func (*OpenChannelRequest) ProtoMessage() {} func (*OpenChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{36} + return fileDescriptor_6960a02cc0a63cf6, []int{38} } func (m *OpenChannelRequest) XXX_Unmarshal(b []byte) error { @@ -2023,7 +2231,7 @@ func (m *OpenChannelResponse) Reset() { *m = OpenChannelResponse{} } func (m *OpenChannelResponse) String() string { return proto.CompactTextString(m) } func (*OpenChannelResponse) ProtoMessage() {} func (*OpenChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{37} + return fileDescriptor_6960a02cc0a63cf6, []int{39} } func (m *OpenChannelResponse) XXX_Unmarshal(b []byte) error { @@ -2081,7 +2289,7 @@ func (m *Order) Reset() { *m = Order{} } func (m *Order) String() string { return proto.CompactTextString(m) } func (*Order) ProtoMessage() {} func (*Order) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{38} + return fileDescriptor_6960a02cc0a63cf6, []int{40} } func (m *Order) XXX_Unmarshal(b []byte) error { @@ -2192,7 +2400,7 @@ func (m *OrderRemoval) Reset() { *m = OrderRemoval{} } func (m *OrderRemoval) String() string { return proto.CompactTextString(m) } func (*OrderRemoval) ProtoMessage() {} func (*OrderRemoval) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{39} + return fileDescriptor_6960a02cc0a63cf6, []int{41} } func (m *OrderRemoval) XXX_Unmarshal(b []byte) error { @@ -2262,7 +2470,7 @@ func (m *Orders) Reset() { *m = Orders{} } func (m *Orders) String() string { return proto.CompactTextString(m) } func (*Orders) ProtoMessage() {} func (*Orders) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{40} + return fileDescriptor_6960a02cc0a63cf6, []int{42} } func (m *Orders) XXX_Unmarshal(b []byte) error { @@ -2311,7 +2519,7 @@ func (m *OrdersCount) Reset() { *m = OrdersCount{} } func (m *OrdersCount) String() string { return proto.CompactTextString(m) } func (*OrdersCount) ProtoMessage() {} func (*OrdersCount) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{41} + return fileDescriptor_6960a02cc0a63cf6, []int{43} } func (m *OrdersCount) XXX_Unmarshal(b []byte) error { @@ -2360,7 +2568,7 @@ func (m *OrderUpdate) Reset() { *m = OrderUpdate{} } func (m *OrderUpdate) String() string { return proto.CompactTextString(m) } func (*OrderUpdate) ProtoMessage() {} func (*OrderUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{42} + return fileDescriptor_6960a02cc0a63cf6, []int{44} } func (m *OrderUpdate) XXX_Unmarshal(b []byte) error { @@ -2452,7 +2660,7 @@ func (m *Peer) Reset() { *m = Peer{} } func (m *Peer) String() string { return proto.CompactTextString(m) } func (*Peer) ProtoMessage() {} func (*Peer) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{43} + return fileDescriptor_6960a02cc0a63cf6, []int{45} } func (m *Peer) XXX_Unmarshal(b []byte) error { @@ -2554,7 +2762,7 @@ func (m *PlaceOrderRequest) Reset() { *m = PlaceOrderRequest{} } func (m *PlaceOrderRequest) String() string { return proto.CompactTextString(m) } func (*PlaceOrderRequest) ProtoMessage() {} func (*PlaceOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{44} + return fileDescriptor_6960a02cc0a63cf6, []int{46} } func (m *PlaceOrderRequest) XXX_Unmarshal(b []byte) error { @@ -2642,7 +2850,7 @@ func (m *PlaceOrderResponse) Reset() { *m = PlaceOrderResponse{} } func (m *PlaceOrderResponse) String() string { return proto.CompactTextString(m) } func (*PlaceOrderResponse) ProtoMessage() {} func (*PlaceOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{45} + return fileDescriptor_6960a02cc0a63cf6, []int{47} } func (m *PlaceOrderResponse) XXX_Unmarshal(b []byte) error { @@ -2707,7 +2915,7 @@ func (m *PlaceOrderEvent) Reset() { *m = PlaceOrderEvent{} } func (m *PlaceOrderEvent) String() string { return proto.CompactTextString(m) } func (*PlaceOrderEvent) ProtoMessage() {} func (*PlaceOrderEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{46} + return fileDescriptor_6960a02cc0a63cf6, []int{48} } func (m *PlaceOrderEvent) XXX_Unmarshal(b []byte) error { @@ -2815,7 +3023,7 @@ func (m *ConnextInfo) Reset() { *m = ConnextInfo{} } func (m *ConnextInfo) String() string { return proto.CompactTextString(m) } func (*ConnextInfo) ProtoMessage() {} func (*ConnextInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{47} + return fileDescriptor_6960a02cc0a63cf6, []int{49} } func (m *ConnextInfo) XXX_Unmarshal(b []byte) error { @@ -2876,7 +3084,7 @@ func (m *RemoveCurrencyRequest) Reset() { *m = RemoveCurrencyRequest{} } func (m *RemoveCurrencyRequest) String() string { return proto.CompactTextString(m) } func (*RemoveCurrencyRequest) ProtoMessage() {} func (*RemoveCurrencyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{48} + return fileDescriptor_6960a02cc0a63cf6, []int{50} } func (m *RemoveCurrencyRequest) XXX_Unmarshal(b []byte) error { @@ -2914,7 +3122,7 @@ func (m *RemoveCurrencyResponse) Reset() { *m = RemoveCurrencyResponse{} func (m *RemoveCurrencyResponse) String() string { return proto.CompactTextString(m) } func (*RemoveCurrencyResponse) ProtoMessage() {} func (*RemoveCurrencyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{49} + return fileDescriptor_6960a02cc0a63cf6, []int{51} } func (m *RemoveCurrencyResponse) XXX_Unmarshal(b []byte) error { @@ -2950,7 +3158,7 @@ func (m *RemoveOrderRequest) Reset() { *m = RemoveOrderRequest{} } func (m *RemoveOrderRequest) String() string { return proto.CompactTextString(m) } func (*RemoveOrderRequest) ProtoMessage() {} func (*RemoveOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{50} + return fileDescriptor_6960a02cc0a63cf6, []int{52} } func (m *RemoveOrderRequest) XXX_Unmarshal(b []byte) error { @@ -2998,7 +3206,7 @@ func (m *RemoveOrderResponse) Reset() { *m = RemoveOrderResponse{} } func (m *RemoveOrderResponse) String() string { return proto.CompactTextString(m) } func (*RemoveOrderResponse) ProtoMessage() {} func (*RemoveOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{51} + return fileDescriptor_6960a02cc0a63cf6, []int{53} } func (m *RemoveOrderResponse) XXX_Unmarshal(b []byte) error { @@ -3036,7 +3244,7 @@ func (m *RemoveAllOrdersRequest) Reset() { *m = RemoveAllOrdersRequest{} func (m *RemoveAllOrdersRequest) String() string { return proto.CompactTextString(m) } func (*RemoveAllOrdersRequest) ProtoMessage() {} func (*RemoveAllOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{52} + return fileDescriptor_6960a02cc0a63cf6, []int{54} } func (m *RemoveAllOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -3071,7 +3279,7 @@ func (m *RemoveAllOrdersResponse) Reset() { *m = RemoveAllOrdersResponse func (m *RemoveAllOrdersResponse) String() string { return proto.CompactTextString(m) } func (*RemoveAllOrdersResponse) ProtoMessage() {} func (*RemoveAllOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{53} + return fileDescriptor_6960a02cc0a63cf6, []int{55} } func (m *RemoveAllOrdersResponse) XXX_Unmarshal(b []byte) error { @@ -3118,7 +3326,7 @@ func (m *RemovePairRequest) Reset() { *m = RemovePairRequest{} } func (m *RemovePairRequest) String() string { return proto.CompactTextString(m) } func (*RemovePairRequest) ProtoMessage() {} func (*RemovePairRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{54} + return fileDescriptor_6960a02cc0a63cf6, []int{56} } func (m *RemovePairRequest) XXX_Unmarshal(b []byte) error { @@ -3156,7 +3364,7 @@ func (m *RemovePairResponse) Reset() { *m = RemovePairResponse{} } func (m *RemovePairResponse) String() string { return proto.CompactTextString(m) } func (*RemovePairResponse) ProtoMessage() {} func (*RemovePairResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{55} + return fileDescriptor_6960a02cc0a63cf6, []int{57} } func (m *RemovePairResponse) XXX_Unmarshal(b []byte) error { @@ -3196,7 +3404,7 @@ func (m *RestoreNodeRequest) Reset() { *m = RestoreNodeRequest{} } func (m *RestoreNodeRequest) String() string { return proto.CompactTextString(m) } func (*RestoreNodeRequest) ProtoMessage() {} func (*RestoreNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{56} + return fileDescriptor_6960a02cc0a63cf6, []int{58} } func (m *RestoreNodeRequest) XXX_Unmarshal(b []byte) error { @@ -3259,7 +3467,7 @@ func (m *RestoreNodeResponse) Reset() { *m = RestoreNodeResponse{} } func (m *RestoreNodeResponse) String() string { return proto.CompactTextString(m) } func (*RestoreNodeResponse) ProtoMessage() {} func (*RestoreNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{57} + return fileDescriptor_6960a02cc0a63cf6, []int{59} } func (m *RestoreNodeResponse) XXX_Unmarshal(b []byte) error { @@ -3305,7 +3513,7 @@ func (m *SetLogLevelRequest) Reset() { *m = SetLogLevelRequest{} } func (m *SetLogLevelRequest) String() string { return proto.CompactTextString(m) } func (*SetLogLevelRequest) ProtoMessage() {} func (*SetLogLevelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{58} + return fileDescriptor_6960a02cc0a63cf6, []int{60} } func (m *SetLogLevelRequest) XXX_Unmarshal(b []byte) error { @@ -3343,7 +3551,7 @@ func (m *SetLogLevelResponse) Reset() { *m = SetLogLevelResponse{} } func (m *SetLogLevelResponse) String() string { return proto.CompactTextString(m) } func (*SetLogLevelResponse) ProtoMessage() {} func (*SetLogLevelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{59} + return fileDescriptor_6960a02cc0a63cf6, []int{61} } func (m *SetLogLevelResponse) XXX_Unmarshal(b []byte) error { @@ -3374,7 +3582,7 @@ func (m *ShutdownRequest) Reset() { *m = ShutdownRequest{} } func (m *ShutdownRequest) String() string { return proto.CompactTextString(m) } func (*ShutdownRequest) ProtoMessage() {} func (*ShutdownRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{60} + return fileDescriptor_6960a02cc0a63cf6, []int{62} } func (m *ShutdownRequest) XXX_Unmarshal(b []byte) error { @@ -3405,7 +3613,7 @@ func (m *ShutdownResponse) Reset() { *m = ShutdownResponse{} } func (m *ShutdownResponse) String() string { return proto.CompactTextString(m) } func (*ShutdownResponse) ProtoMessage() {} func (*ShutdownResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{61} + return fileDescriptor_6960a02cc0a63cf6, []int{63} } func (m *ShutdownResponse) XXX_Unmarshal(b []byte) error { @@ -3438,7 +3646,7 @@ func (m *SubscribeOrdersRequest) Reset() { *m = SubscribeOrdersRequest{} func (m *SubscribeOrdersRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeOrdersRequest) ProtoMessage() {} func (*SubscribeOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{62} + return fileDescriptor_6960a02cc0a63cf6, []int{64} } func (m *SubscribeOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -3466,6 +3674,37 @@ func (m *SubscribeOrdersRequest) GetExisting() bool { return false } +type SubscribeAlertsRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SubscribeAlertsRequest) Reset() { *m = SubscribeAlertsRequest{} } +func (m *SubscribeAlertsRequest) String() string { return proto.CompactTextString(m) } +func (*SubscribeAlertsRequest) ProtoMessage() {} +func (*SubscribeAlertsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{65} +} + +func (m *SubscribeAlertsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SubscribeAlertsRequest.Unmarshal(m, b) +} +func (m *SubscribeAlertsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SubscribeAlertsRequest.Marshal(b, m, deterministic) +} +func (m *SubscribeAlertsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SubscribeAlertsRequest.Merge(m, src) +} +func (m *SubscribeAlertsRequest) XXX_Size() int { + return xxx_messageInfo_SubscribeAlertsRequest.Size(m) +} +func (m *SubscribeAlertsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SubscribeAlertsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SubscribeAlertsRequest proto.InternalMessageInfo + type SubscribeSwapsAcceptedRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -3476,7 +3715,7 @@ func (m *SubscribeSwapsAcceptedRequest) Reset() { *m = SubscribeSwapsAcc func (m *SubscribeSwapsAcceptedRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeSwapsAcceptedRequest) ProtoMessage() {} func (*SubscribeSwapsAcceptedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{63} + return fileDescriptor_6960a02cc0a63cf6, []int{66} } func (m *SubscribeSwapsAcceptedRequest) XXX_Unmarshal(b []byte) error { @@ -3510,7 +3749,7 @@ func (m *SubscribeSwapsRequest) Reset() { *m = SubscribeSwapsRequest{} } func (m *SubscribeSwapsRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeSwapsRequest) ProtoMessage() {} func (*SubscribeSwapsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{64} + return fileDescriptor_6960a02cc0a63cf6, []int{67} } func (m *SubscribeSwapsRequest) XXX_Unmarshal(b []byte) error { @@ -3570,7 +3809,7 @@ func (m *SwapAccepted) Reset() { *m = SwapAccepted{} } func (m *SwapAccepted) String() string { return proto.CompactTextString(m) } func (*SwapAccepted) ProtoMessage() {} func (*SwapAccepted) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{65} + return fileDescriptor_6960a02cc0a63cf6, []int{68} } func (m *SwapAccepted) XXX_Unmarshal(b []byte) error { @@ -3688,7 +3927,7 @@ func (m *SwapFailure) Reset() { *m = SwapFailure{} } func (m *SwapFailure) String() string { return proto.CompactTextString(m) } func (*SwapFailure) ProtoMessage() {} func (*SwapFailure) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{66} + return fileDescriptor_6960a02cc0a63cf6, []int{69} } func (m *SwapFailure) XXX_Unmarshal(b []byte) error { @@ -3780,7 +4019,7 @@ func (m *SwapSuccess) Reset() { *m = SwapSuccess{} } func (m *SwapSuccess) String() string { return proto.CompactTextString(m) } func (*SwapSuccess) ProtoMessage() {} func (*SwapSuccess) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{67} + return fileDescriptor_6960a02cc0a63cf6, []int{70} } func (m *SwapSuccess) XXX_Unmarshal(b []byte) error { @@ -3924,7 +4163,7 @@ func (m *Trade) Reset() { *m = Trade{} } func (m *Trade) String() string { return proto.CompactTextString(m) } func (*Trade) ProtoMessage() {} func (*Trade) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{68} + return fileDescriptor_6960a02cc0a63cf6, []int{71} } func (m *Trade) XXX_Unmarshal(b []byte) error { @@ -4027,7 +4266,7 @@ func (m *TradeHistoryRequest) Reset() { *m = TradeHistoryRequest{} } func (m *TradeHistoryRequest) String() string { return proto.CompactTextString(m) } func (*TradeHistoryRequest) ProtoMessage() {} func (*TradeHistoryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{69} + return fileDescriptor_6960a02cc0a63cf6, []int{72} } func (m *TradeHistoryRequest) XXX_Unmarshal(b []byte) error { @@ -4066,7 +4305,7 @@ func (m *TradeHistoryResponse) Reset() { *m = TradeHistoryResponse{} } func (m *TradeHistoryResponse) String() string { return proto.CompactTextString(m) } func (*TradeHistoryResponse) ProtoMessage() {} func (*TradeHistoryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{70} + return fileDescriptor_6960a02cc0a63cf6, []int{73} } func (m *TradeHistoryResponse) XXX_Unmarshal(b []byte) error { @@ -4112,7 +4351,7 @@ func (m *TradingLimits) Reset() { *m = TradingLimits{} } func (m *TradingLimits) String() string { return proto.CompactTextString(m) } func (*TradingLimits) ProtoMessage() {} func (*TradingLimits) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{71} + return fileDescriptor_6960a02cc0a63cf6, []int{74} } func (m *TradingLimits) XXX_Unmarshal(b []byte) error { @@ -4174,7 +4413,7 @@ func (m *TradingLimitsRequest) Reset() { *m = TradingLimitsRequest{} } func (m *TradingLimitsRequest) String() string { return proto.CompactTextString(m) } func (*TradingLimitsRequest) ProtoMessage() {} func (*TradingLimitsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{72} + return fileDescriptor_6960a02cc0a63cf6, []int{75} } func (m *TradingLimitsRequest) XXX_Unmarshal(b []byte) error { @@ -4214,7 +4453,7 @@ func (m *TradingLimitsResponse) Reset() { *m = TradingLimitsResponse{} } func (m *TradingLimitsResponse) String() string { return proto.CompactTextString(m) } func (*TradingLimitsResponse) ProtoMessage() {} func (*TradingLimitsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{73} + return fileDescriptor_6960a02cc0a63cf6, []int{76} } func (m *TradingLimitsResponse) XXX_Unmarshal(b []byte) error { @@ -4256,7 +4495,7 @@ func (m *UnbanRequest) Reset() { *m = UnbanRequest{} } func (m *UnbanRequest) String() string { return proto.CompactTextString(m) } func (*UnbanRequest) ProtoMessage() {} func (*UnbanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{74} + return fileDescriptor_6960a02cc0a63cf6, []int{77} } func (m *UnbanRequest) XXX_Unmarshal(b []byte) error { @@ -4301,7 +4540,7 @@ func (m *UnbanResponse) Reset() { *m = UnbanResponse{} } func (m *UnbanResponse) String() string { return proto.CompactTextString(m) } func (*UnbanResponse) ProtoMessage() {} func (*UnbanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{75} + return fileDescriptor_6960a02cc0a63cf6, []int{78} } func (m *UnbanResponse) XXX_Unmarshal(b []byte) error { @@ -4335,7 +4574,7 @@ func (m *UnlockNodeRequest) Reset() { *m = UnlockNodeRequest{} } func (m *UnlockNodeRequest) String() string { return proto.CompactTextString(m) } func (*UnlockNodeRequest) ProtoMessage() {} func (*UnlockNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{76} + return fileDescriptor_6960a02cc0a63cf6, []int{79} } func (m *UnlockNodeRequest) XXX_Unmarshal(b []byte) error { @@ -4377,7 +4616,7 @@ func (m *UnlockNodeResponse) Reset() { *m = UnlockNodeResponse{} } func (m *UnlockNodeResponse) String() string { return proto.CompactTextString(m) } func (*UnlockNodeResponse) ProtoMessage() {} func (*UnlockNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{77} + return fileDescriptor_6960a02cc0a63cf6, []int{80} } func (m *UnlockNodeResponse) XXX_Unmarshal(b []byte) error { @@ -4433,7 +4672,7 @@ func (m *WithdrawRequest) Reset() { *m = WithdrawRequest{} } func (m *WithdrawRequest) String() string { return proto.CompactTextString(m) } func (*WithdrawRequest) ProtoMessage() {} func (*WithdrawRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{78} + return fileDescriptor_6960a02cc0a63cf6, []int{81} } func (m *WithdrawRequest) XXX_Unmarshal(b []byte) error { @@ -4501,7 +4740,7 @@ func (m *WithdrawResponse) Reset() { *m = WithdrawResponse{} } func (m *WithdrawResponse) String() string { return proto.CompactTextString(m) } func (*WithdrawResponse) ProtoMessage() {} func (*WithdrawResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{79} + return fileDescriptor_6960a02cc0a63cf6, []int{82} } func (m *WithdrawResponse) XXX_Unmarshal(b []byte) error { @@ -4533,16 +4772,20 @@ func init() { proto.RegisterEnum("xudrpc.OrderSide", OrderSide_name, OrderSide_value) proto.RegisterEnum("xudrpc.Role", Role_name, Role_value) proto.RegisterEnum("xudrpc.LogLevel", LogLevel_name, LogLevel_value) + proto.RegisterEnum("xudrpc.Alert_AlertType", Alert_AlertType_name, Alert_AlertType_value) + proto.RegisterEnum("xudrpc.ChannelBalanceAlert_Side", ChannelBalanceAlert_Side_name, ChannelBalanceAlert_Side_value) proto.RegisterEnum("xudrpc.Currency_SwapClient", Currency_SwapClient_name, Currency_SwapClient_value) proto.RegisterEnum("xudrpc.ListOrdersRequest_Owner", ListOrdersRequest_Owner_name, ListOrdersRequest_Owner_value) proto.RegisterType((*AddCurrencyResponse)(nil), "xudrpc.AddCurrencyResponse") proto.RegisterType((*AddPairRequest)(nil), "xudrpc.AddPairRequest") proto.RegisterType((*AddPairResponse)(nil), "xudrpc.AddPairResponse") + proto.RegisterType((*Alert)(nil), "xudrpc.Alert") proto.RegisterType((*Balance)(nil), "xudrpc.Balance") proto.RegisterType((*BanRequest)(nil), "xudrpc.BanRequest") proto.RegisterType((*BanResponse)(nil), "xudrpc.BanResponse") proto.RegisterType((*Chain)(nil), "xudrpc.Chain") proto.RegisterType((*Channels)(nil), "xudrpc.Channels") + proto.RegisterType((*ChannelBalanceAlert)(nil), "xudrpc.ChannelBalanceAlert") proto.RegisterType((*CloseChannelRequest)(nil), "xudrpc.CloseChannelRequest") proto.RegisterType((*CloseChannelResponse)(nil), "xudrpc.CloseChannelResponse") proto.RegisterType((*ConnectRequest)(nil), "xudrpc.ConnectRequest") @@ -4603,6 +4846,7 @@ func init() { proto.RegisterType((*ShutdownRequest)(nil), "xudrpc.ShutdownRequest") proto.RegisterType((*ShutdownResponse)(nil), "xudrpc.ShutdownResponse") proto.RegisterType((*SubscribeOrdersRequest)(nil), "xudrpc.SubscribeOrdersRequest") + proto.RegisterType((*SubscribeAlertsRequest)(nil), "xudrpc.SubscribeAlertsRequest") proto.RegisterType((*SubscribeSwapsAcceptedRequest)(nil), "xudrpc.SubscribeSwapsAcceptedRequest") proto.RegisterType((*SubscribeSwapsRequest)(nil), "xudrpc.SubscribeSwapsRequest") proto.RegisterType((*SwapAccepted)(nil), "xudrpc.SwapAccepted") @@ -4626,260 +4870,273 @@ func init() { func init() { proto.RegisterFile("xudrpc.proto", fileDescriptor_6960a02cc0a63cf6) } var fileDescriptor_6960a02cc0a63cf6 = []byte{ - // 4034 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0xcf, 0x6f, 0x1c, 0xc9, - 0x5a, 0xee, 0x19, 0x8f, 0x67, 0xfc, 0xcd, 0x4f, 0x97, 0x7f, 0x64, 0x32, 0x9b, 0xdd, 0xcd, 0x2b, - 0x36, 0xab, 0xac, 0x77, 0xd7, 0x09, 0x5e, 0x96, 0x7d, 0x1b, 0xc8, 0x6a, 0x6d, 0xc7, 0x2f, 0xc9, - 0xae, 0x9f, 0x1d, 0xb5, 0x93, 0x4d, 0x78, 0x82, 0xd7, 0xea, 0xe9, 0xae, 0xd8, 0x4d, 0xda, 0xdd, - 0xb3, 0xfd, 0xc3, 0x8e, 0xe1, 0x82, 0x9e, 0x38, 0xc1, 0x01, 0x21, 0xc4, 0x19, 0x4e, 0x08, 0x09, - 0xc4, 0x95, 0x13, 0x12, 0x67, 0xae, 0x1c, 0x90, 0x80, 0x0b, 0x12, 0x7f, 0x01, 0xe2, 0x8a, 0x84, - 0xea, 0x57, 0x57, 0x55, 0x77, 0x8f, 0x5f, 0xf2, 0x04, 0xef, 0x36, 0xf5, 0xd5, 0xd7, 0x5f, 0x55, - 0x7d, 0xbf, 0xbf, 0xaf, 0x6a, 0xa0, 0xf7, 0x3a, 0xf7, 0x93, 0x99, 0xb7, 0x35, 0x4b, 0xe2, 0x2c, - 0x46, 0x4b, 0x7c, 0x34, 0x59, 0x71, 0xa3, 0x28, 0xce, 0xdc, 0x2c, 0x88, 0xa3, 0x94, 0x4f, 0xe1, - 0x75, 0x58, 0xdd, 0xf1, 0xfd, 0xbd, 0x3c, 0x49, 0x48, 0xe4, 0x5d, 0xda, 0x24, 0x9d, 0xc5, 0x51, - 0x4a, 0xf0, 0x4f, 0x61, 0xb0, 0xe3, 0xfb, 0x4f, 0xdc, 0x20, 0xb1, 0xc9, 0xf7, 0x39, 0x49, 0x33, - 0xf4, 0x01, 0xf4, 0xa7, 0x6e, 0x4a, 0x1c, 0x4f, 0xa0, 0x8e, 0xad, 0x9b, 0xd6, 0xed, 0x65, 0xdb, - 0x04, 0xa2, 0x0f, 0x61, 0xf0, 0x7d, 0x1e, 0x67, 0x1a, 0x5a, 0x83, 0xa1, 0x95, 0xa0, 0x78, 0x05, - 0x86, 0x05, 0x7d, 0xb1, 0xe4, 0xdf, 0x37, 0xa0, 0xbd, 0xeb, 0x86, 0x6e, 0xe4, 0x11, 0xba, 0x58, - 0x16, 0x67, 0x6e, 0xe8, 0x4c, 0x39, 0x80, 0x2d, 0xb6, 0x68, 0x9b, 0x40, 0x74, 0x1b, 0x86, 0xde, - 0xa9, 0x1b, 0x45, 0x44, 0xe1, 0x35, 0x18, 0x5e, 0x19, 0x8c, 0x7e, 0x08, 0xd7, 0x66, 0x24, 0xf2, - 0x83, 0xe8, 0xc4, 0x29, 0x7f, 0xd1, 0x64, 0x5f, 0xcc, 0x9b, 0x46, 0xf7, 0x60, 0x1c, 0x44, 0xae, - 0x97, 0x05, 0xe7, 0xa4, 0xf2, 0xe9, 0x22, 0xfb, 0x74, 0xee, 0x3c, 0x65, 0xc6, 0x85, 0x1b, 0x86, - 0x24, 0x2b, 0xbe, 0x68, 0xb1, 0x2f, 0x4a, 0x50, 0xf4, 0x15, 0x4c, 0xf2, 0xc8, 0x8b, 0xa3, 0x97, - 0x41, 0x72, 0x46, 0x7c, 0xa7, 0xf4, 0xcd, 0x12, 0xfb, 0xe6, 0x0a, 0x0c, 0xfc, 0xeb, 0x00, 0xbb, - 0x6e, 0x24, 0x05, 0x75, 0x1b, 0x86, 0x51, 0xec, 0x13, 0x27, 0xf0, 0x49, 0x94, 0x05, 0x2f, 0x03, - 0x92, 0x08, 0x51, 0x95, 0xc1, 0xb8, 0x0f, 0x5d, 0xf6, 0x9d, 0x10, 0xc0, 0x17, 0xd0, 0xda, 0x3b, - 0x75, 0x83, 0x08, 0xad, 0x41, 0xcb, 0xa3, 0x3f, 0xc4, 0x77, 0x7c, 0x80, 0xc6, 0xd0, 0x8e, 0x48, - 0x76, 0x11, 0x27, 0xaf, 0x84, 0x4c, 0xe5, 0x10, 0xcf, 0xa0, 0xb3, 0xc7, 0x8f, 0x9e, 0xa2, 0x0d, - 0x58, 0xe2, 0xdc, 0x60, 0x1f, 0xf7, 0x6d, 0x31, 0x42, 0x13, 0xe8, 0x48, 0x3e, 0xb1, 0xcf, 0xfb, - 0x76, 0x31, 0xa6, 0x94, 0x05, 0xfb, 0x99, 0x34, 0xfa, 0xb6, 0x1c, 0x52, 0x6a, 0x5e, 0x18, 0xa7, - 0xc4, 0x67, 0xbc, 0xee, 0xdb, 0x62, 0x84, 0xff, 0xc1, 0x82, 0xd5, 0x3d, 0xfa, 0x53, 0xac, 0xfb, - 0xd6, 0x67, 0xa7, 0xfb, 0x29, 0xa9, 0x68, 0x31, 0xa6, 0xe7, 0x7f, 0x19, 0x27, 0x42, 0x37, 0x3a, - 0x36, 0x1f, 0xa0, 0x9b, 0xd0, 0xf5, 0x49, 0x9a, 0x05, 0x11, 0xb3, 0x1f, 0xb6, 0xa1, 0x65, 0x5b, - 0x07, 0xb1, 0xb3, 0x9f, 0xc5, 0x79, 0x94, 0x09, 0x39, 0x8b, 0x11, 0x1a, 0x41, 0xf3, 0x25, 0x91, - 0x82, 0xa4, 0x3f, 0xf1, 0xd7, 0xb0, 0x66, 0x6e, 0x9f, 0x8b, 0x80, 0xee, 0x3f, 0x4b, 0xdc, 0x28, - 0xa5, 0x8c, 0x89, 0x23, 0x27, 0xf0, 0xd3, 0xb1, 0x75, 0xb3, 0x49, 0xf7, 0x5f, 0x02, 0xe3, 0x4f, - 0x60, 0xb0, 0x17, 0x47, 0x11, 0xf1, 0x32, 0x79, 0xf6, 0x09, 0x74, 0xd8, 0x21, 0xf3, 0x24, 0x10, - 0x87, 0x2e, 0xc6, 0xd4, 0xdc, 0x0a, 0x6c, 0x21, 0xed, 0x3b, 0xb0, 0xb2, 0x97, 0x10, 0x37, 0x23, - 0x87, 0xb1, 0x4f, 0x34, 0x1a, 0x33, 0x37, 0x4d, 0x2f, 0xe2, 0xc4, 0x97, 0x34, 0xe4, 0x18, 0xff, - 0xb9, 0x05, 0x48, 0xff, 0x42, 0x6c, 0xf9, 0x57, 0xa0, 0x9f, 0x12, 0xe2, 0x3b, 0x67, 0x11, 0x39, - 0x8b, 0xa3, 0xc0, 0x13, 0x1b, 0xee, 0x51, 0xe0, 0x8f, 0x05, 0x0c, 0x7d, 0x04, 0xa3, 0x20, 0x0a, - 0xb2, 0xc0, 0x0d, 0x83, 0xdf, 0x23, 0xbe, 0x13, 0x46, 0x7e, 0x3a, 0x6e, 0xf0, 0x83, 0x69, 0xf0, - 0x83, 0xc8, 0x4f, 0xd1, 0x1d, 0x58, 0xd5, 0x51, 0x3d, 0xba, 0xed, 0xd7, 0x99, 0x10, 0x05, 0xd2, - 0xa6, 0xf6, 0xf8, 0x0c, 0xfe, 0x17, 0x0b, 0x3a, 0xd2, 0x7f, 0x19, 0x62, 0xb5, 0x4a, 0x62, 0xbd, - 0x0f, 0xdd, 0xf4, 0xc2, 0x9d, 0x39, 0x5e, 0x18, 0x90, 0x28, 0x63, 0x52, 0x1f, 0x6c, 0xbf, 0xb3, - 0x25, 0x3c, 0xa5, 0x24, 0xb1, 0x75, 0x7c, 0xe1, 0xce, 0xf6, 0x18, 0x8a, 0xad, 0xe3, 0x73, 0x9f, - 0xf4, 0x8a, 0x44, 0x8e, 0xeb, 0xfb, 0x09, 0x49, 0x53, 0xb6, 0xa5, 0x65, 0xdb, 0x04, 0x52, 0x9b, - 0xf7, 0x89, 0x17, 0x9c, 0xb9, 0xa1, 0x33, 0x0b, 0x5d, 0x8f, 0xa4, 0x42, 0x73, 0x4b, 0x50, 0x8c, - 0x01, 0xd4, 0x42, 0xa8, 0x0d, 0xcd, 0x83, 0xc3, 0x07, 0xa3, 0x05, 0xd4, 0x85, 0xf6, 0xde, 0xd1, - 0xe1, 0xe1, 0xfe, 0x8b, 0xa7, 0xa3, 0x06, 0x95, 0xf1, 0x03, 0x32, 0x8b, 0xd3, 0x40, 0x97, 0xf1, - 0xbc, 0xe3, 0xe1, 0x8f, 0x61, 0x58, 0x60, 0x0b, 0xd9, 0x8c, 0xa1, 0x2d, 0x37, 0xcb, 0xb1, 0xe5, - 0x90, 0x2a, 0xe0, 0x83, 0x20, 0xf5, 0xe2, 0x73, 0x92, 0x50, 0x69, 0xa6, 0x6f, 0xef, 0x3c, 0x3e, - 0x87, 0xf5, 0x12, 0x05, 0xb1, 0xe8, 0x0d, 0x58, 0x8e, 0xf2, 0x33, 0x87, 0xe2, 0xa7, 0xc2, 0x09, - 0x28, 0x00, 0xfe, 0x23, 0x0b, 0xd0, 0xfe, 0x6b, 0xe2, 0xe5, 0x19, 0xa1, 0xe7, 0xd7, 0x0e, 0x16, - 0x27, 0x3e, 0x49, 0x9c, 0xa0, 0x50, 0x3c, 0x39, 0x66, 0xee, 0xc1, 0x0d, 0xd8, 0x94, 0x70, 0x3c, - 0x62, 0x88, 0x30, 0xf4, 0x66, 0x84, 0x24, 0xce, 0x2c, 0x9f, 0x3a, 0xaf, 0xc8, 0xa5, 0x90, 0x88, - 0x01, 0xa3, 0x94, 0xbf, 0xcf, 0xdd, 0x28, 0x0b, 0xb2, 0x4b, 0xe1, 0xb0, 0x8b, 0x31, 0xb5, 0x81, - 0x87, 0x24, 0x13, 0x41, 0xe7, 0x4d, 0x78, 0xfc, 0xd7, 0x16, 0x20, 0xfd, 0x0b, 0x71, 0xe4, 0x07, - 0xd0, 0x11, 0xbe, 0x98, 0xdb, 0x6b, 0x77, 0xfb, 0xb6, 0x54, 0xab, 0x2a, 0xf6, 0x96, 0x18, 0xa7, - 0xfb, 0x51, 0x96, 0x5c, 0xda, 0xc5, 0x97, 0x93, 0x03, 0xe8, 0x1b, 0x53, 0xd4, 0x6f, 0xd0, 0x53, - 0xf1, 0x4d, 0xd0, 0x9f, 0xe8, 0x16, 0xb4, 0xce, 0xdd, 0x30, 0xe7, 0x2e, 0xb4, 0xbb, 0x3d, 0x94, - 0xab, 0xc8, 0x25, 0xf8, 0xec, 0xbd, 0xc6, 0x0f, 0x2d, 0x3c, 0x82, 0xc1, 0x43, 0x92, 0x3d, 0x8e, - 0x5e, 0xc6, 0xe2, 0x60, 0xf8, 0x5f, 0x9b, 0x30, 0x2c, 0x40, 0x4a, 0x43, 0xce, 0x49, 0x92, 0x52, - 0x87, 0x26, 0x34, 0x44, 0x0c, 0x29, 0x6f, 0x99, 0xc8, 0x25, 0x6f, 0x39, 0xeb, 0x0d, 0x18, 0x42, - 0xb0, 0x98, 0x27, 0x01, 0xb5, 0x04, 0x6a, 0xca, 0xec, 0xb7, 0x14, 0x3f, 0x95, 0x81, 0xd4, 0x7d, - 0x05, 0x28, 0x66, 0xdd, 0x20, 0x49, 0x99, 0x97, 0x94, 0xb3, 0x14, 0x80, 0x3e, 0x86, 0x25, 0x26, - 0xf5, 0x94, 0xf9, 0xca, 0xee, 0xf6, 0xaa, 0x3c, 0xdf, 0x11, 0x83, 0xee, 0x51, 0x6f, 0x6a, 0x0b, - 0x14, 0xb4, 0x0d, 0xcd, 0x30, 0xf2, 0xc7, 0x6d, 0xc6, 0xef, 0x9b, 0x1a, 0xbf, 0xf5, 0x03, 0x6e, - 0x1d, 0x44, 0x3e, 0xe7, 0x33, 0x45, 0xa6, 0x9e, 0xdd, 0x0d, 0x03, 0x37, 0x1d, 0x2f, 0xf3, 0xc8, - 0xc6, 0x06, 0x7a, 0x64, 0x03, 0x23, 0xb2, 0xa1, 0xbb, 0xb0, 0x2a, 0x13, 0x03, 0xe6, 0x0a, 0x4e, - 0xdd, 0xf4, 0x94, 0xa4, 0xe3, 0x2e, 0x3b, 0x6f, 0xdd, 0x14, 0xfa, 0x14, 0xda, 0xd2, 0x65, 0xf5, - 0xcc, 0x33, 0x08, 0x7f, 0xc5, 0x76, 0x27, 0x71, 0x26, 0x0f, 0xa1, 0x23, 0x77, 0xf8, 0x16, 0xe2, - 0x3e, 0x88, 0x7c, 0x46, 0x46, 0x13, 0xf7, 0x57, 0x4c, 0x31, 0xa9, 0x25, 0x6a, 0x22, 0x7f, 0x0b, - 0x73, 0xb6, 0x61, 0xd5, 0xf8, 0xbe, 0xf0, 0xee, 0xc3, 0x84, 0xcc, 0x72, 0x9e, 0x33, 0x1e, 0x7b, - 0x71, 0xc2, 0xe3, 0xfa, 0x8a, 0x0d, 0x0a, 0x4c, 0xe3, 0xde, 0x94, 0xc6, 0x31, 0x6e, 0x9f, 0x1d, - 0x5b, 0x8c, 0xf0, 0x35, 0x58, 0x3f, 0x08, 0xd2, 0x4c, 0x78, 0xd6, 0xa0, 0xf0, 0x32, 0xf8, 0x1b, - 0xd8, 0x28, 0x4f, 0x88, 0xf5, 0xee, 0x02, 0x78, 0x05, 0x54, 0xd8, 0xd2, 0xa8, 0xec, 0xa2, 0x6d, - 0x0d, 0x07, 0xff, 0x93, 0x05, 0x2b, 0x94, 0x18, 0x57, 0x11, 0x79, 0x70, 0xcd, 0x67, 0x58, 0xa6, - 0xcf, 0xf8, 0x1c, 0x5a, 0xf1, 0x45, 0x44, 0x12, 0xe1, 0xff, 0xdf, 0x2f, 0x78, 0x5a, 0xa6, 0xb1, - 0x75, 0x44, 0xd1, 0x6c, 0x8e, 0x4d, 0x35, 0x27, 0x0c, 0xce, 0x82, 0x4c, 0x64, 0x28, 0x7c, 0x40, - 0xf9, 0x1b, 0x44, 0x5e, 0x98, 0xfb, 0xc4, 0x61, 0xaa, 0x24, 0xdc, 0x7d, 0xc7, 0x2e, 0x83, 0xf1, - 0x07, 0xd0, 0x62, 0xf4, 0x50, 0x07, 0x16, 0x77, 0x8f, 0x9e, 0x3e, 0x1a, 0x2d, 0x50, 0xa7, 0x7f, - 0xf4, 0xfc, 0x70, 0x64, 0x51, 0xd0, 0x93, 0xfd, 0x7d, 0x7b, 0xd4, 0xc0, 0x7f, 0x61, 0x01, 0xd2, - 0x37, 0x22, 0xb8, 0xf2, 0x55, 0x61, 0x17, 0x9c, 0x23, 0x1f, 0xd6, 0x6d, 0x5a, 0x28, 0x3c, 0x1f, - 0x72, 0x9d, 0x17, 0x5f, 0x4d, 0x1e, 0x43, 0x57, 0x03, 0xd7, 0x28, 0xda, 0x07, 0xa6, 0xa2, 0x0d, - 0x4c, 0xbb, 0xd3, 0xf5, 0x0c, 0xc1, 0x88, 0x2e, 0x4a, 0x33, 0xf7, 0x42, 0x9c, 0x1f, 0x71, 0x09, - 0x08, 0x98, 0xd8, 0xf3, 0x1a, 0xb4, 0xb8, 0x95, 0xf3, 0x7c, 0x80, 0x0f, 0x8a, 0xcf, 0x89, 0xe2, - 0x33, 0xfe, 0x42, 0x7c, 0x4e, 0xf4, 0x23, 0x63, 0x68, 0x71, 0x17, 0xc2, 0x4f, 0xdc, 0x93, 0x3b, - 0xa2, 0x58, 0x36, 0x9f, 0xc2, 0xff, 0x6e, 0x41, 0x5b, 0x98, 0x02, 0xd5, 0xc1, 0x34, 0x73, 0xb3, - 0x5c, 0x46, 0x3a, 0x31, 0x42, 0x9f, 0x40, 0x47, 0xa4, 0xe5, 0xa9, 0x38, 0x9c, 0x52, 0x27, 0x01, - 0xb7, 0x0b, 0x0c, 0x74, 0x0b, 0x96, 0x58, 0xb2, 0xcb, 0x5d, 0x5a, 0x77, 0xbb, 0xaf, 0xe1, 0x06, - 0x91, 0x2d, 0x26, 0x69, 0x2a, 0x38, 0x0d, 0x63, 0xef, 0xd5, 0x29, 0x09, 0x4e, 0x4e, 0x33, 0xe1, - 0xe5, 0x74, 0x50, 0xe1, 0x19, 0x5b, 0x9a, 0x67, 0xd4, 0x7c, 0xed, 0x92, 0xe9, 0x6b, 0x0b, 0xb7, - 0xd4, 0xd6, 0xdc, 0x12, 0xfe, 0x06, 0x06, 0xcc, 0x1e, 0x55, 0xd2, 0x5a, 0xf6, 0xc9, 0x56, 0x8d, - 0x4f, 0x2e, 0x68, 0x35, 0x74, 0x5a, 0x7f, 0x65, 0x01, 0x3a, 0x9a, 0x91, 0xe8, 0xff, 0x25, 0x5f, - 0x56, 0x79, 0x6f, 0xd3, 0xc8, 0x7b, 0x6f, 0x42, 0x77, 0x96, 0xa7, 0xa7, 0x8e, 0x98, 0xe4, 0xd1, - 0x57, 0x07, 0xc9, 0xcc, 0xb8, 0xa5, 0x32, 0xe3, 0xfb, 0xb0, 0x6a, 0xec, 0x53, 0xa8, 0xc3, 0x87, - 0x30, 0x30, 0x33, 0x60, 0xb1, 0xcf, 0x12, 0x14, 0xff, 0x63, 0x03, 0x5a, 0x4c, 0x69, 0x99, 0xfe, - 0x25, 0x81, 0x28, 0x1d, 0x2d, 0x9b, 0x0f, 0x8c, 0x6c, 0xa0, 0x61, 0x66, 0x03, 0xba, 0xcf, 0x68, - 0x9a, 0x3e, 0x63, 0x00, 0x8d, 0xc0, 0x17, 0x19, 0x7f, 0x23, 0xf0, 0xd1, 0xd7, 0x55, 0xb6, 0xb5, - 0x98, 0x6e, 0x6d, 0x48, 0x7d, 0x31, 0x05, 0x57, 0xcb, 0xce, 0x30, 0xf6, 0xdc, 0x90, 0x2e, 0xc6, - 0x95, 0xa1, 0x18, 0xa3, 0xf7, 0x00, 0x3c, 0x96, 0x67, 0xfb, 0x8e, 0x9b, 0x31, 0x95, 0x58, 0xb4, - 0x35, 0x08, 0xba, 0x05, 0x8b, 0x69, 0xe0, 0x93, 0x71, 0x87, 0x39, 0xb0, 0x15, 0xc3, 0x56, 0x8f, - 0x03, 0x9f, 0xd8, 0x6c, 0x9a, 0x2a, 0x4b, 0x90, 0x3a, 0xf1, 0x45, 0xe4, 0x30, 0x2f, 0xc0, 0x42, - 0x5e, 0xc7, 0x36, 0x60, 0x54, 0x4d, 0x4f, 0xe3, 0xd0, 0x67, 0x61, 0x6f, 0xd1, 0x66, 0xbf, 0xf1, - 0x5f, 0x5a, 0xd0, 0x63, 0xb4, 0x6c, 0x72, 0x16, 0x9f, 0xbb, 0xa1, 0xc1, 0x33, 0x6b, 0x3e, 0xcf, - 0x4a, 0xb9, 0x99, 0x9e, 0xd1, 0x35, 0x4b, 0x19, 0x9d, 0x7e, 0xfa, 0xc5, 0xd2, 0xe9, 0xcb, 0xdb, - 0x6e, 0x55, 0xb7, 0x8d, 0x4f, 0x61, 0x89, 0x7b, 0x26, 0xf4, 0x29, 0xc0, 0x34, 0xbf, 0x74, 0x0c, - 0xef, 0xd8, 0x37, 0x38, 0x62, 0x6b, 0x08, 0xe8, 0x0e, 0x74, 0x53, 0x12, 0x86, 0x12, 0xbf, 0x51, - 0x87, 0xaf, 0x63, 0xe0, 0xcf, 0xa4, 0xe7, 0x64, 0xb9, 0x07, 0xe5, 0x17, 0x75, 0x3d, 0x22, 0xad, - 0x65, 0xbf, 0xa9, 0x0e, 0xc7, 0x17, 0x91, 0x28, 0x6a, 0xe9, 0x4f, 0xfc, 0x33, 0x4b, 0x7c, 0xf5, - 0x6c, 0xe6, 0xbb, 0x19, 0xa1, 0x61, 0x9c, 0x9f, 0xc5, 0x62, 0x4a, 0x62, 0xae, 0xf7, 0x68, 0xc1, - 0xe6, 0xb3, 0xe8, 0x37, 0xa1, 0xcf, 0x39, 0x94, 0x70, 0xc6, 0x0b, 0x7f, 0xb5, 0x66, 0x6e, 0x8f, - 0xcf, 0x3d, 0x5a, 0xb0, 0x4d, 0xe4, 0xdd, 0x01, 0xf4, 0x38, 0x20, 0x67, 0x8b, 0xe2, 0x7f, 0x6b, - 0xc0, 0x22, 0x75, 0x96, 0xf3, 0x8b, 0x80, 0x37, 0x4a, 0xf1, 0xbe, 0x86, 0x5e, 0x18, 0xf9, 0x72, - 0x28, 0xfd, 0xe2, 0x0d, 0xdd, 0x1d, 0xd3, 0x74, 0xe4, 0x49, 0x3e, 0xfd, 0x96, 0x5c, 0x8a, 0xb0, - 0x63, 0x7c, 0x41, 0xd7, 0x0f, 0xa2, 0x69, 0x9c, 0x47, 0xbe, 0x88, 0x8d, 0x72, 0xa8, 0x42, 0x44, - 0x4b, 0x0b, 0x11, 0xd4, 0x6b, 0xbc, 0xce, 0x7d, 0xc7, 0x74, 0x95, 0x3a, 0x08, 0x7d, 0x02, 0x2b, - 0x29, 0xf1, 0xe2, 0xc8, 0x4f, 0x79, 0x79, 0xe8, 0x65, 0xc4, 0x67, 0x76, 0xd2, 0xb7, 0xab, 0x13, - 0xf5, 0x39, 0xdf, 0xe4, 0x3e, 0x0c, 0x4b, 0xdb, 0xae, 0x09, 0x8b, 0x6b, 0x7a, 0x58, 0x5c, 0xd6, - 0xc3, 0xe0, 0x1f, 0x34, 0x60, 0xe5, 0x09, 0xad, 0xe4, 0x84, 0x50, 0xb8, 0x3b, 0xfd, 0xbf, 0xf4, - 0x39, 0xba, 0xfd, 0x2c, 0x96, 0xec, 0x47, 0x7a, 0x80, 0xd6, 0xd5, 0x1e, 0x60, 0x13, 0x46, 0x09, - 0x61, 0xf5, 0xa6, 0x53, 0x90, 0xe2, 0xec, 0xac, 0xc0, 0x69, 0xa6, 0x1b, 0x9c, 0x9d, 0x11, 0x3f, - 0x70, 0x33, 0x0a, 0x75, 0x3c, 0x5a, 0x4f, 0x84, 0x8c, 0xab, 0x1d, 0xbb, 0x6e, 0x8a, 0xb2, 0x00, - 0xe9, 0x2c, 0x10, 0x9e, 0xfa, 0x4b, 0x5a, 0xea, 0x67, 0x24, 0x89, 0xdc, 0xd0, 0x39, 0x73, 0x33, - 0xef, 0x94, 0xcc, 0xb1, 0xcb, 0x0a, 0x1a, 0xfa, 0x0d, 0x18, 0xb0, 0x54, 0x3a, 0xcd, 0x3d, 0x8f, - 0xa4, 0x34, 0x99, 0xe2, 0x06, 0x5a, 0xa4, 0xd0, 0xb4, 0x62, 0x3c, 0xe6, 0x93, 0x76, 0x09, 0x15, - 0x7d, 0x41, 0x33, 0xd5, 0x33, 0x37, 0x88, 0x68, 0x46, 0xce, 0xcd, 0xad, 0x59, 0x63, 0x6e, 0x76, - 0x19, 0x0b, 0x7d, 0x09, 0x7d, 0x46, 0xea, 0xa5, 0x1b, 0x84, 0x79, 0xc2, 0x32, 0xb8, 0xca, 0xa2, - 0x3f, 0xe2, 0x73, 0xb6, 0x89, 0x89, 0xff, 0xcb, 0x82, 0xa1, 0x62, 0xc1, 0xfe, 0x39, 0x2d, 0xe5, - 0x6f, 0x41, 0x8b, 0x9d, 0x67, 0xae, 0xb1, 0xb3, 0x59, 0xf4, 0x25, 0xf4, 0xf4, 0x03, 0x08, 0x5b, - 0xaf, 0x3b, 0xe9, 0xa3, 0x05, 0xdb, 0x40, 0x45, 0x5f, 0xbe, 0xd9, 0x49, 0x1f, 0x2d, 0xd4, 0x9d, - 0xb5, 0xa7, 0x9f, 0x80, 0x29, 0x56, 0xfd, 0x51, 0x8b, 0x55, 0x05, 0xea, 0x6e, 0x1b, 0x5a, 0x84, - 0x1e, 0x10, 0xc7, 0xd0, 0xd5, 0x4a, 0x99, 0xb9, 0x89, 0x97, 0xe6, 0x76, 0x1a, 0xa6, 0xdb, 0xd1, - 0xf2, 0xa0, 0xc5, 0x4a, 0x1e, 0xc4, 0x1b, 0x8f, 0x2d, 0xad, 0xf1, 0x88, 0x3f, 0x83, 0x75, 0xe6, - 0xf5, 0x88, 0xea, 0x52, 0xff, 0xfc, 0x4a, 0x7d, 0x0c, 0x1b, 0xe5, 0x8f, 0x44, 0xe3, 0xeb, 0x00, - 0x10, 0x9f, 0x31, 0x4c, 0xf7, 0xaa, 0x06, 0xc4, 0x15, 0x06, 0x8c, 0x3f, 0x87, 0x55, 0x83, 0x9a, - 0xb0, 0x82, 0xf7, 0x60, 0x24, 0x51, 0x9c, 0x38, 0x72, 0x58, 0x90, 0xb5, 0xb4, 0x20, 0x5b, 0x6c, - 0x6f, 0x27, 0x0c, 0x8d, 0xaa, 0x03, 0xe7, 0x70, 0xad, 0x32, 0x23, 0x88, 0x7e, 0x02, 0x2b, 0xcc, - 0xdb, 0x13, 0xbf, 0xb0, 0x5b, 0x99, 0x5e, 0x57, 0x27, 0x28, 0xb6, 0x58, 0x59, 0xc3, 0xe6, 0x4d, - 0xb7, 0xea, 0x04, 0xfe, 0x14, 0x56, 0xf8, 0xb2, 0x7a, 0xcf, 0x7f, 0x6e, 0x15, 0x85, 0xd7, 0x24, - 0x13, 0x8d, 0x16, 0xfe, 0x1f, 0x36, 0x28, 0x38, 0xcd, 0xe2, 0xc4, 0xe8, 0x2a, 0xbe, 0x51, 0x8b, - 0x50, 0x6f, 0x3d, 0x36, 0xcc, 0xd6, 0x23, 0xfa, 0x16, 0xba, 0x34, 0xa4, 0x4c, 0x5d, 0xef, 0x55, - 0x3e, 0x93, 0x31, 0x68, 0x53, 0x6a, 0x6d, 0x75, 0x45, 0x1a, 0x91, 0x76, 0x39, 0x32, 0x8f, 0x48, - 0x10, 0x16, 0x00, 0xf4, 0x03, 0x76, 0x39, 0xe2, 0xf8, 0x6e, 0xe6, 0x4e, 0xdd, 0x94, 0xb7, 0x65, - 0x7b, 0x2c, 0xc0, 0x3c, 0x10, 0x20, 0x11, 0x1c, 0x74, 0x0a, 0x3f, 0x2f, 0x38, 0xf4, 0xf4, 0xe0, - 0x40, 0xa8, 0x4e, 0x68, 0x7b, 0x52, 0x9d, 0xd2, 0x84, 0x83, 0x45, 0x07, 0x54, 0xb0, 0x41, 0x02, - 0x59, 0xfb, 0xf3, 0x23, 0xea, 0xb3, 0x05, 0x92, 0x6c, 0x24, 0xf0, 0xaa, 0x7a, 0x28, 0xe1, 0xb2, - 0xf1, 0xf9, 0x00, 0xd0, 0x31, 0xc9, 0x0e, 0xe2, 0x93, 0x03, 0x72, 0xae, 0x52, 0xfa, 0x2d, 0x58, - 0x0e, 0xe3, 0x13, 0x27, 0xa4, 0x30, 0xb6, 0xdd, 0x81, 0xaa, 0x78, 0x0a, 0x5c, 0x85, 0x82, 0xd7, - 0x61, 0xd5, 0xa0, 0x22, 0x44, 0xb9, 0x02, 0xc3, 0xe3, 0xd3, 0x3c, 0xf3, 0xe3, 0x0b, 0x79, 0xb1, - 0x40, 0x6b, 0x37, 0x05, 0x12, 0x68, 0xbf, 0x06, 0x1b, 0xc7, 0xf9, 0x34, 0xf5, 0x92, 0x60, 0x4a, - 0xcc, 0x0a, 0x7c, 0x02, 0x1d, 0xf2, 0x3a, 0x48, 0xb3, 0x20, 0x3a, 0x61, 0xdb, 0xe8, 0xd8, 0xc5, - 0x18, 0xbf, 0x0f, 0xef, 0x16, 0x5f, 0x51, 0x9f, 0x93, 0xee, 0x78, 0x1e, 0x99, 0x65, 0xc4, 0x97, - 0x4b, 0xdd, 0x87, 0x75, 0x13, 0x41, 0xbb, 0x85, 0x92, 0x95, 0x75, 0xe6, 0xbe, 0x12, 0x29, 0x55, - 0xc7, 0x36, 0x81, 0xf8, 0x7f, 0x1a, 0xd0, 0xa3, 0x9f, 0x49, 0xb2, 0xe8, 0x7a, 0xc5, 0xba, 0xdb, - 0x6c, 0xfc, 0xd8, 0xcc, 0x45, 0x1b, 0xa5, 0x5c, 0xf4, 0xca, 0xe8, 0x3c, 0xaf, 0xab, 0xa8, 0xb2, - 0x80, 0x96, 0x9e, 0x05, 0x94, 0x7b, 0x95, 0x4b, 0x35, 0xbd, 0xca, 0x0d, 0x58, 0x4a, 0x58, 0x23, - 0x49, 0x14, 0x82, 0x62, 0x44, 0x03, 0x39, 0x2f, 0x98, 0x9c, 0x84, 0x78, 0x24, 0x38, 0xa7, 0x3c, - 0xed, 0xb0, 0x55, 0x2b, 0x70, 0x5a, 0x29, 0x09, 0x58, 0x2a, 0xee, 0x54, 0x96, 0xf9, 0xa5, 0x93, - 0x09, 0x45, 0x5b, 0x80, 0xa4, 0xb3, 0xd4, 0xa8, 0xf2, 0xfe, 0x57, 0xcd, 0x0c, 0xdd, 0x43, 0x01, - 0x95, 0x94, 0xbb, 0x3c, 0x99, 0x28, 0xc3, 0xf1, 0xdf, 0x58, 0xd0, 0xd5, 0x62, 0xc9, 0x2f, 0xd8, - 0xdd, 0xd5, 0x79, 0xdc, 0x2c, 0xf1, 0xb8, 0xcc, 0xcd, 0xc5, 0x1a, 0x6e, 0x7e, 0x08, 0x03, 0x11, - 0xbc, 0x9c, 0x84, 0xb8, 0x69, 0x2c, 0xc3, 0x4a, 0x09, 0x8a, 0xff, 0xae, 0xc9, 0x77, 0x2b, 0xe2, - 0xed, 0x2f, 0x57, 0x59, 0x94, 0xc8, 0x5b, 0x86, 0xc8, 0x6f, 0xc3, 0xd0, 0x10, 0x2d, 0xf1, 0x85, - 0xc4, 0xcb, 0x60, 0x9a, 0x2f, 0x2b, 0xd1, 0x66, 0x42, 0xda, 0x3a, 0xa8, 0xc2, 0x2c, 0xa8, 0x61, - 0xd6, 0x4d, 0x58, 0x4c, 0xe2, 0x90, 0x30, 0x91, 0x0e, 0x54, 0xbb, 0xc5, 0x8e, 0x43, 0x62, 0xb3, - 0x19, 0x1a, 0x4f, 0x4a, 0x6a, 0x41, 0x7c, 0xd6, 0xe3, 0x5c, 0xb6, 0xab, 0x13, 0xd4, 0x50, 0x75, - 0xb5, 0xc8, 0xc6, 0x7d, 0x7e, 0x5b, 0x62, 0x00, 0x69, 0xa9, 0x9b, 0x38, 0xb3, 0x84, 0x04, 0x67, - 0xee, 0x09, 0x19, 0x0f, 0x18, 0x8a, 0x06, 0x51, 0xa6, 0x34, 0xd4, 0x4c, 0x09, 0xff, 0x77, 0x03, - 0x5a, 0x4f, 0x13, 0xd7, 0x27, 0xb4, 0x9e, 0x3b, 0xa3, 0x16, 0xef, 0xcc, 0xaf, 0xaf, 0x6c, 0x1d, - 0x83, 0x7e, 0x90, 0x69, 0x1f, 0x34, 0x6a, 0x3f, 0xd0, 0x30, 0x34, 0xf9, 0x34, 0x0d, 0xf9, 0x5c, - 0x25, 0x53, 0x4d, 0x13, 0x5a, 0xa6, 0x26, 0x14, 0xe7, 0x59, 0xd2, 0x5d, 0x83, 0xe4, 0x7d, 0x7b, - 0x2e, 0xef, 0x6f, 0x42, 0x97, 0xf0, 0x4b, 0x13, 0xd6, 0x13, 0xe0, 0x9a, 0xa0, 0x83, 0x8a, 0x92, - 0x60, 0xf9, 0xea, 0x92, 0xe0, 0x1e, 0xf4, 0x3c, 0xaa, 0x18, 0x24, 0x99, 0xb9, 0x49, 0xc6, 0x55, - 0x61, 0x7e, 0xdb, 0xc2, 0xc0, 0xc5, 0x1f, 0xc3, 0x2a, 0xe3, 0xfa, 0xa3, 0x80, 0xc6, 0xa1, 0x4b, - 0xad, 0xe8, 0xe1, 0x9d, 0x51, 0x4b, 0xeb, 0x8c, 0xe2, 0xfb, 0xb0, 0x66, 0x22, 0x8b, 0x20, 0x78, - 0x0b, 0x96, 0x32, 0x0a, 0xaf, 0x14, 0x05, 0x0c, 0xdb, 0x16, 0x93, 0xf8, 0x4f, 0x2c, 0xe8, 0x53, - 0x48, 0x10, 0x9d, 0x1c, 0x50, 0x7a, 0x29, 0x65, 0xf8, 0x99, 0xfb, 0xda, 0xa1, 0xc5, 0xb9, 0xec, - 0x42, 0xc8, 0x31, 0x65, 0x38, 0xfd, 0x3d, 0xcd, 0x65, 0x7e, 0x26, 0x87, 0x54, 0x0d, 0x13, 0x92, - 0x92, 0x84, 0xa6, 0x46, 0xec, 0x53, 0xee, 0x48, 0x4c, 0x20, 0x35, 0x90, 0x02, 0x40, 0x89, 0x70, - 0x81, 0x1a, 0x30, 0xbc, 0xcd, 0x0f, 0x54, 0x6c, 0xe8, 0x4d, 0x92, 0xd0, 0xbf, 0xb5, 0x60, 0xbd, - 0xf4, 0x91, 0x60, 0xc3, 0x0e, 0x2c, 0x31, 0x3e, 0x49, 0x36, 0x7c, 0xa4, 0xb3, 0xa1, 0x82, 0xbe, - 0xc5, 0x87, 0xa2, 0xa9, 0xcb, 0x3f, 0x9c, 0x3c, 0x81, 0xae, 0x06, 0xae, 0x49, 0x50, 0x3e, 0x36, - 0x9b, 0xba, 0xeb, 0xf5, 0x4b, 0x68, 0x79, 0xcb, 0x77, 0xd0, 0x7b, 0x16, 0x4d, 0x7f, 0x81, 0x97, - 0x04, 0xe8, 0x06, 0x2c, 0x27, 0x44, 0x94, 0xdc, 0x22, 0x5d, 0x51, 0x00, 0x3c, 0x84, 0xbe, 0xa0, - 0xab, 0xee, 0x9e, 0x9f, 0x45, 0x61, 0xec, 0xbd, 0x7a, 0xd3, 0xbb, 0xe7, 0x9f, 0x00, 0xd2, 0x3f, - 0x50, 0x09, 0x55, 0xce, 0xa0, 0xa5, 0x84, 0x4a, 0x02, 0x59, 0x42, 0xf5, 0x3e, 0x74, 0x75, 0x14, - 0x7e, 0x55, 0x05, 0x0a, 0x01, 0xff, 0xb1, 0x05, 0xc3, 0xe7, 0x41, 0x76, 0xea, 0x27, 0xee, 0xc5, - 0x1b, 0x08, 0xb5, 0xfc, 0x0e, 0xa0, 0x71, 0xd5, 0x3b, 0x80, 0x66, 0xf9, 0x1d, 0x80, 0x1b, 0x86, - 0xa2, 0x0b, 0x42, 0x7f, 0xea, 0xfd, 0xcf, 0x3e, 0xef, 0x7f, 0xde, 0x83, 0x91, 0xda, 0xcc, 0xdb, - 0x35, 0x3f, 0x37, 0x6f, 0xc3, 0x72, 0x61, 0xef, 0xa8, 0x0d, 0xcd, 0xdd, 0x67, 0xbf, 0x35, 0x5a, - 0x40, 0x1d, 0x58, 0x3c, 0xde, 0x3f, 0x38, 0xe0, 0xf7, 0x0c, 0xec, 0xea, 0xa1, 0xb1, 0xb9, 0x09, - 0x8b, 0xd4, 0xbb, 0xa0, 0x65, 0x68, 0x3d, 0xdd, 0xf9, 0x76, 0xdf, 0x1e, 0x2d, 0xd0, 0x9f, 0x3f, - 0x66, 0x3f, 0x2d, 0xd4, 0x83, 0xce, 0xe3, 0xc3, 0xa7, 0xfb, 0xf6, 0xe1, 0xce, 0xc1, 0xa8, 0xb1, - 0xf9, 0x1c, 0x3a, 0x32, 0x3b, 0xa4, 0x48, 0x3b, 0x07, 0xfb, 0xf6, 0x53, 0x8e, 0xbf, 0x6f, 0xdb, - 0x47, 0x36, 0xa7, 0xfb, 0x7c, 0xc7, 0x3e, 0x1c, 0x35, 0xe8, 0xaf, 0xc7, 0x87, 0x3f, 0x3a, 0x1a, - 0x35, 0x51, 0x17, 0xda, 0xdf, 0xed, 0xdb, 0xbb, 0x47, 0xc7, 0xfb, 0xa3, 0x45, 0x8a, 0xfb, 0x60, - 0x7f, 0xf7, 0xd9, 0xc3, 0x51, 0x8b, 0xad, 0x68, 0xef, 0xec, 0xed, 0x8f, 0x96, 0xb6, 0xff, 0xc3, - 0x82, 0xf6, 0x8b, 0xdc, 0x7f, 0x1c, 0x05, 0x19, 0xda, 0x07, 0x50, 0x6f, 0x0b, 0xd0, 0xf5, 0xa2, - 0xed, 0x5e, 0x7e, 0xa1, 0x30, 0x99, 0xd4, 0x4d, 0x09, 0xb5, 0x5a, 0x40, 0x8f, 0xa0, 0xab, 0x65, - 0xde, 0x68, 0x32, 0xbf, 0x44, 0x98, 0xbc, 0x53, 0x3b, 0x57, 0x50, 0xda, 0x07, 0x50, 0x1a, 0xa7, - 0x36, 0x54, 0x51, 0x5b, 0xb5, 0xa1, 0xaa, 0x82, 0xe2, 0x85, 0xed, 0x3f, 0x1d, 0x43, 0xf3, 0x45, - 0xee, 0xa3, 0x17, 0xd0, 0xd5, 0x9e, 0x59, 0xa1, 0xca, 0x95, 0x96, 0xda, 0x4e, 0xdd, 0x6b, 0xac, - 0xc9, 0xcf, 0xfe, 0xf9, 0x3f, 0xff, 0xac, 0xb1, 0x86, 0x87, 0x77, 0xce, 0x7f, 0xf5, 0x8e, 0xeb, - 0xfb, 0x52, 0x17, 0xef, 0x59, 0x9b, 0xc8, 0x86, 0xb6, 0x78, 0x49, 0x85, 0x36, 0x34, 0x1a, 0x5a, - 0x19, 0x37, 0xb9, 0x56, 0x81, 0x0b, 0xba, 0x1b, 0x8c, 0xee, 0x08, 0x77, 0x05, 0x5d, 0x1a, 0xa6, - 0x28, 0xcd, 0x5d, 0x68, 0xee, 0xba, 0x11, 0x42, 0xea, 0x7a, 0x59, 0xfa, 0x84, 0xc9, 0xaa, 0x01, - 0x13, 0x74, 0x10, 0xa3, 0xd3, 0xc3, 0x6d, 0x4a, 0x67, 0xea, 0x46, 0x94, 0x86, 0x07, 0x3d, 0xfd, - 0x89, 0x0b, 0x52, 0x0f, 0x2d, 0xaa, 0xef, 0x76, 0x26, 0x37, 0xea, 0x27, 0x05, 0xf9, 0x31, 0x23, - 0x8f, 0xf0, 0x88, 0x92, 0x67, 0x2f, 0x80, 0xc4, 0x85, 0x0d, 0x3d, 0xbc, 0x78, 0xd7, 0xa2, 0x0e, - 0x6f, 0x3e, 0x8b, 0x51, 0x87, 0x2f, 0x3f, 0x80, 0x31, 0x0e, 0x2f, 0x5c, 0x15, 0xdd, 0xf8, 0x4f, - 0xa1, 0xff, 0x9c, 0xbd, 0xaf, 0x12, 0xaf, 0x29, 0x14, 0x65, 0xf3, 0x31, 0x86, 0xa2, 0x5c, 0x7a, - 0x76, 0x81, 0x6f, 0x30, 0xca, 0x1b, 0x78, 0x85, 0x52, 0xe6, 0x6f, 0xb5, 0x7c, 0x8e, 0x42, 0xe9, - 0xff, 0x2e, 0xf4, 0x8d, 0x87, 0x13, 0xa8, 0x38, 0x7c, 0xdd, 0x8b, 0x8c, 0xc9, 0xbb, 0x73, 0x66, - 0xeb, 0xd6, 0xf2, 0x05, 0x0a, 0x7b, 0x6a, 0x41, 0xd7, 0x7a, 0x01, 0xa0, 0x1e, 0x20, 0x28, 0x2d, - 0xae, 0x3c, 0x7a, 0x50, 0x5a, 0x5c, 0x7d, 0xaf, 0x80, 0x57, 0xd9, 0x12, 0x7d, 0xd4, 0xe5, 0xd2, - 0xe5, 0xb4, 0x0e, 0xa0, 0x2d, 0xae, 0xda, 0x15, 0x7f, 0xcc, 0xf7, 0x06, 0x8a, 0x3f, 0xa5, 0x3b, - 0x79, 0x3c, 0x62, 0x04, 0x01, 0x75, 0x28, 0xc1, 0x80, 0x92, 0xf8, 0x6d, 0xe8, 0x6a, 0xb7, 0xcf, - 0x48, 0xdf, 0x4d, 0xe9, 0x4a, 0x5b, 0x19, 0x4a, 0xcd, 0x75, 0x35, 0x5e, 0x63, 0x94, 0x07, 0xa8, - 0x47, 0x29, 0x53, 0x2e, 0x30, 0xea, 0xcf, 0x01, 0xd4, 0x45, 0xa9, 0xe2, 0x42, 0xe5, 0xc6, 0x57, - 0x71, 0xa1, 0x7a, 0xaf, 0x2a, 0x75, 0x1c, 0x01, 0x25, 0x2d, 0xae, 0x13, 0x4e, 0x60, 0x60, 0xde, - 0x63, 0xa3, 0x77, 0x75, 0x0a, 0x95, 0x8b, 0xef, 0xc9, 0x7b, 0xf3, 0xa6, 0x4d, 0x9d, 0x44, 0x03, - 0xa6, 0x93, 0x8a, 0xec, 0x31, 0x2c, 0x17, 0x37, 0xac, 0x68, 0xac, 0x13, 0xd1, 0x2f, 0x62, 0x27, - 0xd7, 0x6b, 0x66, 0x64, 0x3d, 0xcf, 0x28, 0x77, 0xd1, 0x32, 0xa5, 0xcc, 0x1b, 0xed, 0x92, 0x28, - 0x7b, 0x98, 0x61, 0x12, 0xd5, 0xae, 0x67, 0x4b, 0x44, 0xf5, 0x4b, 0xda, 0x12, 0x51, 0x46, 0xc7, - 0x81, 0xae, 0x76, 0x7f, 0xa7, 0x24, 0x59, 0xbd, 0x7c, 0x54, 0x92, 0xac, 0xb9, 0xf0, 0xc3, 0xd7, - 0x18, 0xe9, 0x15, 0xee, 0xf2, 0xe2, 0x19, 0x89, 0xa4, 0xc9, 0xff, 0x0e, 0x80, 0x6a, 0xb9, 0x2a, - 0x61, 0x56, 0x9a, 0xf1, 0x4a, 0xfd, 0x4a, 0x1d, 0x5a, 0x7c, 0x9d, 0x91, 0x5e, 0xc5, 0x8c, 0xc9, - 0xac, 0x0d, 0xce, 0xc4, 0x79, 0xcf, 0xda, 0xbc, 0x6b, 0xa1, 0x97, 0x30, 0x50, 0xf8, 0xc7, 0x97, - 0x91, 0x77, 0xd5, 0x12, 0x93, 0xba, 0x29, 0x71, 0x80, 0x77, 0xd9, 0x2a, 0xd7, 0x30, 0x32, 0x57, - 0x49, 0x2f, 0x23, 0x8f, 0x5a, 0xe6, 0x4f, 0xa0, 0xab, 0x3d, 0x83, 0x52, 0x7c, 0xaa, 0xbe, 0x8d, - 0x9a, 0xd4, 0x35, 0x85, 0xcd, 0x90, 0x20, 0x0a, 0x81, 0xf4, 0xc2, 0x9d, 0x51, 0xda, 0x11, 0x0c, - 0xcc, 0xde, 0xa7, 0x52, 0xcb, 0xda, 0x46, 0xaa, 0x52, 0xcb, 0x39, 0x2d, 0x53, 0xe3, 0x2c, 0xbc, - 0xd3, 0xa8, 0x87, 0xa0, 0x29, 0x8d, 0xba, 0x45, 0x0f, 0x54, 0x8f, 0xba, 0xe5, 0x36, 0xab, 0x1e, - 0x75, 0x2b, 0x4d, 0x53, 0xf3, 0x4c, 0x7c, 0x19, 0x29, 0x19, 0x94, 0xc0, 0xb0, 0xd4, 0x16, 0x45, - 0xa5, 0x5d, 0x97, 0x3b, 0xa9, 0x93, 0xf7, 0xe7, 0xce, 0x8b, 0xf5, 0xde, 0x63, 0xeb, 0x8d, 0xf1, - 0xaa, 0x5a, 0xcf, 0x0d, 0x43, 0x2e, 0x26, 0x1e, 0x09, 0x40, 0x35, 0x39, 0x95, 0x1e, 0x54, 0xfa, - 0xa4, 0x93, 0x49, 0xdd, 0x94, 0x58, 0xc4, 0xd0, 0x36, 0xbe, 0x88, 0x0c, 0xb3, 0x53, 0xe8, 0x6a, - 0xad, 0x37, 0xc5, 0xb7, 0x6a, 0x57, 0x4f, 0xf1, 0xad, 0xae, 0x57, 0x67, 0xf0, 0x2d, 0x25, 0x59, - 0x18, 0x9f, 0xb0, 0xde, 0x1e, 0x5d, 0xe3, 0x3b, 0xe8, 0xc8, 0xa6, 0x1d, 0x2a, 0x2c, 0xa2, 0xd4, - 0xd9, 0x9b, 0x8c, 0xab, 0x13, 0x25, 0x33, 0x64, 0x0e, 0x35, 0x15, 0xb3, 0x94, 0x2e, 0x81, 0x61, - 0xa9, 0xf1, 0xa7, 0xe4, 0x51, 0xdf, 0x11, 0x9c, 0x98, 0xaf, 0xb9, 0xf8, 0xdd, 0x28, 0x7e, 0x87, - 0x2d, 0xb0, 0x8e, 0x98, 0x0c, 0x52, 0xf9, 0x21, 0x97, 0xc1, 0x5d, 0x0b, 0xcd, 0x4a, 0x8d, 0x40, - 0xd1, 0x51, 0xd2, 0x1c, 0x6d, 0x6d, 0x9f, 0x70, 0x52, 0x77, 0xa5, 0x81, 0x7f, 0xc0, 0xd6, 0x7a, - 0x07, 0x5d, 0x37, 0xd6, 0xa2, 0x56, 0x23, 0x6f, 0x74, 0xee, 0x5a, 0x68, 0x0a, 0x03, 0x93, 0xe4, - 0x5b, 0x2d, 0x55, 0x32, 0x4f, 0x84, 0x2a, 0x4b, 0xd1, 0x35, 0x7e, 0x5f, 0xeb, 0x9a, 0x1a, 0xfd, - 0x4f, 0x74, 0xab, 0x7e, 0xad, 0x52, 0x7f, 0x74, 0xb2, 0xa6, 0xaf, 0x29, 0x27, 0x31, 0x66, 0x8b, - 0xde, 0x40, 0x93, 0xea, 0xa2, 0xae, 0xc0, 0x61, 0x1e, 0xae, 0xa7, 0x57, 0xe6, 0x2a, 0x31, 0xab, - 0x29, 0xee, 0x55, 0x62, 0x56, 0x57, 0xcc, 0x4b, 0xe1, 0xf1, 0xc4, 0x8c, 0x55, 0xee, 0xa7, 0x1c, - 0x83, 0x6a, 0xc8, 0x49, 0xb9, 0x82, 0xbf, 0x31, 0xa7, 0xc6, 0x2d, 0xe5, 0x39, 0xb5, 0x15, 0xb0, - 0x34, 0x23, 0xb4, 0x22, 0x97, 0x0a, 0xa2, 0x13, 0x5e, 0x08, 0xa3, 0x6f, 0xa0, 0xc5, 0xca, 0x4b, - 0xb4, 0xa6, 0x52, 0x71, 0x55, 0xc5, 0x4e, 0xd6, 0x4b, 0x50, 0x33, 0x55, 0xc0, 0x2c, 0x76, 0xe5, - 0x91, 0xc8, 0x5a, 0xa7, 0x30, 0xe0, 0xc9, 0x9f, 0x2c, 0xc2, 0x94, 0xd1, 0x94, 0x6a, 0x44, 0x65, - 0x34, 0xe5, 0x7a, 0xcd, 0x74, 0x97, 0x3c, 0xff, 0xbb, 0x10, 0x38, 0xf7, 0xac, 0xcd, 0xe9, 0x12, - 0xfb, 0xe7, 0xc5, 0x67, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xc4, 0x0b, 0x0f, 0xf4, 0xa4, 0x31, - 0x00, 0x00, + // 4246 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x8f, 0x1c, 0x49, + 0x56, 0x9d, 0xf5, 0xd1, 0x55, 0xf5, 0xea, 0xb3, 0xa3, 0x3f, 0x5c, 0xae, 0xb1, 0x67, 0x7a, 0x83, + 0xf1, 0xc8, 0xd3, 0x9e, 0x69, 0x9b, 0x9e, 0x1d, 0x66, 0xc7, 0xe0, 0xd1, 0x74, 0xb7, 0x6b, 0xc7, + 0x9e, 0xa9, 0xe9, 0xb6, 0xb2, 0xed, 0xb1, 0x59, 0xc1, 0xa6, 0xb2, 0x32, 0xc3, 0xdd, 0x89, 0xb3, + 0x32, 0x6b, 0x32, 0xb3, 0xba, 0xdd, 0x70, 0x41, 0x2b, 0x4e, 0x70, 0xe0, 0x80, 0x38, 0xc3, 0x09, + 0x21, 0x81, 0xb8, 0x72, 0x01, 0x89, 0x33, 0x57, 0x0e, 0x48, 0xc0, 0x05, 0x89, 0x1f, 0x80, 0x56, + 0x5c, 0x91, 0x50, 0x7c, 0x65, 0x46, 0x64, 0x66, 0xf5, 0xda, 0x2b, 0xe0, 0xd2, 0xaa, 0x78, 0xf1, + 0xf2, 0xbd, 0x88, 0xf7, 0x5e, 0xbc, 0xaf, 0x88, 0x86, 0xce, 0xeb, 0x85, 0x1b, 0xcd, 0x9d, 0xdd, + 0x79, 0x14, 0x26, 0x21, 0x5a, 0xe5, 0xa3, 0xd1, 0x9a, 0x1d, 0x04, 0x61, 0x62, 0x27, 0x5e, 0x18, + 0xc4, 0x7c, 0x0a, 0x6f, 0xc2, 0xfa, 0xbe, 0xeb, 0x1e, 0x2e, 0xa2, 0x88, 0x04, 0xce, 0xa5, 0x49, + 0xe2, 0x79, 0x18, 0xc4, 0x04, 0xff, 0x14, 0x7a, 0xfb, 0xae, 0xfb, 0xc4, 0xf6, 0x22, 0x93, 0x7c, + 0xbf, 0x20, 0x71, 0x82, 0xde, 0x87, 0xee, 0xd4, 0x8e, 0x89, 0xe5, 0x08, 0xd4, 0xa1, 0xb1, 0x6d, + 0xdc, 0x6e, 0x99, 0x3a, 0x10, 0x7d, 0x00, 0xbd, 0xef, 0x17, 0x61, 0xa2, 0xa0, 0x55, 0x18, 0x5a, + 0x0e, 0x8a, 0xd7, 0xa0, 0x9f, 0xd2, 0x17, 0x2c, 0xff, 0xce, 0x80, 0xfa, 0xbe, 0x4f, 0xa2, 0x04, + 0xdd, 0x81, 0x5a, 0x72, 0x39, 0x27, 0x8c, 0x43, 0x6f, 0xef, 0xda, 0xae, 0xd8, 0x0b, 0x9b, 0xe4, + 0x7f, 0x9f, 0x5e, 0xce, 0x89, 0xc9, 0x90, 0xd0, 0x10, 0x1a, 0x33, 0x12, 0xc7, 0xf6, 0x29, 0x11, + 0xac, 0xe4, 0x10, 0x1d, 0xd2, 0x15, 0xfb, 0x76, 0xe0, 0x10, 0xcb, 0xa6, 0x1f, 0x0d, 0xab, 0xdb, + 0xc6, 0xed, 0xf6, 0xde, 0x3b, 0x92, 0xde, 0xe1, 0x99, 0x1d, 0x04, 0xc4, 0x3f, 0xe0, 0x38, 0x8c, + 0xee, 0xa3, 0x15, 0x53, 0xff, 0x06, 0xdf, 0x80, 0x56, 0xca, 0x11, 0xf5, 0xa1, 0x3d, 0x39, 0x7e, + 0x6e, 0x1d, 0xec, 0x4f, 0xf6, 0x8f, 0x0e, 0xc7, 0x83, 0x95, 0x83, 0x16, 0x34, 0xe6, 0xf6, 0xa5, + 0x1f, 0xda, 0x2e, 0xfe, 0xdb, 0x0a, 0x34, 0x04, 0x29, 0x2a, 0xab, 0x24, 0x4c, 0x6c, 0xdf, 0x12, + 0xb4, 0xd8, 0x4e, 0x6a, 0xa6, 0x0e, 0x44, 0xb7, 0xa1, 0xef, 0xf0, 0x25, 0xa4, 0x78, 0x15, 0x86, + 0x97, 0x07, 0xa3, 0x1f, 0xc1, 0xb5, 0x39, 0x09, 0x5c, 0x2f, 0x38, 0xb5, 0xf2, 0x5f, 0x54, 0xd9, + 0x17, 0xcb, 0xa6, 0xd1, 0x7d, 0x18, 0x7a, 0x81, 0xed, 0x24, 0xde, 0x39, 0x29, 0x7c, 0x5a, 0x63, + 0x9f, 0x2e, 0x9d, 0xa7, 0xba, 0xbc, 0xb0, 0x7d, 0x9f, 0x24, 0xe9, 0x17, 0x75, 0xf6, 0x45, 0x0e, + 0x8a, 0xbe, 0x80, 0xd1, 0x22, 0x70, 0xc2, 0xe0, 0xa5, 0x17, 0xcd, 0x88, 0x6b, 0xe5, 0xbe, 0x59, + 0x65, 0xdf, 0x5c, 0x81, 0x81, 0x7f, 0x0d, 0xe0, 0xc0, 0x0e, 0xa4, 0x9d, 0xdd, 0x86, 0x7e, 0x10, + 0xba, 0xc4, 0xf2, 0x5c, 0x12, 0x24, 0xde, 0x4b, 0x8f, 0x44, 0xc2, 0xd2, 0xf2, 0x60, 0xdc, 0x85, + 0x36, 0xfb, 0x4e, 0xd8, 0xcf, 0x67, 0x50, 0x3f, 0x3c, 0xb3, 0xbd, 0x00, 0x6d, 0x40, 0xdd, 0xa1, + 0x3f, 0xc4, 0x77, 0x7c, 0x40, 0xed, 0x24, 0x20, 0xc9, 0x45, 0x18, 0xbd, 0x92, 0x76, 0x22, 0x86, + 0x78, 0x0e, 0x4d, 0x61, 0x0a, 0x31, 0xda, 0x82, 0x55, 0x2e, 0x0d, 0xf6, 0x71, 0xd7, 0x14, 0x23, + 0x34, 0x82, 0xa6, 0x94, 0x13, 0xfb, 0xbc, 0x6b, 0xa6, 0x63, 0x4a, 0x59, 0x88, 0x9f, 0x69, 0xa3, + 0x6b, 0xca, 0x21, 0xa5, 0xe6, 0xf8, 0x61, 0x4c, 0x5c, 0x26, 0xeb, 0xae, 0x29, 0x46, 0xf8, 0x3f, + 0x0d, 0x58, 0x2f, 0xb1, 0xbe, 0x37, 0xb4, 0x9b, 0x1f, 0x42, 0x2d, 0xf6, 0x5c, 0xbe, 0x8e, 0xde, + 0xde, 0xf6, 0x15, 0xe6, 0xbc, 0x7b, 0xe2, 0xb9, 0xc4, 0x64, 0xd8, 0x54, 0x2a, 0xd3, 0x70, 0x11, + 0xb8, 0x62, 0x8d, 0x7c, 0x80, 0x30, 0x74, 0xe8, 0x6c, 0xce, 0x26, 0x34, 0x18, 0x5d, 0x95, 0x34, + 0x8d, 0x79, 0xe8, 0x05, 0x09, 0x33, 0x83, 0x96, 0xa9, 0x03, 0xf1, 0x4d, 0xa8, 0x51, 0x6e, 0x08, + 0x60, 0xd5, 0x1c, 0x7f, 0x7b, 0xfc, 0x74, 0x3c, 0x58, 0x41, 0x2d, 0xa8, 0x4f, 0x8e, 0x0f, 0xf7, + 0x27, 0x03, 0x03, 0xff, 0x3d, 0xdd, 0x32, 0xdd, 0xbd, 0x58, 0xe6, 0x5b, 0xab, 0x9b, 0xaa, 0x20, + 0xe7, 0x54, 0xd2, 0x31, 0xdd, 0xdc, 0xcb, 0x30, 0x12, 0xc7, 0xa1, 0x69, 0xf2, 0x01, 0xda, 0x86, + 0xb6, 0x4b, 0xe2, 0xc4, 0x0b, 0x98, 0xc7, 0x63, 0x7b, 0x6b, 0x99, 0x2a, 0x88, 0xa9, 0x7b, 0x16, + 0x2e, 0xc4, 0x9e, 0x6a, 0xa6, 0x18, 0xa1, 0x01, 0x54, 0x5f, 0x12, 0x69, 0xbb, 0xf4, 0x27, 0xfe, + 0x12, 0x36, 0xf4, 0xe5, 0x73, 0xab, 0xa3, 0xeb, 0x4f, 0x22, 0x3b, 0x88, 0xa9, 0x2d, 0x84, 0x81, + 0xe5, 0xb9, 0xf1, 0xd0, 0xd8, 0xae, 0xd2, 0xf5, 0xe7, 0xc0, 0xf8, 0x23, 0xe8, 0x1d, 0x86, 0x41, + 0x40, 0x9c, 0x44, 0xee, 0x7d, 0x04, 0x4d, 0xb6, 0xc9, 0x45, 0xe4, 0x89, 0x4d, 0xa7, 0x63, 0xea, + 0x20, 0x53, 0x6c, 0x61, 0xe0, 0x77, 0x61, 0xed, 0x30, 0x22, 0x76, 0x42, 0x8e, 0x42, 0x97, 0x28, + 0x34, 0xe6, 0x76, 0x1c, 0x5f, 0x84, 0x91, 0x2b, 0x69, 0xc8, 0x31, 0xfe, 0x53, 0x03, 0x90, 0xfa, + 0x85, 0x58, 0xf2, 0xaf, 0x40, 0x37, 0x26, 0xc4, 0xb5, 0x66, 0x01, 0x99, 0x85, 0x81, 0xe7, 0x88, + 0x05, 0x77, 0x28, 0xf0, 0x5b, 0x01, 0x43, 0x1f, 0xc2, 0xc0, 0x0b, 0xbc, 0xc4, 0xb3, 0x7d, 0xef, + 0x77, 0x89, 0x6b, 0xf9, 0x81, 0x1b, 0x0f, 0x2b, 0x7c, 0x63, 0x0a, 0x7c, 0x12, 0xb8, 0x31, 0xba, + 0x0b, 0xeb, 0x2a, 0xaa, 0x43, 0x97, 0xfd, 0x3a, 0x11, 0xaa, 0x40, 0xca, 0xd4, 0x21, 0x9f, 0xc1, + 0xff, 0x6c, 0x40, 0x53, 0x46, 0x1c, 0x4d, 0xad, 0x46, 0x4e, 0xad, 0x0f, 0xa0, 0x1d, 0x5f, 0xd8, + 0x73, 0xcb, 0xf1, 0x3d, 0x12, 0x24, 0xc2, 0xe0, 0x33, 0xff, 0x2d, 0xd0, 0x76, 0x4f, 0x2e, 0xec, + 0xf9, 0x21, 0x43, 0x31, 0x55, 0x7c, 0x7e, 0x9c, 0x5e, 0x91, 0xc0, 0xb2, 0x5d, 0x37, 0x22, 0x71, + 0xcc, 0x96, 0xd4, 0x32, 0x75, 0x20, 0x75, 0x73, 0x2e, 0x71, 0xbc, 0x99, 0xed, 0x5b, 0x73, 0xdf, + 0x76, 0x48, 0x2c, 0x0e, 0x6b, 0x0e, 0x8a, 0x31, 0x40, 0xc6, 0x08, 0x35, 0xa0, 0x3a, 0x39, 0x7a, + 0x38, 0x58, 0x41, 0x6d, 0x68, 0x1c, 0x1e, 0x1f, 0x1d, 0x8d, 0x5f, 0x3c, 0x1d, 0x54, 0xa8, 0x8e, + 0x1f, 0x92, 0x79, 0x18, 0x7b, 0xaa, 0x8e, 0x97, 0x6d, 0x0f, 0xdf, 0x81, 0x7e, 0x8a, 0x2d, 0x74, + 0x33, 0x84, 0x86, 0x5c, 0x2c, 0xc7, 0x96, 0x43, 0x6a, 0x80, 0x0f, 0xbd, 0xd8, 0x09, 0xcf, 0x49, + 0x44, 0xb5, 0x19, 0xbf, 0xbd, 0xbf, 0xfc, 0x14, 0x36, 0x73, 0x14, 0x04, 0xd3, 0x1b, 0xd0, 0x0a, + 0x16, 0x33, 0x8b, 0xe2, 0xc7, 0xc2, 0xef, 0x65, 0x00, 0xfc, 0x87, 0x06, 0xa0, 0xf1, 0x6b, 0xe2, + 0x2c, 0x12, 0x42, 0xf7, 0xaf, 0x6c, 0x2c, 0x8c, 0x5c, 0x12, 0x59, 0x5e, 0x6a, 0x78, 0x72, 0xcc, + 0x3c, 0xa2, 0xed, 0xb1, 0x29, 0xe1, 0x6b, 0xc5, 0x90, 0xfa, 0x9b, 0x39, 0x21, 0x91, 0x35, 0x5f, + 0x4c, 0xad, 0x57, 0xe4, 0x52, 0x68, 0x44, 0x83, 0x51, 0xca, 0xdf, 0x2f, 0xec, 0x20, 0xf1, 0x92, + 0x4b, 0xe1, 0x8f, 0xd2, 0x31, 0x3d, 0x03, 0x5f, 0x91, 0x44, 0xf8, 0xb8, 0x37, 0x91, 0xf1, 0x5f, + 0x1a, 0x80, 0xd4, 0x2f, 0xc4, 0x96, 0x1f, 0x42, 0x53, 0xb8, 0x37, 0x7e, 0x5e, 0xdb, 0x7b, 0xb7, + 0xa5, 0x59, 0x15, 0xb1, 0x77, 0xc5, 0x38, 0x1e, 0x07, 0x49, 0x74, 0x69, 0xa6, 0x5f, 0x8e, 0x26, + 0xd0, 0xd5, 0xa6, 0xa8, 0xdf, 0xa0, 0xbb, 0xe2, 0x8b, 0xa0, 0x3f, 0xd1, 0x2d, 0xa8, 0x9f, 0xdb, + 0xfe, 0x82, 0x7b, 0xeb, 0xf6, 0x5e, 0x5f, 0x72, 0x91, 0x2c, 0xf8, 0xec, 0xfd, 0xca, 0x8f, 0x0c, + 0x3c, 0x80, 0xde, 0x57, 0x24, 0x79, 0x1c, 0xbc, 0x0c, 0xc5, 0xc6, 0xf0, 0xbf, 0x54, 0xa1, 0x9f, + 0x82, 0x32, 0x0b, 0x39, 0x27, 0x51, 0x4c, 0x1d, 0x9a, 0xb0, 0x10, 0x31, 0xa4, 0xb2, 0x65, 0x2a, + 0x97, 0xb2, 0xe5, 0xa2, 0xd7, 0x60, 0x08, 0x41, 0x6d, 0x11, 0x79, 0xf4, 0x24, 0xd0, 0xa3, 0xcc, + 0x7e, 0x4b, 0xf5, 0x53, 0x1d, 0x48, 0xdb, 0xcf, 0x00, 0xe9, 0xac, 0xed, 0x45, 0x31, 0xf3, 0x92, + 0x72, 0x96, 0x02, 0xd0, 0x1d, 0x58, 0x65, 0x5a, 0x8f, 0x99, 0xaf, 0x6c, 0xef, 0xad, 0xcb, 0xfd, + 0x1d, 0x33, 0xe8, 0x21, 0xf5, 0xa6, 0xa6, 0x40, 0x41, 0x7b, 0x50, 0xf5, 0x03, 0x77, 0xd8, 0x60, + 0xf2, 0xde, 0x56, 0xe4, 0xad, 0x6e, 0x70, 0x77, 0x12, 0xb8, 0x5c, 0xce, 0x14, 0x99, 0x7a, 0x76, + 0xdb, 0xf7, 0xec, 0x78, 0xd8, 0xe2, 0xc1, 0x9c, 0x0d, 0xd4, 0x60, 0x0e, 0x5a, 0x30, 0x47, 0xf7, + 0x60, 0x5d, 0xe6, 0x42, 0xcc, 0x15, 0x9c, 0xd9, 0xf1, 0x19, 0x89, 0x87, 0x6d, 0xb6, 0xdf, 0xb2, + 0x29, 0xf4, 0x31, 0x34, 0xa4, 0xcb, 0xea, 0xe8, 0x7b, 0x10, 0xfe, 0x8a, 0xad, 0x4e, 0xe2, 0x8c, + 0xbe, 0x82, 0xa6, 0x5c, 0xe1, 0x5b, 0xa8, 0x7b, 0x12, 0xb8, 0x8c, 0x8c, 0xa2, 0xee, 0x2f, 0x98, + 0x61, 0xd2, 0x93, 0xa8, 0xa8, 0xfc, 0x2d, 0x8e, 0xb3, 0x09, 0xeb, 0xda, 0xf7, 0xa9, 0x77, 0xef, + 0x47, 0x64, 0xbe, 0xe0, 0x59, 0xfe, 0x89, 0x13, 0x46, 0x3c, 0x8b, 0x58, 0x33, 0x21, 0x03, 0xd3, + 0xb8, 0x37, 0xa5, 0x71, 0x8c, 0x9f, 0xcf, 0xa6, 0x29, 0x46, 0xf8, 0x1a, 0x6c, 0x4e, 0xbc, 0x38, + 0x11, 0x9e, 0xd5, 0x4b, 0xbd, 0x0c, 0xfe, 0x1a, 0xb6, 0xf2, 0x13, 0x82, 0xdf, 0x3d, 0x00, 0x27, + 0x85, 0x8a, 0xb3, 0x34, 0xc8, 0xbb, 0x68, 0x53, 0xc1, 0xc1, 0xff, 0x68, 0xc0, 0x1a, 0x25, 0xc6, + 0x4d, 0x44, 0x6e, 0x5c, 0xf1, 0x19, 0x86, 0xee, 0x33, 0x3e, 0x85, 0x7a, 0x78, 0x11, 0x90, 0x48, + 0xf8, 0xff, 0xf7, 0x52, 0x99, 0xe6, 0x69, 0xec, 0x1e, 0x53, 0x34, 0x93, 0x63, 0x53, 0xcb, 0xf1, + 0xbd, 0x99, 0x97, 0xc8, 0x84, 0x87, 0x0d, 0xa8, 0x7c, 0xbd, 0xc0, 0xf1, 0x17, 0x2e, 0x4d, 0xf0, + 0x3d, 0x3b, 0x16, 0xee, 0xbe, 0x69, 0xe6, 0xc1, 0xf8, 0x7d, 0xa8, 0x33, 0x7a, 0xa8, 0x09, 0xb5, + 0x83, 0xe3, 0xa7, 0x8f, 0x06, 0x2b, 0xd4, 0xe9, 0x1f, 0x3f, 0x3f, 0x1a, 0x18, 0x14, 0xf4, 0x64, + 0x3c, 0x36, 0x07, 0x15, 0xfc, 0x67, 0x06, 0x20, 0x75, 0x21, 0x42, 0x2a, 0x5f, 0xa4, 0xe7, 0x82, + 0x4b, 0xe4, 0x83, 0xb2, 0x45, 0x0b, 0x83, 0xe7, 0x43, 0x6e, 0xf3, 0xe2, 0xab, 0xd1, 0x63, 0x68, + 0x2b, 0xe0, 0x12, 0x43, 0x7b, 0x5f, 0x37, 0xb4, 0x9e, 0x7e, 0xee, 0x54, 0x3b, 0x43, 0x30, 0xa0, + 0x4c, 0x69, 0xad, 0x95, 0xaa, 0xf3, 0x43, 0xae, 0x01, 0x01, 0x13, 0x6b, 0xde, 0x80, 0x3a, 0x3f, + 0xe5, 0x3c, 0x1f, 0xe0, 0x83, 0xf4, 0x73, 0x92, 0xc9, 0x19, 0x7f, 0x26, 0x3e, 0x27, 0xea, 0x96, + 0x31, 0xd4, 0xb9, 0x0b, 0xe1, 0x3b, 0xee, 0xc8, 0x15, 0x51, 0x2c, 0x93, 0x4f, 0xe1, 0x7f, 0x33, + 0xa0, 0x21, 0x8e, 0x02, 0xb5, 0xc1, 0x38, 0xb1, 0x93, 0x85, 0x8c, 0x74, 0x62, 0x84, 0x3e, 0x82, + 0xa6, 0xc8, 0x2c, 0x63, 0xb1, 0xb9, 0x41, 0x2e, 0xc5, 0x8d, 0xcd, 0x14, 0x03, 0xdd, 0x82, 0x55, + 0x96, 0xdf, 0x73, 0x97, 0xd6, 0xde, 0xeb, 0x2a, 0xb8, 0x5e, 0x60, 0x8a, 0x49, 0x9a, 0x0a, 0x4e, + 0xfd, 0xd0, 0x79, 0x75, 0x46, 0xbc, 0xd3, 0xb3, 0x44, 0x78, 0x39, 0x15, 0x94, 0x7a, 0xc6, 0xba, + 0xe2, 0x19, 0x15, 0x5f, 0xbb, 0xaa, 0xfb, 0xda, 0xd4, 0x2d, 0x35, 0x14, 0xb7, 0x84, 0xbf, 0x86, + 0x1e, 0x3b, 0x8f, 0x59, 0xd2, 0x9a, 0xf7, 0xc9, 0x46, 0x89, 0x4f, 0x4e, 0x69, 0x55, 0x54, 0x5a, + 0x7f, 0x61, 0x00, 0x3a, 0x9e, 0x93, 0xe0, 0xff, 0x24, 0x5f, 0xce, 0xf2, 0xde, 0xaa, 0x96, 0xf7, + 0x6e, 0x43, 0x7b, 0xbe, 0x88, 0xcf, 0x2c, 0x31, 0xc9, 0xa3, 0xaf, 0x0a, 0x92, 0x99, 0x71, 0x3d, + 0xcb, 0x8c, 0x1f, 0xc0, 0xba, 0xb6, 0x4e, 0x61, 0x0e, 0x1f, 0x40, 0x4f, 0xcf, 0x80, 0xc5, 0x3a, + 0x73, 0x50, 0xfc, 0x0f, 0x15, 0xa8, 0x33, 0xa3, 0x65, 0xf6, 0x17, 0x79, 0xa2, 0xea, 0x31, 0x4c, + 0x3e, 0xd0, 0xb2, 0x81, 0x8a, 0x9e, 0x0d, 0xa8, 0x3e, 0xa3, 0xaa, 0xfb, 0x8c, 0x1e, 0x54, 0x3c, + 0x57, 0x64, 0xfc, 0x15, 0xcf, 0x45, 0x5f, 0x16, 0xc5, 0x56, 0x67, 0xb6, 0xb5, 0x25, 0xed, 0x45, + 0x57, 0x5c, 0xa9, 0x38, 0xfd, 0xd0, 0xb1, 0x7d, 0xca, 0x8c, 0x1b, 0x43, 0x3a, 0x46, 0xef, 0x02, + 0x38, 0x2c, 0xcf, 0x76, 0x2d, 0x3b, 0x61, 0x26, 0x51, 0x33, 0x15, 0x08, 0xba, 0x25, 0x2a, 0xb6, + 0x26, 0x73, 0x60, 0x6b, 0xda, 0x59, 0x55, 0x4a, 0x34, 0x0c, 0x1d, 0x2f, 0xb6, 0xc2, 0x8b, 0xc0, + 0x62, 0x5e, 0x80, 0x85, 0xbc, 0xa6, 0xa9, 0xc1, 0xa8, 0x99, 0x9e, 0x85, 0xbe, 0xcb, 0xc2, 0x5e, + 0xcd, 0x64, 0xbf, 0xf1, 0x9f, 0x1b, 0xd0, 0x61, 0xb4, 0x4c, 0x32, 0x0b, 0xcf, 0x6d, 0x5f, 0x93, + 0x99, 0xb1, 0x5c, 0x66, 0xb9, 0xdc, 0x4c, 0xcd, 0xe8, 0xaa, 0xb9, 0x8c, 0x4e, 0xdd, 0x7d, 0x2d, + 0xb7, 0xfb, 0xfc, 0xb2, 0xeb, 0xc5, 0x65, 0xe3, 0x33, 0x58, 0xe5, 0x9e, 0x09, 0x7d, 0x0c, 0x30, + 0x5d, 0x5c, 0x5a, 0x9a, 0x77, 0xec, 0x6a, 0x12, 0x31, 0x15, 0x04, 0x74, 0x17, 0xda, 0x31, 0xf1, + 0x7d, 0x89, 0x5f, 0x29, 0xc3, 0x57, 0x31, 0xf0, 0x27, 0xd2, 0x73, 0xb2, 0xdc, 0x83, 0xca, 0x8b, + 0xba, 0x1e, 0x91, 0xd6, 0xb2, 0xdf, 0xd4, 0x86, 0xc3, 0x8b, 0x40, 0xd4, 0xf1, 0xf4, 0x27, 0xfe, + 0x99, 0x21, 0xbe, 0x7a, 0x36, 0x77, 0xed, 0x84, 0xd0, 0x30, 0xce, 0xf7, 0x62, 0x30, 0x23, 0xd1, + 0xf9, 0x3d, 0x5a, 0x31, 0xf9, 0x2c, 0xfa, 0x0d, 0xe8, 0x72, 0x09, 0x45, 0x5c, 0xf0, 0xc2, 0x5f, + 0x6d, 0xe8, 0xcb, 0xe3, 0x73, 0x8f, 0x56, 0x4c, 0x1d, 0xf9, 0xa0, 0x07, 0x1d, 0x0e, 0x58, 0x30, + 0xa6, 0xf8, 0x5f, 0x2b, 0x50, 0xa3, 0xce, 0x72, 0x79, 0x11, 0xf0, 0x46, 0x29, 0xde, 0x97, 0xd0, + 0xf1, 0x03, 0x57, 0x0e, 0xa5, 0x5f, 0xbc, 0xa1, 0xba, 0x63, 0x9a, 0x8e, 0x3c, 0x59, 0x4c, 0xbf, + 0x21, 0x97, 0x22, 0xec, 0x68, 0x5f, 0x50, 0xfe, 0x5e, 0xc0, 0x9b, 0x05, 0x3c, 0x36, 0xca, 0x61, + 0x16, 0x22, 0xea, 0x4a, 0x88, 0xa0, 0x5e, 0xe3, 0xf5, 0xc2, 0xb5, 0x74, 0x57, 0xa9, 0x82, 0xd0, + 0x47, 0xb0, 0x16, 0x13, 0x27, 0x0c, 0xdc, 0x98, 0x97, 0x87, 0x4e, 0x42, 0x5c, 0x76, 0x4e, 0xba, + 0x66, 0x71, 0xa2, 0x3c, 0xe7, 0x1b, 0x3d, 0x80, 0x7e, 0x6e, 0xd9, 0x25, 0x61, 0x71, 0x43, 0x0d, + 0x8b, 0x2d, 0x35, 0x0c, 0xfe, 0x7e, 0x05, 0xd6, 0x9e, 0xd0, 0x4a, 0x4e, 0x28, 0x85, 0xbb, 0xd3, + 0xff, 0x4d, 0x9f, 0xa3, 0x9e, 0x9f, 0x5a, 0xee, 0xfc, 0x48, 0x0f, 0x50, 0xbf, 0xda, 0x03, 0xec, + 0xc0, 0x20, 0x22, 0xac, 0xde, 0xb4, 0x52, 0x52, 0x5c, 0x9c, 0x05, 0x38, 0xcd, 0x74, 0xbd, 0xd9, + 0x8c, 0xb8, 0x9e, 0x9d, 0x50, 0xa8, 0xe5, 0xd0, 0x7a, 0xc2, 0x67, 0x52, 0x6d, 0x9a, 0x65, 0x53, + 0x54, 0x04, 0x48, 0x15, 0x81, 0xf0, 0xd4, 0x9f, 0xd3, 0x52, 0x3f, 0x21, 0x51, 0x60, 0xfb, 0xd6, + 0xcc, 0x4e, 0x9c, 0x33, 0xb2, 0xe4, 0x5c, 0x16, 0xd0, 0xd0, 0xaf, 0x43, 0x8f, 0xa5, 0xd2, 0xf1, + 0xc2, 0x71, 0x48, 0x4c, 0x93, 0x29, 0x7e, 0x40, 0xd3, 0x14, 0x9a, 0x56, 0x8c, 0x27, 0x7c, 0xd2, + 0xcc, 0xa1, 0xa2, 0xcf, 0x68, 0xa6, 0x3a, 0xb3, 0xbd, 0x80, 0x66, 0xe4, 0xfc, 0xb8, 0x55, 0x4b, + 0x8e, 0x9b, 0x99, 0xc7, 0x42, 0x9f, 0x43, 0x97, 0x91, 0x7a, 0x69, 0x7b, 0xfe, 0x22, 0x62, 0x19, + 0x5c, 0x81, 0xe9, 0x8f, 0xf9, 0x9c, 0xa9, 0x63, 0xe2, 0x9f, 0x1b, 0xd0, 0xcf, 0x44, 0x30, 0x3e, + 0xa7, 0xa5, 0xfc, 0x2d, 0xa8, 0xb3, 0xfd, 0x2c, 0x3d, 0xec, 0x6c, 0x16, 0x7d, 0x0e, 0x1d, 0x75, + 0x03, 0xe2, 0xac, 0x97, 0xed, 0xf4, 0xd1, 0x8a, 0xa9, 0xa1, 0xa2, 0xcf, 0xdf, 0x6c, 0xa7, 0x8f, + 0x56, 0xca, 0xf6, 0xda, 0x51, 0x77, 0xc0, 0x0c, 0xab, 0x7c, 0xab, 0x29, 0x57, 0x81, 0x7a, 0xd0, + 0x80, 0x3a, 0xa1, 0x1b, 0xc4, 0x21, 0xb4, 0x95, 0x52, 0x66, 0x69, 0xe2, 0xa5, 0xb8, 0x9d, 0x8a, + 0xee, 0x76, 0x94, 0x3c, 0xa8, 0x56, 0xc8, 0x83, 0x78, 0xaf, 0xb5, 0xae, 0xf4, 0x5a, 0xf1, 0x27, + 0xb0, 0xc9, 0xbc, 0x1e, 0xc9, 0xee, 0x15, 0x7e, 0x71, 0xa5, 0x3e, 0x84, 0xad, 0xfc, 0x47, 0xa2, + 0xf1, 0x35, 0x01, 0xc4, 0x67, 0xb4, 0xa3, 0x7b, 0x55, 0x03, 0xe2, 0x8a, 0x03, 0x8c, 0x3f, 0x85, + 0x75, 0x8d, 0x9a, 0x38, 0x05, 0xef, 0xc2, 0x40, 0xa2, 0x58, 0x61, 0x60, 0xb1, 0x20, 0x6b, 0x28, + 0x41, 0x36, 0x5d, 0xde, 0xbe, 0xef, 0x6b, 0x55, 0x07, 0x5e, 0xc0, 0xb5, 0xc2, 0x8c, 0x20, 0xfa, + 0x11, 0xac, 0x31, 0x6f, 0x4f, 0xdc, 0xf4, 0xdc, 0xca, 0xf4, 0xba, 0x38, 0x41, 0xb1, 0x05, 0x67, + 0x05, 0x9b, 0x37, 0xdd, 0x8a, 0x13, 0xf8, 0x63, 0x58, 0xe3, 0x6c, 0xd5, 0x5b, 0x9a, 0xa5, 0x55, + 0x14, 0xde, 0x90, 0x42, 0xd4, 0x2e, 0x5d, 0xfe, 0xa0, 0x42, 0xc1, 0x71, 0x12, 0x46, 0x5a, 0x57, + 0xf1, 0x8d, 0x5a, 0x84, 0x6a, 0xeb, 0xb1, 0xa2, 0xb7, 0x1e, 0xd1, 0x37, 0xd0, 0xa6, 0x21, 0x65, + 0x6a, 0x3b, 0xaf, 0x16, 0x73, 0x19, 0x83, 0x76, 0xa4, 0xd5, 0x16, 0x39, 0xd2, 0x88, 0x74, 0xc0, + 0x91, 0x79, 0x44, 0x02, 0x3f, 0x05, 0xa0, 0x1f, 0xb0, 0xeb, 0x2c, 0xcb, 0xb5, 0x13, 0x7b, 0x6a, + 0xc7, 0xbc, 0x2d, 0xdb, 0x61, 0x01, 0xe6, 0xa1, 0x00, 0x89, 0xe0, 0xa0, 0x52, 0xf8, 0x45, 0xc1, + 0xa1, 0xa3, 0x06, 0x07, 0x42, 0x6d, 0x42, 0x59, 0x53, 0xd6, 0x29, 0x8d, 0x38, 0x58, 0x74, 0x40, + 0x85, 0x18, 0x24, 0x90, 0xb5, 0x3f, 0x3f, 0xa4, 0x3e, 0x5b, 0x20, 0xc9, 0x46, 0x02, 0xaf, 0xaa, + 0xfb, 0x12, 0x2e, 0x1b, 0x9f, 0x0f, 0x01, 0x9d, 0x90, 0x64, 0x12, 0x9e, 0x4e, 0xc8, 0x79, 0x96, + 0xd2, 0xef, 0x42, 0xcb, 0x0f, 0x4f, 0x2d, 0x9f, 0xc2, 0xc4, 0x9d, 0x57, 0x5a, 0xf1, 0xa4, 0xb8, + 0x19, 0x0a, 0xde, 0x84, 0x75, 0x8d, 0x8a, 0x50, 0xe5, 0x1a, 0xf4, 0x4f, 0xce, 0x16, 0x89, 0x1b, + 0x5e, 0xc8, 0xbb, 0x14, 0x5a, 0xbb, 0x65, 0x20, 0x81, 0xf6, 0x43, 0xd8, 0x3a, 0x59, 0x4c, 0x63, + 0x27, 0xf2, 0xa6, 0x44, 0xaf, 0xc0, 0x47, 0xd0, 0x24, 0xaf, 0xbd, 0x38, 0xf1, 0x82, 0x53, 0xb6, + 0x8c, 0xa6, 0x99, 0x8e, 0xa9, 0xf5, 0xa7, 0x5f, 0xb1, 0xab, 0x85, 0xd4, 0xfa, 0xdf, 0x83, 0x9b, + 0xe9, 0x0c, 0xf5, 0x46, 0xf1, 0xbe, 0xe3, 0x90, 0x79, 0x42, 0x5c, 0x89, 0xf0, 0x00, 0x36, 0x75, + 0x04, 0xe5, 0x46, 0x51, 0xd6, 0xdc, 0x89, 0xfd, 0x4a, 0x24, 0x5b, 0x4d, 0x53, 0x07, 0xe2, 0xff, + 0xae, 0x40, 0x87, 0x7e, 0x26, 0xc9, 0xa2, 0xeb, 0x85, 0x73, 0xdf, 0x60, 0xe3, 0xc7, 0x7a, 0x96, + 0x5a, 0xc9, 0x65, 0xa9, 0x57, 0xc6, 0xed, 0x65, 0xfd, 0xc6, 0x2c, 0x3f, 0xa8, 0xab, 0xf9, 0x41, + 0xbe, 0x8b, 0xb9, 0x5a, 0xd2, 0xc5, 0xdc, 0x82, 0xd5, 0x88, 0xb5, 0x98, 0x44, 0x89, 0x28, 0x46, + 0x34, 0xc4, 0xf3, 0x52, 0xca, 0x8a, 0x88, 0x43, 0xbc, 0x73, 0x2a, 0xed, 0x26, 0xe3, 0x5a, 0x80, + 0xd3, 0x1a, 0x4a, 0xc0, 0x62, 0x71, 0xc1, 0xd4, 0xe2, 0x37, 0x70, 0x3a, 0x14, 0xed, 0x02, 0x92, + 0x6e, 0x54, 0xa1, 0xca, 0x3b, 0x63, 0x25, 0x33, 0x74, 0x0d, 0x29, 0x54, 0x52, 0x6e, 0xf3, 0x34, + 0x23, 0x0f, 0xc7, 0x7f, 0x65, 0x40, 0x5b, 0x89, 0x32, 0xbf, 0x64, 0xdf, 0x57, 0x95, 0x71, 0x35, + 0x27, 0xe3, 0xbc, 0x34, 0x6b, 0x25, 0xd2, 0xfc, 0x00, 0x7a, 0x22, 0xac, 0x59, 0x11, 0xb1, 0xe3, + 0x50, 0x06, 0x9c, 0x1c, 0x14, 0xff, 0x4d, 0x95, 0xaf, 0x56, 0x44, 0xe2, 0xff, 0x5f, 0x63, 0xc9, + 0x54, 0x5e, 0xd7, 0x54, 0x7e, 0x1b, 0xfa, 0x9a, 0x6a, 0x89, 0x2b, 0x34, 0x9e, 0x07, 0xd3, 0x4c, + 0x3a, 0x53, 0x6d, 0x22, 0xb4, 0xad, 0x82, 0x0a, 0xc2, 0x82, 0x12, 0x61, 0x6d, 0x43, 0x2d, 0x0a, + 0x7d, 0xc2, 0x54, 0xda, 0xcb, 0x1a, 0x31, 0x66, 0xe8, 0x13, 0x93, 0xcd, 0xd0, 0x48, 0x93, 0x33, + 0x0b, 0xe2, 0xb2, 0xee, 0x67, 0xcb, 0x2c, 0x4e, 0xb0, 0x0b, 0x40, 0xc5, 0x2c, 0x92, 0x61, 0x57, + 0x5c, 0x00, 0xaa, 0x40, 0x5a, 0x04, 0x47, 0xd6, 0x3c, 0x22, 0xde, 0xcc, 0x3e, 0x25, 0xc3, 0x1e, + 0x43, 0x51, 0x20, 0xd9, 0x51, 0xea, 0x2b, 0x47, 0x09, 0xff, 0x57, 0x05, 0xea, 0x4f, 0x23, 0xdb, + 0x25, 0xb4, 0xd2, 0x9b, 0xd1, 0x13, 0x6f, 0x2d, 0xaf, 0xbc, 0x4c, 0x15, 0x83, 0x7e, 0x90, 0x28, + 0x1f, 0x54, 0x4a, 0x3f, 0x50, 0x30, 0x14, 0xfd, 0x54, 0x35, 0xfd, 0x5c, 0xa5, 0x53, 0xc5, 0x12, + 0xea, 0xba, 0x25, 0xa4, 0xfb, 0x59, 0x55, 0x5d, 0x83, 0x94, 0x7d, 0x63, 0xa9, 0xec, 0xb7, 0xa1, + 0x4d, 0xf8, 0x75, 0x0a, 0xeb, 0x16, 0x70, 0x4b, 0x50, 0x41, 0x69, 0xb1, 0xd0, 0xba, 0xba, 0x58, + 0xb8, 0x0f, 0x1d, 0x87, 0x1a, 0x06, 0x89, 0xe6, 0x76, 0x94, 0x70, 0x53, 0x58, 0xde, 0xd0, 0xd0, + 0x70, 0xf1, 0x1d, 0x58, 0x67, 0x52, 0x7f, 0xe4, 0xd1, 0x08, 0x75, 0xa9, 0x94, 0x43, 0xbc, 0x67, + 0x6a, 0x28, 0x3d, 0x53, 0xfc, 0x00, 0x36, 0x74, 0x64, 0x11, 0x1e, 0x6f, 0xc1, 0x6a, 0x42, 0xe1, + 0x85, 0x72, 0x81, 0x61, 0x9b, 0x62, 0x12, 0xff, 0xb1, 0x01, 0x5d, 0x0a, 0xf1, 0x82, 0xd3, 0x09, + 0xa5, 0x17, 0x53, 0x81, 0xcf, 0xec, 0xd7, 0x16, 0x2d, 0xdb, 0x65, 0x7f, 0x42, 0x8e, 0xd9, 0x7b, + 0x0e, 0xfb, 0xb5, 0x35, 0x5d, 0xc8, 0xcc, 0x4d, 0x0e, 0xa9, 0x19, 0x46, 0x24, 0x26, 0x11, 0x4d, + 0x9a, 0xd8, 0xa7, 0xdc, 0x91, 0xe8, 0x40, 0x7a, 0x40, 0x52, 0x00, 0x25, 0x22, 0x6e, 0xb4, 0x55, + 0x18, 0xde, 0xe3, 0x1b, 0x4a, 0x17, 0xf4, 0x26, 0xe9, 0xe9, 0x5f, 0x1b, 0xb0, 0x99, 0xfb, 0x48, + 0x88, 0x61, 0x1f, 0x56, 0x99, 0x9c, 0xa4, 0x18, 0x3e, 0x54, 0xc5, 0x50, 0x40, 0xdf, 0xe5, 0x43, + 0xd1, 0xee, 0xe5, 0x1f, 0x8e, 0x9e, 0x40, 0x5b, 0x01, 0x97, 0xa4, 0x2e, 0x77, 0xf4, 0x76, 0xef, + 0x66, 0x39, 0x0b, 0x25, 0xa3, 0xf9, 0x0e, 0x3a, 0xcf, 0x82, 0xe9, 0x2f, 0xf1, 0xac, 0x02, 0xdd, + 0x80, 0x56, 0x44, 0x44, 0x31, 0x2e, 0x12, 0x99, 0x0c, 0x80, 0xfb, 0xd0, 0x15, 0x74, 0xb3, 0x5b, + 0xe9, 0x67, 0x81, 0x1f, 0x3a, 0xaf, 0xde, 0xf4, 0x56, 0xfa, 0x27, 0x80, 0xd4, 0x0f, 0xb2, 0x54, + 0x6b, 0xc1, 0xa0, 0xb9, 0x54, 0x4b, 0x02, 0x59, 0xaa, 0xf5, 0x1e, 0xb4, 0x55, 0x14, 0x7e, 0x89, + 0x05, 0x19, 0x02, 0xfe, 0x23, 0x03, 0xfa, 0xcf, 0xbd, 0xe4, 0xcc, 0x8d, 0xec, 0x8b, 0x37, 0x50, + 0x6a, 0xfe, 0x85, 0x40, 0xe5, 0xaa, 0x17, 0x02, 0xd5, 0xfc, 0x0b, 0x01, 0xdb, 0xf7, 0x45, 0x7f, + 0x84, 0xfe, 0x54, 0x3b, 0xa3, 0x5d, 0xde, 0x19, 0xbd, 0x0f, 0x83, 0x6c, 0x31, 0x6f, 0xd7, 0x16, + 0xdd, 0xb9, 0x0d, 0xad, 0xf4, 0xbc, 0xa3, 0x06, 0x54, 0x0f, 0x9e, 0xfd, 0xe6, 0x60, 0x05, 0x35, + 0xa1, 0x76, 0x32, 0x9e, 0x4c, 0xf8, 0x0d, 0x04, 0xbb, 0x94, 0xa8, 0xec, 0xec, 0x40, 0x8d, 0x7a, + 0x17, 0xd4, 0x82, 0xfa, 0xd3, 0xfd, 0x6f, 0xc6, 0x26, 0x7f, 0x77, 0xf1, 0x2d, 0xfb, 0x69, 0xa0, + 0x0e, 0x34, 0x1f, 0x1f, 0x3d, 0x1d, 0x9b, 0x47, 0xfb, 0x93, 0x41, 0x65, 0xe7, 0x39, 0x34, 0x65, + 0xde, 0x48, 0x91, 0xf6, 0x27, 0x63, 0xf3, 0x29, 0xc7, 0x1f, 0x9b, 0xe6, 0xb1, 0xc9, 0xe9, 0x3e, + 0xdf, 0x37, 0x8f, 0x06, 0x15, 0xfa, 0xeb, 0xf1, 0xd1, 0x8f, 0x8f, 0x07, 0x55, 0xd4, 0x86, 0xc6, + 0x77, 0x63, 0xf3, 0xe0, 0xf8, 0x64, 0x3c, 0xa8, 0x51, 0xdc, 0x87, 0xe3, 0x83, 0x67, 0x5f, 0x0d, + 0xea, 0x8c, 0xa3, 0xb9, 0x7f, 0x38, 0x1e, 0xac, 0xee, 0xfd, 0xbb, 0x01, 0x8d, 0x17, 0x0b, 0xf7, + 0x71, 0xe0, 0x25, 0x68, 0x0c, 0x90, 0xbd, 0x3a, 0x40, 0xd7, 0xd3, 0x86, 0x7c, 0xfe, 0xed, 0xc2, + 0x68, 0x54, 0x36, 0x25, 0xcc, 0x6a, 0x05, 0x3d, 0x82, 0xb6, 0x92, 0x93, 0xa3, 0xd1, 0xf2, 0xe2, + 0x61, 0xf4, 0x4e, 0xe9, 0x5c, 0x4a, 0x69, 0x0c, 0x90, 0x59, 0x5c, 0xb6, 0xa0, 0x82, 0xd9, 0x66, + 0x0b, 0x2a, 0x1a, 0x28, 0x5e, 0xd9, 0xfb, 0xf9, 0x10, 0xaa, 0x2f, 0x16, 0x2e, 0x7a, 0x01, 0x6d, + 0xe5, 0xc9, 0x1c, 0x2a, 0x5c, 0x76, 0x65, 0xcb, 0x29, 0x7b, 0x59, 0x37, 0xfa, 0xd9, 0x3f, 0xfd, + 0xc7, 0x9f, 0x54, 0x36, 0x70, 0xff, 0xee, 0xf9, 0xaf, 0xde, 0xb5, 0x5d, 0x57, 0xda, 0xe2, 0x7d, + 0x63, 0x07, 0x99, 0xd0, 0x10, 0xaf, 0xe2, 0xd0, 0x96, 0x42, 0x43, 0x29, 0xf0, 0x46, 0xd7, 0x0a, + 0x70, 0x41, 0x77, 0x8b, 0xd1, 0x1d, 0xe0, 0xb6, 0xa0, 0x4b, 0xc3, 0x14, 0xa5, 0x79, 0x00, 0xd5, + 0x03, 0x3b, 0x40, 0x28, 0xbb, 0x78, 0x96, 0x3e, 0x61, 0xb4, 0xae, 0xc1, 0x04, 0x1d, 0xc4, 0xe8, + 0x74, 0x70, 0x83, 0xd2, 0x99, 0xda, 0x01, 0xa5, 0xe1, 0x40, 0x47, 0x7d, 0xfc, 0x82, 0xb2, 0x27, + 0x18, 0xc5, 0x17, 0x3d, 0xa3, 0x1b, 0xe5, 0x93, 0x82, 0xfc, 0x90, 0x91, 0x47, 0x78, 0x40, 0xc9, + 0xb3, 0xe7, 0x50, 0xe2, 0x2a, 0x87, 0x6e, 0x5e, 0xbc, 0x78, 0xc9, 0x36, 0xaf, 0x3f, 0x98, 0xc9, + 0x36, 0x9f, 0x7f, 0x1a, 0xa3, 0x6d, 0x5e, 0xb8, 0x2a, 0xba, 0xf0, 0x9f, 0x42, 0xf7, 0x39, 0x7b, + 0x6c, 0x26, 0xde, 0x59, 0x64, 0x94, 0xf5, 0x67, 0x1a, 0x19, 0xe5, 0xdc, 0x83, 0x0c, 0x7c, 0x83, + 0x51, 0xde, 0xc2, 0x6b, 0x94, 0x32, 0x7f, 0xb8, 0xe6, 0x72, 0x14, 0x4a, 0xff, 0x77, 0xa0, 0xab, + 0x3d, 0xa9, 0x40, 0xe9, 0xe6, 0xcb, 0xde, 0x6a, 0x8c, 0x6e, 0x2e, 0x99, 0x2d, 0xe3, 0xe5, 0x0a, + 0x14, 0xf6, 0x08, 0x83, 0xf2, 0x7a, 0x01, 0x90, 0x3d, 0x4d, 0xc8, 0xac, 0xb8, 0xf0, 0x1c, 0x22, + 0xb3, 0xe2, 0xe2, 0x4b, 0x06, 0xbc, 0xce, 0x58, 0x74, 0x51, 0x9b, 0x6b, 0x97, 0xd3, 0x9a, 0x40, + 0x43, 0x5c, 0xc2, 0x67, 0xf2, 0xd1, 0x5f, 0x22, 0x64, 0xf2, 0xc9, 0xdd, 0xd6, 0xe3, 0x01, 0x23, + 0x08, 0xa8, 0x49, 0x09, 0x7a, 0x94, 0xc4, 0x6f, 0x41, 0x5b, 0xb9, 0x97, 0x46, 0xea, 0x6a, 0x72, + 0x97, 0xdd, 0xd9, 0x41, 0x29, 0xb9, 0xc8, 0xc6, 0x1b, 0x8c, 0x72, 0x0f, 0x75, 0x28, 0x65, 0x2a, + 0x05, 0x46, 0xfd, 0x39, 0x40, 0x76, 0x85, 0x9a, 0x49, 0xa1, 0x70, 0x17, 0x9c, 0x49, 0xa1, 0x78, + 0xe3, 0x2a, 0x6d, 0x1c, 0x01, 0x25, 0x2d, 0x2e, 0x1a, 0x4e, 0xa1, 0xa7, 0xdf, 0x70, 0xa3, 0x9b, + 0x2a, 0x85, 0xc2, 0x95, 0xf8, 0xe8, 0xdd, 0x65, 0xd3, 0xba, 0x4d, 0xa2, 0x1e, 0xb3, 0xc9, 0x8c, + 0xec, 0x09, 0xb4, 0xd2, 0xbb, 0x57, 0x34, 0x54, 0x89, 0xa8, 0x57, 0xb4, 0xa3, 0xeb, 0x25, 0x33, + 0xb2, 0xd2, 0x67, 0x94, 0xdb, 0xa8, 0x45, 0x29, 0xf3, 0x16, 0xbc, 0x24, 0xca, 0x9e, 0x6c, 0xe8, + 0x44, 0x95, 0x8b, 0xdb, 0x1c, 0x51, 0xf5, 0xfa, 0x36, 0x47, 0x94, 0xd1, 0xb1, 0xa0, 0xad, 0xdc, + 0xec, 0x65, 0x9a, 0x2c, 0x5e, 0x4b, 0x66, 0x9a, 0x2c, 0xb9, 0x0a, 0xc4, 0xd7, 0x18, 0xe9, 0x35, + 0xee, 0xf2, 0xc2, 0x39, 0x09, 0xe4, 0x91, 0xff, 0x6d, 0x80, 0xac, 0x19, 0x9b, 0x29, 0xb3, 0xd0, + 0xa6, 0xcf, 0xcc, 0x2f, 0xd7, 0xbb, 0xc5, 0xd7, 0x19, 0xe9, 0x75, 0xcc, 0x84, 0xcc, 0x1a, 0xe4, + 0x4c, 0x9d, 0xf7, 0x8d, 0x9d, 0x7b, 0x06, 0x7a, 0x09, 0xbd, 0x0c, 0xff, 0xe4, 0x32, 0x70, 0xae, + 0x62, 0x31, 0x2a, 0x9b, 0x12, 0x1b, 0xb8, 0xc9, 0xb8, 0x5c, 0xc3, 0x48, 0xe7, 0x12, 0x5f, 0x06, + 0x0e, 0x3d, 0x99, 0x3f, 0x81, 0xb6, 0xf2, 0x40, 0x2a, 0x93, 0x53, 0xf1, 0xd5, 0xd4, 0xa8, 0xac, + 0x5d, 0xac, 0x87, 0x04, 0x51, 0x08, 0xc4, 0x17, 0xf6, 0x9c, 0xd2, 0x0e, 0xa0, 0xa7, 0x77, 0x45, + 0x33, 0xb3, 0x2c, 0x6d, 0xb1, 0x66, 0x66, 0xb9, 0xa4, 0x99, 0xaa, 0xed, 0x85, 0xf7, 0x20, 0xd5, + 0x10, 0x34, 0xa5, 0x51, 0x37, 0xed, 0x8e, 0xaa, 0x51, 0x37, 0xdf, 0x80, 0x55, 0xa3, 0x6e, 0xa1, + 0x9d, 0xaa, 0xef, 0x89, 0xb3, 0x91, 0x9a, 0x41, 0x11, 0xf4, 0x73, 0x0d, 0x53, 0x94, 0x5b, 0x75, + 0xbe, 0xc7, 0x3a, 0x7a, 0x6f, 0xe9, 0xbc, 0xe0, 0xf7, 0x2e, 0xe3, 0x37, 0xc4, 0xeb, 0x19, 0x3f, + 0xdb, 0xf7, 0xb9, 0x9a, 0x78, 0x24, 0x80, 0xac, 0xfd, 0x99, 0xd9, 0x41, 0xa1, 0x83, 0x3a, 0x1a, + 0x95, 0x4d, 0x09, 0x26, 0x9a, 0xb5, 0x71, 0x26, 0x32, 0xcc, 0x4e, 0xa1, 0xad, 0x34, 0xe5, 0x32, + 0xb9, 0x15, 0xfb, 0x7d, 0x99, 0xdc, 0xca, 0xba, 0x78, 0x9a, 0xdc, 0x62, 0x92, 0xf8, 0xe1, 0x29, + 0xeb, 0xfa, 0x51, 0x1e, 0xdf, 0x41, 0x53, 0xb6, 0xf3, 0x50, 0x7a, 0x22, 0x72, 0x3d, 0xbf, 0xd1, + 0xb0, 0x38, 0x91, 0x3b, 0x86, 0xcc, 0xa1, 0xc6, 0x62, 0x96, 0xd2, 0x25, 0xd0, 0xcf, 0xb5, 0x04, + 0x33, 0x7d, 0x94, 0xf7, 0x0a, 0x47, 0xfa, 0x3b, 0x2f, 0x7e, 0x6b, 0x8a, 0xdf, 0x61, 0x0c, 0x36, + 0x11, 0xd3, 0x41, 0x2c, 0x3f, 0xe4, 0x3a, 0xb8, 0x67, 0x20, 0x4b, 0x61, 0xc3, 0x7b, 0x88, 0x25, + 0x6c, 0xb4, 0xe6, 0xe2, 0xa8, 0xab, 0xbd, 0xfd, 0x5f, 0xc2, 0x80, 0x3d, 0xd4, 0xa7, 0x0c, 0xe6, + 0xb9, 0x4e, 0xa3, 0x68, 0x59, 0x29, 0x9e, 0xbc, 0xb4, 0x11, 0x39, 0x2a, 0xbb, 0x4d, 0xc1, 0x3f, + 0x60, 0xbc, 0xde, 0x41, 0xd7, 0x35, 0x5e, 0xf4, 0x58, 0xca, 0xcb, 0xa4, 0x7b, 0x06, 0x9a, 0x42, + 0x4f, 0x27, 0xf9, 0x56, 0xac, 0x72, 0xe7, 0x1f, 0xa1, 0x02, 0x2b, 0xca, 0xe3, 0xf7, 0x94, 0xd6, + 0xab, 0xd6, 0x60, 0x45, 0xb7, 0xca, 0x79, 0xe5, 0x1a, 0xb0, 0xa3, 0x0d, 0x95, 0xa7, 0x9c, 0xc4, + 0x98, 0x31, 0xbd, 0x81, 0x46, 0x45, 0xa6, 0xb6, 0xc0, 0x61, 0x2e, 0xb4, 0xa3, 0x96, 0xfe, 0x59, + 0xe6, 0x57, 0xd2, 0x3d, 0xc8, 0x32, 0xbf, 0xb2, 0x6e, 0x81, 0x54, 0x1e, 0xcf, 0xfc, 0x58, 0x6b, + 0xe0, 0x8c, 0x63, 0x50, 0x13, 0x3c, 0xcd, 0xb7, 0x08, 0x6e, 0x2c, 0x29, 0xa2, 0x73, 0x89, 0x54, + 0x69, 0x89, 0x2d, 0xcf, 0x29, 0x5a, 0x93, 0xac, 0xbc, 0xe0, 0x94, 0x57, 0xda, 0xe8, 0x6b, 0xa8, + 0xb3, 0xfa, 0x15, 0x6d, 0x64, 0xb9, 0x7e, 0x56, 0x26, 0x8f, 0x36, 0x73, 0x50, 0x3d, 0x17, 0xc1, + 0x2c, 0x38, 0x2e, 0x02, 0x91, 0x16, 0x4f, 0xa1, 0xc7, 0xb3, 0x4b, 0x59, 0xe5, 0x65, 0xa7, 0x32, + 0x57, 0x84, 0x66, 0xa7, 0x32, 0x5f, 0x10, 0xea, 0xfe, 0x98, 0x27, 0x98, 0x17, 0x02, 0xe7, 0xbe, + 0xb1, 0x33, 0x5d, 0x65, 0xff, 0xa6, 0xf3, 0xc9, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x62, 0x1e, + 0x21, 0xf1, 0xd1, 0x33, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -5135,6 +5392,8 @@ type XudClient interface { // its users a real time view of the orders available to them would subscribe to this streaming // call to be alerted as new orders are added and expired orders are removed. SubscribeOrders(ctx context.Context, in *SubscribeOrdersRequest, opts ...grpc.CallOption) (Xud_SubscribeOrdersClient, error) + // Subscribes to alerts such as low balance. + SubscribeAlerts(ctx context.Context, in *SubscribeAlertsRequest, opts ...grpc.CallOption) (Xud_SubscribeAlertsClient, error) // Subscribes to failed swaps. By default, only swaps that are initiated by a remote peer are // transmitted unless a flag is set to include swaps initiated by the local node. This call allows // the client to get real-time notifications when swap attempts are failing. It can be used for @@ -5442,8 +5701,40 @@ func (x *xudSubscribeOrdersClient) Recv() (*OrderUpdate, error) { return m, nil } +func (c *xudClient) SubscribeAlerts(ctx context.Context, in *SubscribeAlertsRequest, opts ...grpc.CallOption) (Xud_SubscribeAlertsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[2], "/xudrpc.Xud/SubscribeAlerts", opts...) + if err != nil { + return nil, err + } + x := &xudSubscribeAlertsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Xud_SubscribeAlertsClient interface { + Recv() (*Alert, error) + grpc.ClientStream +} + +type xudSubscribeAlertsClient struct { + grpc.ClientStream +} + +func (x *xudSubscribeAlertsClient) Recv() (*Alert, error) { + m := new(Alert) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + func (c *xudClient) SubscribeSwapFailures(ctx context.Context, in *SubscribeSwapsRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapFailuresClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[2], "/xudrpc.Xud/SubscribeSwapFailures", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[3], "/xudrpc.Xud/SubscribeSwapFailures", opts...) if err != nil { return nil, err } @@ -5475,7 +5766,7 @@ func (x *xudSubscribeSwapFailuresClient) Recv() (*SwapFailure, error) { } func (c *xudClient) SubscribeSwaps(ctx context.Context, in *SubscribeSwapsRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapsClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[3], "/xudrpc.Xud/SubscribeSwaps", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[4], "/xudrpc.Xud/SubscribeSwaps", opts...) if err != nil { return nil, err } @@ -5507,7 +5798,7 @@ func (x *xudSubscribeSwapsClient) Recv() (*SwapSuccess, error) { } func (c *xudClient) SubscribeSwapsAccepted(ctx context.Context, in *SubscribeSwapsAcceptedRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapsAcceptedClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[4], "/xudrpc.Xud/SubscribeSwapsAccepted", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[5], "/xudrpc.Xud/SubscribeSwapsAccepted", opts...) if err != nil { return nil, err } @@ -5671,6 +5962,8 @@ type XudServer interface { // its users a real time view of the orders available to them would subscribe to this streaming // call to be alerted as new orders are added and expired orders are removed. SubscribeOrders(*SubscribeOrdersRequest, Xud_SubscribeOrdersServer) error + // Subscribes to alerts such as low balance. + SubscribeAlerts(*SubscribeAlertsRequest, Xud_SubscribeAlertsServer) error // Subscribes to failed swaps. By default, only swaps that are initiated by a remote peer are // transmitted unless a flag is set to include swaps initiated by the local node. This call allows // the client to get real-time notifications when swap attempts are failing. It can be used for @@ -6159,6 +6452,27 @@ func (x *xudSubscribeOrdersServer) Send(m *OrderUpdate) error { return x.ServerStream.SendMsg(m) } +func _Xud_SubscribeAlerts_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SubscribeAlertsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(XudServer).SubscribeAlerts(m, &xudSubscribeAlertsServer{stream}) +} + +type Xud_SubscribeAlertsServer interface { + Send(*Alert) error + grpc.ServerStream +} + +type xudSubscribeAlertsServer struct { + grpc.ServerStream +} + +func (x *xudSubscribeAlertsServer) Send(m *Alert) error { + return x.ServerStream.SendMsg(m) +} + func _Xud_SubscribeSwapFailures_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(SubscribeSwapsRequest) if err := stream.RecvMsg(m); err != nil { @@ -6418,6 +6732,11 @@ var _Xud_serviceDesc = grpc.ServiceDesc{ Handler: _Xud_SubscribeOrders_Handler, ServerStreams: true, }, + { + StreamName: "SubscribeAlerts", + Handler: _Xud_SubscribeAlerts_Handler, + ServerStreams: true, + }, { StreamName: "SubscribeSwapFailures", Handler: _Xud_SubscribeSwapFailures_Handler,