From 2915a3e38b9c82042b52521059107dccb1c7f098 Mon Sep 17 00:00:00 2001 From: Matthew <45381190+Matthew17-21@users.noreply.github.com> Date: Mon, 6 Jan 2025 13:23:04 -0500 Subject: [PATCH] V1.0.0 (#4) * Added reverse engineering docs * Update .gitignore * Added protobuf for Hypurr * Added better documentation * Added hyperr utils package * Added env utils * Added function to convert unix ms to time.Time * Added method to extend HyperliquidLaunch * Added functions to sort launches * Exported GetValFromEnv * Added method to format supply * Added session handlers * Added default config * Added helpers to create new launch embeds * Updated webhook color * Added new launch monitor * Added dockerfile * Added docs on how to run docker image --- .Dockerignore | 4 + .gitignore | 3 + Dockerfile | 40 + README.md | 98 +- cmd/new-project-monitor/main.go | 131 + go.mod | 22 + go.sum | 48 + hypurr_utils/client.go | 25 + hypurr_utils/conn.go | 32 + internal/env_utils/env.go | 23 + internal/env_utils/env_test.go | 92 + internal/launch_utils/format.go | 66 + internal/launch_utils/format_test.go | 121 + internal/launch_utils/launch.go | 72 + internal/launch_utils/launch_test.go | 88 + internal/launch_utils/sort.go | 67 + internal/launch_utils/sort_test.go | 177 + internal/webhook/config.go | 24 + internal/webhook/new_launch.go | 81 + internal/webhook/new_launch_test.go | 76 + internal/webhook/session.go | 26 + internal/webhook/session_test.go | 104 + internal/webhook/webhook.go | 51 + pb/hypurr.pb.go | 7169 ++++++++++++++++++++++++++ pb/hypurr.proto | 613 +++ pb/hypurr_grpc.pb.go | 1116 ++++ 26 files changed, 10368 insertions(+), 1 deletion(-) create mode 100644 .Dockerignore create mode 100644 Dockerfile create mode 100644 cmd/new-project-monitor/main.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 hypurr_utils/client.go create mode 100644 hypurr_utils/conn.go create mode 100644 internal/env_utils/env.go create mode 100644 internal/env_utils/env_test.go create mode 100644 internal/launch_utils/format.go create mode 100644 internal/launch_utils/format_test.go create mode 100644 internal/launch_utils/launch.go create mode 100644 internal/launch_utils/launch_test.go create mode 100644 internal/launch_utils/sort.go create mode 100644 internal/launch_utils/sort_test.go create mode 100644 internal/webhook/config.go create mode 100644 internal/webhook/new_launch.go create mode 100644 internal/webhook/new_launch_test.go create mode 100644 internal/webhook/session.go create mode 100644 internal/webhook/session_test.go create mode 100644 internal/webhook/webhook.go create mode 100644 pb/hypurr.pb.go create mode 100644 pb/hypurr.proto create mode 100644 pb/hypurr_grpc.pb.go diff --git a/.Dockerignore b/.Dockerignore new file mode 100644 index 0000000..785fe34 --- /dev/null +++ b/.Dockerignore @@ -0,0 +1,4 @@ +reverse_engineering/ +.env +.gitignore +README.md \ No newline at end of file diff --git a/.gitignore b/.gitignore index 6f72f89..3ddaccb 100644 --- a/.gitignore +++ b/.gitignore @@ -23,3 +23,6 @@ go.work.sum # env file .env + +# Reverse engineering specifics +reverse_engineering \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..655e863 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,40 @@ +############################################################################### +# Build stage +############################################################################### +FROM golang:latest AS builder + +# Create and/or change our directory to /build +WORKDIR /build + +# Copy go mod & go.sum files so we can verify they haven't been tampered with +COPY go.mod go.sum ./ +RUN go mod download && go mod verify + +# Copy everything from our root into /build +COPY . . + +# Create and/or change our directory to /new-project-monitor +WORKDIR /build/cmd/new-project-monitor + +# Create the binary for the app +RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o app-binary + +############################################################################### +# Production stage +############################################################################### +# Start a new stage from scratch so that our final image is way smaller +# We use alpine instead of stratch since we need OS packages +FROM alpine:latest + +# Create and/or change our directory to /app +WORKDIR /app + +# Copy the binary from the build stage to the final stage +COPY --from=builder /build/cmd/new-project-monitor . + + +# Expose Port +EXPOSE 8080 + +# Run the app +CMD ["/app/app-binary"] \ No newline at end of file diff --git a/README.md b/README.md index b6c3179..8c04aad 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,98 @@ # HypurrFun -Program to monitor HypurrFun releases + +A tool for interacting with hypurr.fun + +## Overview + +This project allows you to monitor and interact releases on HypurrFun by reverse engineering and decoding the binary gRPC data used in their client-server communication. Since the platform doesn't provide official documentation for their `.protobuf` files or enable gRPC reflection, I've made a quick package to help decode their protocol. + +## Features + +- Hypurr Protobuf file +- Streaming support +- New project monitor + - Lightning quick + - Discord webhook notification + +## How to use + +### Docker + +To use the new project monitor, you can simply use Docker to build and run the image. To do so, use: + +Build the image: + +```bash +docker build -t hypurr-project-monitor:latest . +``` + +Run the image: + +```bash +docker run -d -i \ +-e NEW_LAUNCHES_WEBHOOK= \ +--name hypurr-new-releases hypurr-project-monitor:latest +``` + +Replace `` with your actual webhook URL for notifications. + +### Manually + +Alternatively, you can do: + +```bash +go run cmd/new-project-monitor/main.go +``` + +### Integration + +#### Go Integration + +To use this library in your own Go program, simply follow these steps: + +1. Install the package: + +```bash +go get -u github.com/Matthew17-21/HypurrFun +``` + +2. Use in your code: + +```go +package main + +import ( + "log" + hypurrutils "github.com/Matthew17-21/HypurrFun/hypurr_utils" +) + +func main() { + userAgent := "" // Replace with your user agent + + // Initialize the client + client, err := hypurrutils.NewStaticClient(userAgent) + if err != nil { + log.Fatalln(err) + } + + // Your implementation here +} +``` + +#### Other Languages + +The project supports integration with multiple programming languages through Protocol Buffers: + +1. Locate the Proto file at [`pb/hypurr.proto`](/pb/hypurr.proto) +2. Generate code for your target language using `protoc`: + +```bash +protoc --_out=. pb/hypurr.proto +``` + +Replace `` with your desired language (e.g., python, java, cpp). + +## TODOs + +- [ ] Tests + - [ ] Tests for the `hypurr_utils` package diff --git a/cmd/new-project-monitor/main.go b/cmd/new-project-monitor/main.go new file mode 100644 index 0000000..ab2b7ab --- /dev/null +++ b/cmd/new-project-monitor/main.go @@ -0,0 +1,131 @@ +package main + +import ( + "context" + "io" + "log" + "time" + + hypurrutils "github.com/Matthew17-21/HypurrFun/hypurr_utils" + launchutils "github.com/Matthew17-21/HypurrFun/internal/launch_utils" + "github.com/Matthew17-21/HypurrFun/internal/webhook" + "github.com/Matthew17-21/HypurrFun/pb" + "github.com/joho/godotenv" + "google.golang.org/grpc" +) + +const userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36" + +const ( + errorDelay = 1500 * time.Millisecond +) + +func main() { + // Initialize app + initialize() + + // Create a new client + client, err := hypurrutils.NewStaticClient(userAgent) + if err != nil { + log.Fatalln(err) + } + + // Create new context + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + // Monitor for new projects + monitorNewLaunches(ctx, client) +} + +// initialize sets up the application environment, such as loading `.env` variables. +func initialize() { + log.Println("Initializing application...") + + // Attempt to load environment variables from a `.env` file. + // If the file is missing or cannot be read, log a warning and proceed. + if err := godotenv.Load(); err != nil { + log.Printf("WARNING: Failed to load environment variables from .env file: %v", err) + } +} + +func monitorNewLaunches(ctx context.Context, client pb.StaticClient) { + log.Println("Monitoring for new Hypurr.fun launches...") + + // Create a function to establish the stream + establishStream := func() (grpc.ServerStreamingClient[pb.HyperliquidLaunchStreamResponse], error) { + return client.HyperliquidLaunchStream(ctx, &pb.HyperliquidLaunchStreamRequest{}) + } + + // Create the stream + launchesStream, err := establishStream() + if err != nil { + log.Fatalln("error with stream:", err) + } + + // Define a var to reference when getting new coins + // No need to have an array of launches, we only need to keep track of the lastest one + var latestCoin *launchutils.LaunchExtended + + // Listen to for new events + for { + resp, err := launchesStream.Recv() + if err != nil { + // Check to see if stream is closed + if err == io.EOF { + log.Println("Stream is closed.") + return + } + log.Println("Error receiving message from stream:", err) + launchesStream.CloseSend() + time.Sleep(errorDelay) + + // Attempt to reestablish the stream + launchesStream, err = establishStream() + if err != nil { + log.Fatalln("error with stream:", err) + } + continue + } + + // The first response message from the stream will be a list of tokens sorted by latest activity + // Update our initial array to to that + if latestCoin == nil { + // Sort by listed timestamp in descending order (most recent first) + tmp := launchutils.SortByListedTimestampDesc(resp.Launches) + if len(tmp) == 0 { + continue + } + log.Printf("Received initial launch list with %d launches\n", len(tmp)) + + // Get the first coin (latest one) and set it as the latest + latestCoin = launchutils.ToLaunchExtended(tmp[0]) + continue + } + + // For subsequent messages, if the listed timestamp is newer than the first element, add to array & send webhook + for _, launch := range resp.Launches { + // Filter out launches that are either: + // - Duplicates (same ID as an existing launch) + // - Or out of chronological order (earlier timestamp than what we already have) + coin := launchutils.ToLaunchExtended(launch) + if shouldSkipLaunch(coin, latestCoin) { + continue + } + log.Printf("New launch detected: %+v\n", launch) + + // Send webhook + webhook.SendNewLaunch(coin) + + // Update the latest coin + latestCoin = coin + } + } +} + +func shouldSkipLaunch(coin, latestCoin *launchutils.LaunchExtended) bool { + return coin == nil || + latestCoin == nil || + coin.Id == latestCoin.Id || + coin.LaunchTime.Before(latestCoin.LaunchTime) +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..7baf8a5 --- /dev/null +++ b/go.mod @@ -0,0 +1,22 @@ +module github.com/Matthew17-21/HypurrFun + +go 1.22.2 + +require ( + github.com/Monumental-Shopping/go-discord-webhook v1.1.1 + github.com/joho/godotenv v1.5.1 + github.com/stretchr/testify v1.8.4 + github.com/test-go/testify v1.1.4 + google.golang.org/grpc v1.69.2 + google.golang.org/protobuf v1.36.1 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + golang.org/x/net v0.33.0 // indirect + golang.org/x/sys v0.28.0 // indirect + golang.org/x/text v0.21.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20241230172942-26aa7a208def // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..f1f036c --- /dev/null +++ b/go.sum @@ -0,0 +1,48 @@ +github.com/Monumental-Shopping/go-discord-webhook v1.1.1 h1:s4Xit/WweCncUuapna0H2xmYA0/ZALX6il3UJNz2GTI= +github.com/Monumental-Shopping/go-discord-webhook v1.1.1/go.mod h1:WV+RisyjGyR9IzjLMzcSABNzIvFbYTk354DWQN54sxI= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= +github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/test-go/testify v1.1.4 h1:Tf9lntrKUMHiXQ07qBScBTSA0dhYQlu83hswqelv1iE= +github.com/test-go/testify v1.1.4/go.mod h1:rH7cfJo/47vWGdi4GPj16x3/t1xGOj2YxzmNQzk2ghU= +go.opentelemetry.io/otel v1.31.0 h1:NsJcKPIW0D0H3NgzPDHmo0WW6SptzPdqg/L1zsIm2hY= +go.opentelemetry.io/otel v1.31.0/go.mod h1:O0C14Yl9FgkjqcCZAsE053C13OaddMYr/hz6clDkEJE= +go.opentelemetry.io/otel/metric v1.31.0 h1:FSErL0ATQAmYHUIzSezZibnyVlft1ybhy4ozRPcF2fE= +go.opentelemetry.io/otel/metric v1.31.0/go.mod h1:C3dEloVbLuYoX41KpmAhOqNriGbA+qqH6PQ5E5mUfnY= +go.opentelemetry.io/otel/sdk v1.31.0 h1:xLY3abVHYZ5HSfOg3l2E5LUj2Cwva5Y7yGxnSW9H5Gk= +go.opentelemetry.io/otel/sdk v1.31.0/go.mod h1:TfRbMdhvxIIr/B2N2LQW2S5v9m3gOQ/08KsbbO5BPT0= +go.opentelemetry.io/otel/sdk/metric v1.31.0 h1:i9hxxLJF/9kkvfHppyLL55aW7iIJz4JjxTeYusH7zMc= +go.opentelemetry.io/otel/sdk/metric v1.31.0/go.mod h1:CRInTMVvNhUKgSAMbKyTMxqOBC0zgyxzW55lZzX43Y8= +go.opentelemetry.io/otel/trace v1.31.0 h1:ffjsj1aRouKewfr85U2aGagJ46+MvodynlQ1HYdmJys= +go.opentelemetry.io/otel/trace v1.31.0/go.mod h1:TXZkRk7SM2ZQLtR6eoAWQFIHPvzQ06FJAsO1tJg480A= +golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I= +golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= +golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= +golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= +golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241230172942-26aa7a208def h1:4P81qv5JXI/sDNae2ClVx88cgDDA6DPilADkG9tYKz8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20241230172942-26aa7a208def/go.mod h1:bdAgzvd4kFrpykc5/AC2eLUiegK9T/qxZHD4hXYf/ho= +google.golang.org/grpc v1.69.2 h1:U3S9QEtbXC0bYNvRtcoklF3xGtLViumSYxWykJS+7AU= +google.golang.org/grpc v1.69.2/go.mod h1:vyjdE6jLBI76dgpDojsFGNaHlxdjXN9ghpnd2o7JGZ4= +google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk= +google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/hypurr_utils/client.go b/hypurr_utils/client.go new file mode 100644 index 0000000..c558e0f --- /dev/null +++ b/hypurr_utils/client.go @@ -0,0 +1,25 @@ +package hypurrutils + +import ( + "fmt" + + "github.com/Matthew17-21/HypurrFun/pb" +) + +// NewStaticClient creates a new gRPC client to communicate with Hypurr.fun's static servers +func NewStaticClient(userAgent string) (pb.StaticClient, error) { + conn, err := createGRPCConnection(userAgent) + if err != nil { + return nil, fmt.Errorf("createGRPCConnection error: %w", err) + } + return pb.NewStaticClient(conn), nil +} + +// NewTelegramClient creates a new gRPC client to communicate with Hypurr.fun's telegram servers +func NewTelegramClient(userAgent string) (pb.TelegramClient, error) { + conn, err := createGRPCConnection(userAgent) + if err != nil { + return nil, fmt.Errorf("createGRPCConnection error: %w", err) + } + return pb.NewTelegramClient(conn), nil +} diff --git a/hypurr_utils/conn.go b/hypurr_utils/conn.go new file mode 100644 index 0000000..fa5a6c4 --- /dev/null +++ b/hypurr_utils/conn.go @@ -0,0 +1,32 @@ +package hypurrutils + +import ( + "fmt" + + "google.golang.org/grpc" + "google.golang.org/grpc/credentials" +) + +const ( + serverAddress = "grpc.hypurr.fun:443" + maxMessageSizeMB = 50 + maxMessageSizeB = 1024 * 1024 * maxMessageSizeMB +) + +// createGRPCConnection establishes a new gRPC connection with common configuration +func createGRPCConnection(userAgent string) (*grpc.ClientConn, error) { + // Set up TLS credentials + creds := credentials.NewClientTLSFromCert(nil, "") // nil uses the system's root CA pool + + // Create connection + conn, err := grpc.NewClient( + serverAddress, + grpc.WithUserAgent(userAgent), + grpc.WithTransportCredentials(creds), + grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(maxMessageSizeB)), + ) + if err != nil { + return nil, fmt.Errorf("error creating new client: %w", err) + } + return conn, nil +} diff --git a/internal/env_utils/env.go b/internal/env_utils/env.go new file mode 100644 index 0000000..0b727bb --- /dev/null +++ b/internal/env_utils/env.go @@ -0,0 +1,23 @@ +package envutils + +import ( + "fmt" + "os" +) + +// getValFromEnv retrieves a value from environment variables by its key. +// It returns the value if found, or an error if the environment variable is not set. +// +// Parameters: +// - key: The name of the environment variable to retrieve +// +// Returns: +// - string: The value of the environment variable if found +// - error: An error if the environment variable is not set +func GetValFromEnv(key string) (string, error) { + url, exists := os.LookupEnv(key) + if !exists { + return "", fmt.Errorf("no webhook found in the %q env var", key) + } + return url, nil +} diff --git a/internal/env_utils/env_test.go b/internal/env_utils/env_test.go new file mode 100644 index 0000000..f46293b --- /dev/null +++ b/internal/env_utils/env_test.go @@ -0,0 +1,92 @@ +package envutils + +import ( + "os" + "strings" + "testing" +) + +func TestGetValFromEnv(t *testing.T) { + // Test table structure for different test cases + tests := []struct { + name string + key string + envValue string + shouldExist bool + wantErr bool + }{ + { + name: "existing environment variable", + key: "NEW_LAUNCHES_WEBHOOK", + envValue: "https://discord.webhook.url", + shouldExist: true, + wantErr: false, + }, + { + name: "non-existing environment variable", + key: "NEW_LAUNCHES_WEBHOOK", + shouldExist: false, + wantErr: true, + }, + { + name: "empty environment variable", + key: "NEW_LAUNCHES_WEBHOOK", + envValue: "", + shouldExist: true, + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Test setup + if tt.shouldExist { + os.Setenv(tt.key, tt.envValue) + defer os.Unsetenv(tt.key) + } else { + os.Unsetenv(tt.key) + } + + // Execute test + got, err := GetValFromEnv(tt.key) + + // Check error condition + if (err != nil) != tt.wantErr { + t.Errorf("getValFromEnv() error = %v, wantErr %v", err, tt.wantErr) + return + } + + // For error cases, check error message contains the key + if err != nil && !strings.Contains(err.Error(), tt.key) { + t.Errorf("error message should contain key %q, got %q", tt.key, err.Error()) + } + + // For success cases, verify returned value + if err == nil && got != tt.envValue { + t.Errorf("getValFromEnv() = %v, want %v", got, tt.envValue) + } + }) + } +} + +// TestGetValFromEnvWithSpecialCharacters tests the function with special characters in the environment variable +func TestGetValFromEnvWithSpecialCharacters(t *testing.T) { + specialValue := "https://webhook.url?token=abc123&special=!@#$%^" + key := "NEW_LAUNCHES_WEBHOOK" + + // Set up + os.Setenv(key, specialValue) + defer os.Unsetenv(key) + + // Execute + got, err := GetValFromEnv(key) + + // Verify + if err != nil { + t.Errorf("getValFromEnv() unexpected error = %v", err) + } + + if got != specialValue { + t.Errorf("getValFromEnv() = %v, want %v", got, specialValue) + } +} diff --git a/internal/launch_utils/format.go b/internal/launch_utils/format.go new file mode 100644 index 0000000..895d38b --- /dev/null +++ b/internal/launch_utils/format.go @@ -0,0 +1,66 @@ +package launchutils + +import ( + "fmt" + "strings" +) + +// FormattedSupply returns the supply in a human-readable string with metric suffixes (K, M, B, T) +func (l LaunchExtended) FormattedSupply() string { + if l.Session == nil { + return NotAvailble + } + return formatNumber(l.Session.TokenSupply) +} + +// formatNumber converts a float64 number into a human-readable string with metric suffixes (K, M, B, T). +// The function automatically determines the appropriate suffix and decimal places based on the number's magnitude. +// +// NOTE: +// - Trailing zeros after the decimal point are removed +// - Supports negative numbers +// - Supports suffixes up to Trillion (T) +func formatNumber(n float64) string { + suffixes := []string{"", "K", "M", "B", "T"} + order := 0 + + // Handle negative numbers + sign := "" + if n < 0 { + sign = "-" + n = -n + } + + // Special case for zero + if n == 0 { + return "0" + } + + // Find the appropriate suffix + for n >= 1000 && order < len(suffixes)-1 { + n = n / 1000 + order++ + } + + // Format the number + var result string + switch { + case n >= 100: + // Numbers >= 100 show no decimal places + result = fmt.Sprintf("%.0f", n) + case n >= 10: + // Numbers >= 10 show one decimal place + result = fmt.Sprintf("%.1f", n) + // Remove trailing zero after decimal point + if strings.HasSuffix(result, ".0") { + result = strings.TrimSuffix(result, ".0") + } + default: + // Numbers < 10 show up to two decimal places + result = fmt.Sprintf("%.2f", n) + // Remove trailing zeros after decimal point + result = strings.TrimRight(strings.TrimRight(result, "0"), ".") + } + + return sign + result + suffixes[order] +} diff --git a/internal/launch_utils/format_test.go b/internal/launch_utils/format_test.go new file mode 100644 index 0000000..5d97faa --- /dev/null +++ b/internal/launch_utils/format_test.go @@ -0,0 +1,121 @@ +package launchutils + +import ( + "testing" + + "github.com/Matthew17-21/HypurrFun/pb" + "github.com/test-go/testify/require" +) + +func TestLaunchExtended_FormattedSupply(t *testing.T) { + tests := []struct { + name string + launch LaunchExtended + expected string + }{ + { + name: "nil session", + launch: LaunchExtended{HyperliquidLaunch: &pb.HyperliquidLaunch{}}, + expected: "Not Available", + }, + { + name: "zero supply", + launch: LaunchExtended{HyperliquidLaunch: &pb.HyperliquidLaunch{ + Session: &pb.HyperliquidWalletDeploySession{ + TokenSupply: 0, + }, + }}, + expected: "0", + }, + { + name: "regular number", + launch: LaunchExtended{HyperliquidLaunch: &pb.HyperliquidLaunch{ + Session: &pb.HyperliquidWalletDeploySession{ + TokenSupply: 1234567, + }, + }}, + expected: "1.23M", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := tt.launch.FormattedSupply() + if got != tt.expected { + t.Errorf("FormattedSupply() = %v, want %v", got, tt.expected) + } + }) + } +} + +func Test_formatNumber(t *testing.T) { + tests := []struct { + name string + number float64 + expected string + }{ + // Zero and small numbers + {"zero", 0, "0"}, + {"small decimal", 0.123, "0.12"}, + {"one decimal", 1.23, "1.23"}, + {"nine point nine", 9.9, "9.9"}, + + // Numbers >= 10 (one decimal place) + {"ten", 10, "10"}, + {"twelve point three four", 12.34, "12.3"}, + {"ninety nine point nine", 99.9, "99.9"}, + + // Numbers >= 100 (no decimal places) + {"hundred", 100, "100"}, + {"hundred point five", 100.5, "100"}, + {"nine hundred ninety nine", 999, "999"}, + + // Thousands (K) + {"one thousand", 1000, "1K"}, + {"one point two thousand", 1200, "1.2K"}, + {"hundred thousand", 100000, "100K"}, + {"nine hundred ninety nine thousand", 999999, "1000K"}, + + // Millions (M) + {"one million", 1000000, "1M"}, + {"one point two million", 1200000, "1.2M"}, + {"hundred million", 100000000, "100M"}, + + // Billions (B) + {"one billion", 1000000000, "1B"}, + {"one point two billion", 1200000000, "1.2B"}, + {"hundred billion", 100000000000, "100B"}, + + // Trillions (T) + {"one trillion", 1000000000000, "1T"}, + {"one point two trillion", 1200000000000, "1.2T"}, + {"hundred trillion", 100000000000000, "100T"}, + + // Negative numbers + {"negative small", -1.23, "-1.23"}, + {"negative thousand", -1000, "-1K"}, + {"negative million", -1000000, "-1M"}, + {"negative billion", -1000000000, "-1B"}, + {"negative trillion", -1000000000000, "-1T"}, + + // Edge cases + {"1e+03", 1e+03, "1K"}, + {"1e+04", 1e+04, "10K"}, + {"1e+05", 1e+05, "100K"}, + {"1e+06", 1e+06, "1M"}, + {"1e+07", 1e+07, "10M"}, + {"1e+08", 1e+08, "100M"}, + {"1e+09", 1e+09, "1B"}, + {"just under thousand", 999.9, "1000"}, + {"just under million", 999999.9, "1000K"}, + {"just under billion", 999999999.9, "1000M"}, + {"just under trillion", 999999999999.9, "1000B"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := formatNumber(tt.number) + require.Equal(t, tt.expected, got) + }) + } +} diff --git a/internal/launch_utils/launch.go b/internal/launch_utils/launch.go new file mode 100644 index 0000000..49b7a90 --- /dev/null +++ b/internal/launch_utils/launch.go @@ -0,0 +1,72 @@ +package launchutils + +import ( + "time" + + "github.com/Matthew17-21/HypurrFun/pb" +) + +const NotAvailble = "Not Available" + +// LaunchExtended extends the protobuf HyperliquidLaunch message with additional computed fields +type LaunchExtended struct { + *pb.HyperliquidLaunch + LaunchTime time.Time // Time the token was launched +} + +// ToLaunchExtended converts a protobuf HyperliquidLaunch message to an extended launch struct +// It handles the conversion of the Unix millisecond timestamp to a time.Time object +func ToLaunchExtended(hl *pb.HyperliquidLaunch) *LaunchExtended { + if hl == nil { + return &LaunchExtended{ + HyperliquidLaunch: nil, + LaunchTime: time.Time{}, // Zero value for time.Time + } + } + + return &LaunchExtended{ + HyperliquidLaunch: hl, + LaunchTime: unixMilliToTime(hl.ListedTimestamp), + } +} + +// LaunchSlice represents a slice of HyperliquidLaunch pointers that can be sorted. +// It implements the basic methods required by sort.Interface. +type LaunchSlice []*pb.HyperliquidLaunch + +// Len returns the length of the LaunchSlice. +// This is part of sort.Interface implementation. +func (l LaunchSlice) Len() int { return len(l) } + +// Swap exchanges the elements with indexes i and j. +// This is part of sort.Interface implementation. +func (l LaunchSlice) Swap(i, j int) { l[i], l[j] = l[j], l[i] } + +// SortByLastActivity is a wrapper around LaunchSlice that implements +// sort.Interface to sort launches by their LastEventTimestamp in ascending order +// (oldest first). +type SortByLastActivity struct{ LaunchSlice } + +// Less reports whether the launch at index i should sort before the launch at index j. +// It compares LastEventTimestamp values in ascending order. +// This is part of sort.Interface implementation. +func (s SortByLastActivity) Less(i, j int) bool { + return s.LaunchSlice[i].LastEventTimestamp < s.LaunchSlice[j].LastEventTimestamp +} + +// SortByListedTimestamp is a wrapper around LaunchSlice that implements +// sort.Interface to sort launches by their ListedTimestamp in ascending order +// (oldest first). +type SortByListedTimestamp struct{ LaunchSlice } + +// Less reports whether the launch at index i should sort before the launch at index j. +// It compares ListedTimestamp values in ascending order. +// This is part of sort.Interface implementation. +func (s SortByListedTimestamp) Less(i, j int) bool { + return s.LaunchSlice[i].ListedTimestamp < s.LaunchSlice[j].ListedTimestamp +} + +// UnixMilliToTime converts Unix milliseconds timestamp to time.Time +func unixMilliToTime(msTimestamp int64) time.Time { + return time.UnixMilli(msTimestamp) //.UTC() +} diff --git a/internal/launch_utils/launch_test.go b/internal/launch_utils/launch_test.go new file mode 100644 index 0000000..5750b7e --- /dev/null +++ b/internal/launch_utils/launch_test.go @@ -0,0 +1,88 @@ +package launchutils + +import ( + "testing" + "time" + + "github.com/Matthew17-21/HypurrFun/pb" + "github.com/test-go/testify/require" +) + +func TestToLaunchExtended(t *testing.T) { + tests := []struct { + name string + input *pb.HyperliquidLaunch + expectedTime time.Time + }{ + { + name: "converts zero timestamp", + input: &pb.HyperliquidLaunch{ + ListedTimestamp: 0, + }, + expectedTime: time.Unix(0, 0).Local(), + }, + { + name: "converts set timestamp", + input: &pb.HyperliquidLaunch{ + ListedTimestamp: 1641024000000, // Saturday, January 1, 2022 8:00:00 UTC + }, + expectedTime: time.Date(2022, time.January, 1, 8, 0, 0, 0, time.UTC).UTC(), + }, + } + + t.Run("handles non nil input", func(t *testing.T) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Run tests + got := ToLaunchExtended(tt.input) + + // Assert + require.NotNil(t, got) + require.Equal(t, tt.input, got.HyperliquidLaunch, "original Launch struct should be preserved") + require.Equal(t, tt.expectedTime.UTC(), got.LaunchTime.UTC(), "LaunchTime should be correctly converted") + }) + } + }) + + t.Run("handles nil input", func(t *testing.T) { + // Run test + got := ToLaunchExtended(nil) + + // Assert + expectedTime := time.Time{} + require.NotNil(t, got) + require.Nil(t, got.HyperliquidLaunch) + require.Equal(t, expectedTime, got.LaunchTime) + }) +} + +func TestUnixMillisecondsToTime(t *testing.T) { + tests := []struct { + name string + input int64 + expected time.Time + }{ + { + name: "Epoch time", + input: 0, + expected: time.Unix(0, 0).UTC(), + }, + { + name: "Epoch time UnixMilli", + input: time.Time{}.UnixMilli(), + expected: time.Time{}.UTC(), + }, + { + name: "Non-zero milliseconds", + input: 1672531199000, // Saturday, December 31, 2022 23:59:59 + expected: time.Date(2022, time.December, 31, 23, 59, 59, 0, time.UTC).UTC(), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := unixMilliToTime(tt.input) + require.Equal(t, tt.expected.UTC(), result.UTC()) + }) + } +} diff --git a/internal/launch_utils/sort.go b/internal/launch_utils/sort.go new file mode 100644 index 0000000..f7b488b --- /dev/null +++ b/internal/launch_utils/sort.go @@ -0,0 +1,67 @@ +package launchutils + +import ( + "sort" + + "github.com/Matthew17-21/HypurrFun/pb" +) + +// SortByLastActivityAsc sorts the given launches by LastEventTimestamp in ascending order +// and returns the sorted slice. The original slice is modified. +func SortByLastActivityAsc(launches []*pb.HyperliquidLaunch) []*pb.HyperliquidLaunch { + sort.Sort(SortByLastActivity{LaunchSlice(launches)}) + return launches +} + +// SortByLastActivityDesc sorts the given launches by LastEventTimestamp in descending order +// and returns the sorted slice. The original slice is modified. +func SortByLastActivityDesc(launches []*pb.HyperliquidLaunch) []*pb.HyperliquidLaunch { + sort.Sort(sort.Reverse(SortByLastActivity{LaunchSlice(launches)})) + return launches +} + +// SortByListedTimestampAsc sorts the given launches by ListedTimestamp in ascending order +// and returns the sorted slice. The original slice is modified. +func SortByListedTimestampAsc(launches []*pb.HyperliquidLaunch) []*pb.HyperliquidLaunch { + sort.Sort(SortByListedTimestamp{LaunchSlice(launches)}) + return launches +} + +// SortByListedTimestampDesc sorts the given launches by ListedTimestamp in descending order +// and returns the sorted slice. The original slice is modified. +func SortByListedTimestampDesc(launches []*pb.HyperliquidLaunch) []*pb.HyperliquidLaunch { + sort.Sort(sort.Reverse(SortByListedTimestamp{LaunchSlice(launches)})) + return launches +} + +// GetSortedByLastActivityAsc returns a new slice containing the launches sorted +// by LastEventTimestamp in ascending order. The original slice is not modified. +func GetSortedByLastActivityAsc(launches []*pb.HyperliquidLaunch) []*pb.HyperliquidLaunch { + sorted := make([]*pb.HyperliquidLaunch, len(launches)) + copy(sorted, launches) + return SortByLastActivityAsc(sorted) +} + +// GetSortedByLastActivityDesc returns a new slice containing the launches sorted +// by LastEventTimestamp in descending order. The original slice is not modified. +func GetSortedByLastActivityDesc(launches []*pb.HyperliquidLaunch) []*pb.HyperliquidLaunch { + sorted := make([]*pb.HyperliquidLaunch, len(launches)) + copy(sorted, launches) + return SortByLastActivityDesc(sorted) +} + +// GetSortedByListedTimestampAsc returns a new slice containing the launches sorted +// by ListedTimestamp in ascending order. The original slice is not modified. +func GetSortedByListedTimestampAsc(launches []*pb.HyperliquidLaunch) []*pb.HyperliquidLaunch { + sorted := make([]*pb.HyperliquidLaunch, len(launches)) + copy(sorted, launches) + return SortByListedTimestampAsc(sorted) +} + +// GetSortedByListedTimestampDesc returns a new slice containing the launches sorted +// by ListedTimestamp in descending order. The original slice is not modified. +func GetSortedByListedTimestampDesc(launches []*pb.HyperliquidLaunch) []*pb.HyperliquidLaunch { + sorted := make([]*pb.HyperliquidLaunch, len(launches)) + copy(sorted, launches) + return SortByListedTimestampDesc(sorted) +} diff --git a/internal/launch_utils/sort_test.go b/internal/launch_utils/sort_test.go new file mode 100644 index 0000000..50b1010 --- /dev/null +++ b/internal/launch_utils/sort_test.go @@ -0,0 +1,177 @@ +package launchutils + +import ( + "testing" + + "github.com/Matthew17-21/HypurrFun/pb" + "github.com/test-go/testify/require" +) + +func TestSortingFunctions(t *testing.T) { + // Create test data + launches := []*pb.HyperliquidLaunch{ + { + LastEventTimestamp: 3, + ListedTimestamp: 1, + }, + { + LastEventTimestamp: 1, + ListedTimestamp: 3, + }, + { + LastEventTimestamp: 2, + ListedTimestamp: 2, + }, + } + + t.Run("SortByLastActivity", func(t *testing.T) { + t.Run("Ascending", func(t *testing.T) { + // Make a copy for testing + testLaunches := make([]*pb.HyperliquidLaunch, len(launches)) + copy(testLaunches, launches) + + sorted := SortByLastActivityAsc(testLaunches) + + // Verify sorting + require.Equal(t, int64(1), sorted[0].LastEventTimestamp) + require.Equal(t, int64(2), sorted[1].LastEventTimestamp) + require.Equal(t, int64(3), sorted[2].LastEventTimestamp) + + // Verify original slice was modified + require.Equal(t, sorted, testLaunches) + }) + + t.Run("Descending", func(t *testing.T) { + testLaunches := make([]*pb.HyperliquidLaunch, len(launches)) + copy(testLaunches, launches) + + sorted := SortByLastActivityDesc(testLaunches) + + require.Equal(t, int64(3), sorted[0].LastEventTimestamp) + require.Equal(t, int64(2), sorted[1].LastEventTimestamp) + require.Equal(t, int64(1), sorted[2].LastEventTimestamp) + + require.Equal(t, sorted, testLaunches) + }) + }) + + t.Run("SortByListedTimestamp", func(t *testing.T) { + t.Run("Ascending", func(t *testing.T) { + testLaunches := make([]*pb.HyperliquidLaunch, len(launches)) + copy(testLaunches, launches) + + sorted := SortByListedTimestampAsc(testLaunches) + + require.Equal(t, int64(1), sorted[0].ListedTimestamp) + require.Equal(t, int64(2), sorted[1].ListedTimestamp) + require.Equal(t, int64(3), sorted[2].ListedTimestamp) + + require.Equal(t, sorted, testLaunches) + }) + + t.Run("Descending", func(t *testing.T) { + testLaunches := make([]*pb.HyperliquidLaunch, len(launches)) + copy(testLaunches, launches) + + sorted := SortByListedTimestampDesc(testLaunches) + + require.Equal(t, int64(3), sorted[0].ListedTimestamp) + require.Equal(t, int64(2), sorted[1].ListedTimestamp) + require.Equal(t, int64(1), sorted[2].ListedTimestamp) + + require.Equal(t, sorted, testLaunches) + }) + }) + + t.Run("GetSortedByLastActivity", func(t *testing.T) { + t.Run("Ascending", func(t *testing.T) { + original := make([]*pb.HyperliquidLaunch, len(launches)) + copy(original, launches) + + sorted := GetSortedByLastActivityAsc(original) + + // Verify sorting + require.Equal(t, int64(1), sorted[0].LastEventTimestamp) + require.Equal(t, int64(2), sorted[1].LastEventTimestamp) + require.Equal(t, int64(3), sorted[2].LastEventTimestamp) + + // Verify original slice was not modified + require.NotEqual(t, sorted, original) + require.Equal(t, launches[0].LastEventTimestamp, original[0].LastEventTimestamp) + }) + + t.Run("Descending", func(t *testing.T) { + original := make([]*pb.HyperliquidLaunch, len(launches)) + copy(original, launches) + + sorted := GetSortedByLastActivityDesc(original) + + require.Equal(t, int64(3), sorted[0].LastEventTimestamp) + require.Equal(t, int64(2), sorted[1].LastEventTimestamp) + require.Equal(t, int64(1), sorted[2].LastEventTimestamp) + + require.NotEqual(t, sorted, original) + require.Equal(t, launches[0].LastEventTimestamp, original[0].LastEventTimestamp) + }) + }) + + t.Run("GetSortedByListedTimestamp", func(t *testing.T) { + t.Run("Ascending", func(t *testing.T) { + original := make([]*pb.HyperliquidLaunch, len(launches)) + copy(original, launches) + + sorted := GetSortedByListedTimestampAsc(original) + + require.Equal(t, int64(1), sorted[0].ListedTimestamp) + require.Equal(t, int64(2), sorted[1].ListedTimestamp) + require.Equal(t, int64(3), sorted[2].ListedTimestamp) + + require.NotEqual(t, sorted, original) + require.Equal(t, launches[0].ListedTimestamp, original[0].ListedTimestamp) + }) + + t.Run("Descending", func(t *testing.T) { + original := make([]*pb.HyperliquidLaunch, len(launches)) + copy(original, launches) + + sorted := GetSortedByListedTimestampDesc(original) + + require.Equal(t, int64(3), sorted[0].ListedTimestamp) + require.Equal(t, int64(2), sorted[1].ListedTimestamp) + require.Equal(t, int64(1), sorted[2].ListedTimestamp) + + require.NotEqual(t, sorted, original) + require.Equal(t, launches[0].ListedTimestamp, original[0].ListedTimestamp) + }) + }) + + t.Run("Empty slice", func(t *testing.T) { + emptyLaunches := []*pb.HyperliquidLaunch{} + + // Test all functions with empty slice + require.Empty(t, SortByLastActivityAsc(emptyLaunches)) + require.Empty(t, SortByLastActivityDesc(emptyLaunches)) + require.Empty(t, SortByListedTimestampAsc(emptyLaunches)) + require.Empty(t, SortByListedTimestampDesc(emptyLaunches)) + require.Empty(t, GetSortedByLastActivityAsc(emptyLaunches)) + require.Empty(t, GetSortedByLastActivityDesc(emptyLaunches)) + require.Empty(t, GetSortedByListedTimestampAsc(emptyLaunches)) + require.Empty(t, GetSortedByListedTimestampDesc(emptyLaunches)) + }) + + t.Run("Single element", func(t *testing.T) { + singleLaunch := []*pb.HyperliquidLaunch{{ + LastEventTimestamp: 1, + ListedTimestamp: 1, + }} + + // Test all functions with single element + sorted := SortByLastActivityAsc(singleLaunch) + require.Len(t, sorted, 1) + require.Equal(t, int64(1), sorted[0].LastEventTimestamp) + + sorted = GetSortedByListedTimestampDesc(singleLaunch) + require.Len(t, sorted, 1) + require.Equal(t, int64(1), sorted[0].ListedTimestamp) + }) +} diff --git a/internal/webhook/config.go b/internal/webhook/config.go new file mode 100644 index 0000000..d6b3dbe --- /dev/null +++ b/internal/webhook/config.go @@ -0,0 +1,24 @@ +package webhook + +// WebhookConfig holds the configuration for Discord webhooks +type WebhookConfig struct { + Color int + Title string + Username string + AvatarURL string + Footer string + BaseAppURL string + MediaURL string +} + +func newLaunchConfig() WebhookConfig { + return WebhookConfig{ + Color: webhookColor, + Title: webhookTitleNewLaunch, + Username: webhookUsername, + AvatarURL: webhookAvatarURL, + Footer: webhookFooter, + BaseAppURL: baseAppURL, + MediaURL: baseMediaURL, + } +} diff --git a/internal/webhook/new_launch.go b/internal/webhook/new_launch.go new file mode 100644 index 0000000..ee76a18 --- /dev/null +++ b/internal/webhook/new_launch.go @@ -0,0 +1,81 @@ +package webhook + +import ( + "errors" + "fmt" + "strconv" + "time" + + launchutils "github.com/Matthew17-21/HypurrFun/internal/launch_utils" + "github.com/Matthew17-21/HypurrFun/pb" + discordwebhook "github.com/Monumental-Shopping/go-discord-webhook" +) + +type newLaunchHelper struct{} + +// formatTimestamp formats Unix timestamp for Discord display +func (newLaunchHelper) formatTimestamp(listed time.Time) string { + ts := listed.Unix() + return fmt.Sprintf(" ()", ts, ts) +} + +// formatTokenName formats the token name display +func (newLaunchHelper) formatTokenName(fullName, tokenName string) string { + if tokenName == notAvailable { + return fullName + } + return fmt.Sprintf("%s ($%s)", fullName, tokenName) +} + +// setupWebhookBase configures the basic webhook properties +func (newLaunchHelper) setupWebhookBase(w discordwebhook.Webhook, launch *launchutils.LaunchExtended, config WebhookConfig) { + w.SetColor(config.Color) + w.SetTimestamp(time.Unix(0, launch.ListedTimestamp*int64(time.Millisecond))) + w.SetThumbnail(config.MediaURL + launch.MediaFileId) + w.SetTitle(config.Title) + w.SetUrl(config.BaseAppURL + strconv.Itoa(int(launch.Id))) + w.SetUsername(config.Username) + w.SetAvatarUrl(config.AvatarURL) + w.CreateFooter(config.Footer, "") +} + +// addSessionFields adds session-specific fields to the webhook +func (n newLaunchHelper) addSessionFields(w discordwebhook.Webhook, l *launchutils.LaunchExtended, session *pb.HyperliquidWalletDeploySession) { + w.CreateField("Name", n.formatTokenName(session.FullName, session.TokenName), true) + w.CreateField("Supply", l.FormattedSupply(), true) + w.CreateField("Market Cap", strconv.FormatInt(int64(session.StartMarketCap), 10), true) +} + +// addLaunchFields adds launch-specific fields to the webhook +func (n newLaunchHelper) addLaunchFields(w discordwebhook.Webhook, launch *launchutils.LaunchExtended) { + w.CreateField("Description", launch.Description, false) + w.CreateField("Created At", n.formatTimestamp(launch.LaunchTime), true) + if launch.TelegramUser != nil { + w.CreateField("Created by", launch.TelegramUser.Username, true) + } +} + +// SendWebhook sends a Discord webhook for a HyperliquidLaunch +func (n newLaunchHelper) SendWebhook(launch *launchutils.LaunchExtended, url string) error { + // Make sure launch is not nil + if launch == nil { + return errors.New("hyperliquidLaunch is nil") + } + + // Create a new webhook + webhook := discordwebhook.NewWebhook() + config := newLaunchConfig() + + // Setup webhook with base configuration + n.setupWebhookBase(webhook, launch, config) + + // Add session information + sessionInfo := getSessionInfo(launch) + n.addSessionFields(webhook, launch, sessionInfo) + + // Add launch-specific information + n.addLaunchFields(webhook, launch) + + // Send + return send(webhook, url) +} diff --git a/internal/webhook/new_launch_test.go b/internal/webhook/new_launch_test.go new file mode 100644 index 0000000..90d480a --- /dev/null +++ b/internal/webhook/new_launch_test.go @@ -0,0 +1,76 @@ +package webhook + +import ( + "fmt" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +// Test timestamp formatting +func TestFormatTimestamp(t *testing.T) { + helper := newLaunchHelper{} + + t.Run("formats current time correctly", func(t *testing.T) { + now := time.Now() + formatted := helper.formatTimestamp(now) + expected := fmt.Sprintf(" ()", now.Unix(), now.Unix()) + assert.Equal(t, expected, formatted, "Current timestamp should be formatted correctly") + }) + + t.Run("formats specific date correctly", func(t *testing.T) { + // Use a specific date for consistent testing + specificDate := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC) + formatted := helper.formatTimestamp(specificDate) + expected := fmt.Sprintf(" ()", specificDate.Unix(), specificDate.Unix()) + assert.Equal(t, expected, formatted, "Specific date should be formatted correctly") + }) + + t.Run("formats zero time correctly", func(t *testing.T) { + zeroTime := time.Time{} + formatted := helper.formatTimestamp(zeroTime) + expected := fmt.Sprintf(" ()", zeroTime.Unix(), zeroTime.Unix()) + assert.Equal(t, expected, formatted, "Zero time should be formatted without error") + }) +} + +// Test token name formatting +func TestFormatTokenName(t *testing.T) { + helper := newLaunchHelper{} + + t.Run("formats normal token name and full name", func(t *testing.T) { + fullName := "Test Token" + tokenName := "TEST" + formatted := helper.formatTokenName(fullName, tokenName) + expected := "Test Token ($TEST)" + assert.Equal(t, expected, formatted, "Token name and full name should be formatted correctly") + }) + + t.Run("handles not available token name", func(t *testing.T) { + fullName := "Test Token" + formatted := helper.formatTokenName(fullName, notAvailable) + assert.Equal(t, fullName, formatted, "Should return only full name when token is not available") + }) + + t.Run("handles empty strings", func(t *testing.T) { + formatted := helper.formatTokenName("", "") + assert.Equal(t, " ($)", formatted, "Should handle empty strings without error") + }) + + t.Run("handles special characters", func(t *testing.T) { + fullName := "Test & Token!" + tokenName := "T&T" + formatted := helper.formatTokenName(fullName, tokenName) + expected := "Test & Token! ($T&T)" + assert.Equal(t, expected, formatted, "Should handle special characters correctly") + }) + + t.Run("handles unicode characters", func(t *testing.T) { + fullName := "Token 币" + tokenName := "币" + formatted := helper.formatTokenName(fullName, tokenName) + expected := "Token 币 ($币)" + assert.Equal(t, expected, formatted, "Should handle unicode characters correctly") + }) +} diff --git a/internal/webhook/session.go b/internal/webhook/session.go new file mode 100644 index 0000000..88ce0e7 --- /dev/null +++ b/internal/webhook/session.go @@ -0,0 +1,26 @@ +package webhook + +import ( + launchutils "github.com/Matthew17-21/HypurrFun/internal/launch_utils" + "github.com/Matthew17-21/HypurrFun/pb" +) + +const notAvailable string = "Not Available" + +// getDefaultSession returns a default session when none is provided +func getDefaultSession() *pb.HyperliquidWalletDeploySession { + return &pb.HyperliquidWalletDeploySession{ + FullName: notAvailable, + TokenName: notAvailable, + TokenSupply: 0, + StartMarketCap: 0, + } +} + +// getSessionInfo safely extracts session information +func getSessionInfo(launch *launchutils.LaunchExtended) *pb.HyperliquidWalletDeploySession { + if launch.Session == nil { + return getDefaultSession() + } + return launch.Session +} diff --git a/internal/webhook/session_test.go b/internal/webhook/session_test.go new file mode 100644 index 0000000..b5e41ad --- /dev/null +++ b/internal/webhook/session_test.go @@ -0,0 +1,104 @@ +package webhook + +import ( + "testing" + + launchutils "github.com/Matthew17-21/HypurrFun/internal/launch_utils" + "github.com/Matthew17-21/HypurrFun/pb" + "github.com/stretchr/testify/require" +) + +func TestGetDefaultSession(t *testing.T) { + // Test the default session creation + session := getDefaultSession() + const expectedTokenSupply float64 = 0 + const expectedMarketCap int32 = 0 + const exptectedTokenName string = notAvailable + const exptectedFullName string = notAvailable + + // Verify all default values are set correctly + require.Equal(t, exptectedFullName, session.FullName, "Default FullName should be 'Not available'") + require.Equal(t, exptectedTokenName, session.TokenName, "Default TokenName should be '?'") + require.Equal(t, expectedTokenSupply, session.TokenSupply, "Default TokenSupply should be 0") + require.Equal(t, expectedMarketCap, session.StartMarketCap, "Default StartMarketCap should be 0") +} + +func TestGetSessionInfo(t *testing.T) { + t.Run("nil session returns default", func(t *testing.T) { + // Create a launch with nil session + launch := &launchutils.LaunchExtended{ + HyperliquidLaunch: &pb.HyperliquidLaunch{ + Session: nil, + }, + } + const expectedTokenSupply float64 = 0 + const expectedMarketCap int32 = 0 + const exptectedTokenName string = notAvailable + const exptectedFullName string = notAvailable + + session := getSessionInfo(launch) + + // Verify default values are returned + require.Equal(t, exptectedFullName, session.FullName) + require.Equal(t, exptectedTokenName, session.TokenName) + require.Equal(t, expectedTokenSupply, session.TokenSupply) + require.Equal(t, expectedMarketCap, session.StartMarketCap) + }) + + t.Run("valid session returns correct values", func(t *testing.T) { + // Create a launch with custom session values + customSession := &pb.HyperliquidWalletDeploySession{ + FullName: "Test Token", + TokenName: "TST", + TokenSupply: 1000000, + StartMarketCap: 5000000, + } + launch := &launchutils.LaunchExtended{ + HyperliquidLaunch: &pb.HyperliquidLaunch{ + Session: customSession, + }, + } + const expectedTokenSupply float64 = 1000000 + const expectedMarketCap int32 = 5000000 + const exptectedTokenName string = "TST" + const exptectedFullName string = "Test Token" + + session := getSessionInfo(launch) + + // Verify custom values are returned + require.Equal(t, exptectedFullName, session.FullName) + require.Equal(t, exptectedTokenName, session.TokenName) + require.Equal(t, expectedTokenSupply, session.TokenSupply) + require.Equal(t, expectedMarketCap, session.StartMarketCap) + }) +} + +func TestGetSessionInfoEdgeCases(t *testing.T) { + t.Run("empty session values", func(t *testing.T) { + // Test with empty string values but non-nil session + emptySession := &pb.HyperliquidWalletDeploySession{ + FullName: "", + TokenName: "", + TokenSupply: 0, + StartMarketCap: 0, + } + + launch := &launchutils.LaunchExtended{ + HyperliquidLaunch: &pb.HyperliquidLaunch{ + Session: emptySession, + }, + } + const expectedTokenSupply float64 = 0 + const expectedMarketCap int32 = 0 + const exptectedTokenName string = "" + const exptectedFullName string = "" + + session := getSessionInfo(launch) + + // Verify empty values are preserved (not converted to defaults) + require.Equal(t, exptectedFullName, session.FullName) + require.Equal(t, exptectedTokenName, session.TokenName) + require.Equal(t, expectedTokenSupply, session.TokenSupply) + require.Equal(t, expectedMarketCap, session.StartMarketCap) + }) +} diff --git a/internal/webhook/webhook.go b/internal/webhook/webhook.go new file mode 100644 index 0000000..5a7b46a --- /dev/null +++ b/internal/webhook/webhook.go @@ -0,0 +1,51 @@ +package webhook + +import ( + "errors" + "fmt" + + envutils "github.com/Matthew17-21/HypurrFun/internal/env_utils" + launchutils "github.com/Matthew17-21/HypurrFun/internal/launch_utils" + discordwebhook "github.com/Monumental-Shopping/go-discord-webhook" +) + +// Webhook constants +const ( + webhookColor = 271647 // Hperliquid green + webhookTitleNewLaunch = "New hypurr.fun launch!" + webhookUsername = "Hypurr.fun Monitor" + webhookAvatarURL = "https://pbs.twimg.com/profile_images/1646991609416806408/vKLEZxhh_400x400.png" + baseMediaURL = "https://media.hypurr.fun/" + baseAppURL = "https://app.hypurr.fun/launch/" + webhookFooter = "Created by: `mattthew` on discord" +) + +// SendNewLaunch sends a Discord webhook for a new Hypurr.fun token +func SendNewLaunch(launch *launchutils.LaunchExtended) error { + // Ensure launch is not nil + if launch == nil { + return errors.New("launch is nil") + } + + // Get webhook url + url, err := envutils.GetValFromEnv("NEW_LAUNCHES_WEBHOOK") + if err != nil { + return fmt.Errorf("error getting valu from env: %w", err) + } + + // Send webhook + n := new(newLaunchHelper) + n.SendWebhook(launch, url) + return nil +} + +// send is a wrapper function to send discord webhooks +func send(w discordwebhook.Webhook, url string) error { + resp, err := w.Send(url) + if err != nil { + return fmt.Errorf("error sending webhook: %w", err) + } + defer resp.Body.Close() + + return nil +} diff --git a/pb/hypurr.pb.go b/pb/hypurr.pb.go new file mode 100644 index 0000000..78e7b3a --- /dev/null +++ b/pb/hypurr.pb.go @@ -0,0 +1,7169 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.35.2 +// protoc v5.29.1 +// source: hypurr.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type HyperliquidLaunchPoolType int32 + +const ( + HyperliquidLaunchPoolType_Quadratic HyperliquidLaunchPoolType = 0 + HyperliquidLaunchPoolType_QuadraticV2 HyperliquidLaunchPoolType = 1 + HyperliquidLaunchPoolType_Linear HyperliquidLaunchPoolType = 2 + HyperliquidLaunchPoolType_Fixed HyperliquidLaunchPoolType = 3 +) + +// Enum value maps for HyperliquidLaunchPoolType. +var ( + HyperliquidLaunchPoolType_name = map[int32]string{ + 0: "Quadratic", + 1: "QuadraticV2", + 2: "Linear", + 3: "Fixed", + } + HyperliquidLaunchPoolType_value = map[string]int32{ + "Quadratic": 0, + "QuadraticV2": 1, + "Linear": 2, + "Fixed": 3, + } +) + +func (x HyperliquidLaunchPoolType) Enum() *HyperliquidLaunchPoolType { + p := new(HyperliquidLaunchPoolType) + *p = x + return p +} + +func (x HyperliquidLaunchPoolType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (HyperliquidLaunchPoolType) Descriptor() protoreflect.EnumDescriptor { + return file_hypurr_proto_enumTypes[0].Descriptor() +} + +func (HyperliquidLaunchPoolType) Type() protoreflect.EnumType { + return &file_hypurr_proto_enumTypes[0] +} + +func (x HyperliquidLaunchPoolType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use HyperliquidLaunchPoolType.Descriptor instead. +func (HyperliquidLaunchPoolType) EnumDescriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{0} +} + +type HyperliquidLaunchTradeDirection int32 + +const ( + HyperliquidLaunchTradeDirection_BUY HyperliquidLaunchTradeDirection = 0 + HyperliquidLaunchTradeDirection_SELL HyperliquidLaunchTradeDirection = 1 +) + +// Enum value maps for HyperliquidLaunchTradeDirection. +var ( + HyperliquidLaunchTradeDirection_name = map[int32]string{ + 0: "BUY", + 1: "SELL", + } + HyperliquidLaunchTradeDirection_value = map[string]int32{ + "BUY": 0, + "SELL": 1, + } +) + +func (x HyperliquidLaunchTradeDirection) Enum() *HyperliquidLaunchTradeDirection { + p := new(HyperliquidLaunchTradeDirection) + *p = x + return p +} + +func (x HyperliquidLaunchTradeDirection) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (HyperliquidLaunchTradeDirection) Descriptor() protoreflect.EnumDescriptor { + return file_hypurr_proto_enumTypes[1].Descriptor() +} + +func (HyperliquidLaunchTradeDirection) Type() protoreflect.EnumType { + return &file_hypurr_proto_enumTypes[1] +} + +func (x HyperliquidLaunchTradeDirection) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use HyperliquidLaunchTradeDirection.Descriptor instead. +func (HyperliquidLaunchTradeDirection) EnumDescriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{1} +} + +type HyperliquidToken struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Index int64 `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"` + SzDecimals int64 `protobuf:"varint,4,opt,name=sz_decimals,json=szDecimals,proto3" json:"sz_decimals,omitempty"` + WeiDecimals int64 `protobuf:"varint,5,opt,name=wei_decimals,json=weiDecimals,proto3" json:"wei_decimals,omitempty"` + TokenId string `protobuf:"bytes,6,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + CirculatingSupply float64 `protobuf:"fixed64,7,opt,name=circulating_supply,json=circulatingSupply,proto3" json:"circulating_supply,omitempty"` + DeployInfo *HyperliquidTokenDeployInfo `protobuf:"bytes,8,opt,name=deploy_info,json=deployInfo,proto3" json:"deploy_info,omitempty"` + Geneses []*HyperliquidTokenGenesis `protobuf:"bytes,9,rep,name=geneses,proto3" json:"geneses,omitempty"` + HlqBalance float64 `protobuf:"fixed64,10,opt,name=hlq_balance,json=hlqBalance,proto3" json:"hlq_balance,omitempty"` + FullName string `protobuf:"bytes,11,opt,name=full_name,json=fullName,proto3" json:"full_name,omitempty"` + Statistics *HyperliquidTokenStatistics `protobuf:"bytes,12,opt,name=statistics,proto3" json:"statistics,omitempty"` +} + +func (x *HyperliquidToken) Reset() { + *x = HyperliquidToken{} + mi := &file_hypurr_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidToken) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidToken) ProtoMessage() {} + +func (x *HyperliquidToken) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidToken.ProtoReflect.Descriptor instead. +func (*HyperliquidToken) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{0} +} + +func (x *HyperliquidToken) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HyperliquidToken) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *HyperliquidToken) GetIndex() int64 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *HyperliquidToken) GetSzDecimals() int64 { + if x != nil { + return x.SzDecimals + } + return 0 +} + +func (x *HyperliquidToken) GetWeiDecimals() int64 { + if x != nil { + return x.WeiDecimals + } + return 0 +} + +func (x *HyperliquidToken) GetTokenId() string { + if x != nil { + return x.TokenId + } + return "" +} + +func (x *HyperliquidToken) GetCirculatingSupply() float64 { + if x != nil { + return x.CirculatingSupply + } + return 0 +} + +func (x *HyperliquidToken) GetDeployInfo() *HyperliquidTokenDeployInfo { + if x != nil { + return x.DeployInfo + } + return nil +} + +func (x *HyperliquidToken) GetGeneses() []*HyperliquidTokenGenesis { + if x != nil { + return x.Geneses + } + return nil +} + +func (x *HyperliquidToken) GetHlqBalance() float64 { + if x != nil { + return x.HlqBalance + } + return 0 +} + +func (x *HyperliquidToken) GetFullName() string { + if x != nil { + return x.FullName + } + return "" +} + +func (x *HyperliquidToken) GetStatistics() *HyperliquidTokenStatistics { + if x != nil { + return x.Statistics + } + return nil +} + +type HyperliquidTokenHolder struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Balance float64 `protobuf:"fixed64,1,opt,name=balance,proto3" json:"balance,omitempty"` + Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` + Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"` +} + +func (x *HyperliquidTokenHolder) Reset() { + *x = HyperliquidTokenHolder{} + mi := &file_hypurr_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenHolder) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenHolder) ProtoMessage() {} + +func (x *HyperliquidTokenHolder) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenHolder.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenHolder) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{1} +} + +func (x *HyperliquidTokenHolder) GetBalance() float64 { + if x != nil { + return x.Balance + } + return 0 +} + +func (x *HyperliquidTokenHolder) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *HyperliquidTokenHolder) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +type HyperliquidTokenHoldersRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TokenId int64 `protobuf:"varint,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` +} + +func (x *HyperliquidTokenHoldersRequest) Reset() { + *x = HyperliquidTokenHoldersRequest{} + mi := &file_hypurr_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenHoldersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenHoldersRequest) ProtoMessage() {} + +func (x *HyperliquidTokenHoldersRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenHoldersRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenHoldersRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{2} +} + +func (x *HyperliquidTokenHoldersRequest) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +type HyperliquidTokenHoldersResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Holders []*HyperliquidTokenHolder `protobuf:"bytes,1,rep,name=holders,proto3" json:"holders,omitempty"` +} + +func (x *HyperliquidTokenHoldersResponse) Reset() { + *x = HyperliquidTokenHoldersResponse{} + mi := &file_hypurr_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenHoldersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenHoldersResponse) ProtoMessage() {} + +func (x *HyperliquidTokenHoldersResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenHoldersResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenHoldersResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{3} +} + +func (x *HyperliquidTokenHoldersResponse) GetHolders() []*HyperliquidTokenHolder { + if x != nil { + return x.Holders + } + return nil +} + +type HyperliquidTokenStatistics struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TokenId int64 `protobuf:"varint,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + HolderCount int64 `protobuf:"varint,2,opt,name=holder_count,json=holderCount,proto3" json:"holder_count,omitempty"` + ConcentrationCoefficient float64 `protobuf:"fixed64,3,opt,name=concentration_coefficient,json=concentrationCoefficient,proto3" json:"concentration_coefficient,omitempty"` +} + +func (x *HyperliquidTokenStatistics) Reset() { + *x = HyperliquidTokenStatistics{} + mi := &file_hypurr_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenStatistics) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenStatistics) ProtoMessage() {} + +func (x *HyperliquidTokenStatistics) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenStatistics.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenStatistics) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{4} +} + +func (x *HyperliquidTokenStatistics) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +func (x *HyperliquidTokenStatistics) GetHolderCount() int64 { + if x != nil { + return x.HolderCount + } + return 0 +} + +func (x *HyperliquidTokenStatistics) GetConcentrationCoefficient() float64 { + if x != nil { + return x.ConcentrationCoefficient + } + return 0 +} + +type HyperliquidTokenDeployInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TokenId int64 `protobuf:"varint,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + Height int64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` + Deployer string `protobuf:"bytes,3,opt,name=deployer,proto3" json:"deployer,omitempty"` + RegisterTx string `protobuf:"bytes,4,opt,name=register_tx,json=registerTx,proto3" json:"register_tx,omitempty"` + RegisterSpotTx string `protobuf:"bytes,5,opt,name=register_spot_tx,json=registerSpotTx,proto3" json:"register_spot_tx,omitempty"` + GenesisTx string `protobuf:"bytes,6,opt,name=genesis_tx,json=genesisTx,proto3" json:"genesis_tx,omitempty"` + HyperliquidityTx string `protobuf:"bytes,7,opt,name=hyperliquidity_tx,json=hyperliquidityTx,proto3" json:"hyperliquidity_tx,omitempty"` + Hip2Price float64 `protobuf:"fixed64,8,opt,name=hip2_price,json=hip2Price,proto3" json:"hip2_price,omitempty"` + Hip2OrderCount int32 `protobuf:"varint,9,opt,name=hip2_order_count,json=hip2OrderCount,proto3" json:"hip2_order_count,omitempty"` + Hip2OrderSize float64 `protobuf:"fixed64,10,opt,name=hip2_order_size,json=hip2OrderSize,proto3" json:"hip2_order_size,omitempty"` +} + +func (x *HyperliquidTokenDeployInfo) Reset() { + *x = HyperliquidTokenDeployInfo{} + mi := &file_hypurr_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenDeployInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenDeployInfo) ProtoMessage() {} + +func (x *HyperliquidTokenDeployInfo) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenDeployInfo.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenDeployInfo) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{5} +} + +func (x *HyperliquidTokenDeployInfo) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +func (x *HyperliquidTokenDeployInfo) GetHeight() int64 { + if x != nil { + return x.Height + } + return 0 +} + +func (x *HyperliquidTokenDeployInfo) GetDeployer() string { + if x != nil { + return x.Deployer + } + return "" +} + +func (x *HyperliquidTokenDeployInfo) GetRegisterTx() string { + if x != nil { + return x.RegisterTx + } + return "" +} + +func (x *HyperliquidTokenDeployInfo) GetRegisterSpotTx() string { + if x != nil { + return x.RegisterSpotTx + } + return "" +} + +func (x *HyperliquidTokenDeployInfo) GetGenesisTx() string { + if x != nil { + return x.GenesisTx + } + return "" +} + +func (x *HyperliquidTokenDeployInfo) GetHyperliquidityTx() string { + if x != nil { + return x.HyperliquidityTx + } + return "" +} + +func (x *HyperliquidTokenDeployInfo) GetHip2Price() float64 { + if x != nil { + return x.Hip2Price + } + return 0 +} + +func (x *HyperliquidTokenDeployInfo) GetHip2OrderCount() int32 { + if x != nil { + return x.Hip2OrderCount + } + return 0 +} + +func (x *HyperliquidTokenDeployInfo) GetHip2OrderSize() float64 { + if x != nil { + return x.Hip2OrderSize + } + return 0 +} + +type HyperliquidTokenGenesis struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TokenId int64 `protobuf:"varint,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + Target string `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"` + Amount float64 `protobuf:"fixed64,3,opt,name=amount,proto3" json:"amount,omitempty"` + Type string `protobuf:"bytes,4,opt,name=type,proto3" json:"type,omitempty"` + TargetTokenId *wrapperspb.Int64Value `protobuf:"bytes,5,opt,name=target_token_id,json=targetTokenId,proto3" json:"target_token_id,omitempty"` +} + +func (x *HyperliquidTokenGenesis) Reset() { + *x = HyperliquidTokenGenesis{} + mi := &file_hypurr_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenGenesis) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenGenesis) ProtoMessage() {} + +func (x *HyperliquidTokenGenesis) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenGenesis.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenGenesis) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{6} +} + +func (x *HyperliquidTokenGenesis) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +func (x *HyperliquidTokenGenesis) GetTarget() string { + if x != nil { + return x.Target + } + return "" +} + +func (x *HyperliquidTokenGenesis) GetAmount() float64 { + if x != nil { + return x.Amount + } + return 0 +} + +func (x *HyperliquidTokenGenesis) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *HyperliquidTokenGenesis) GetTargetTokenId() *wrapperspb.Int64Value { + if x != nil { + return x.TargetTokenId + } + return nil +} + +type HyperliquidSpotPair struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + BaseId int64 `protobuf:"varint,3,opt,name=base_id,json=baseId,proto3" json:"base_id,omitempty"` + Base *HyperliquidToken `protobuf:"bytes,4,opt,name=base,proto3" json:"base,omitempty"` + QuoteId int64 `protobuf:"varint,5,opt,name=quote_id,json=quoteId,proto3" json:"quote_id,omitempty"` + Quote *HyperliquidToken `protobuf:"bytes,6,opt,name=quote,proto3" json:"quote,omitempty"` + Index int64 `protobuf:"varint,7,opt,name=index,proto3" json:"index,omitempty"` + MidPrice float64 `protobuf:"fixed64,8,opt,name=mid_price,json=midPrice,proto3" json:"mid_price,omitempty"` + MarkPrice float64 `protobuf:"fixed64,9,opt,name=mark_price,json=markPrice,proto3" json:"mark_price,omitempty"` + DailyNtlVolume float64 `protobuf:"fixed64,10,opt,name=daily_ntl_volume,json=dailyNtlVolume,proto3" json:"daily_ntl_volume,omitempty"` + PreviousDayPx float64 `protobuf:"fixed64,11,opt,name=previous_day_px,json=previousDayPx,proto3" json:"previous_day_px,omitempty"` +} + +func (x *HyperliquidSpotPair) Reset() { + *x = HyperliquidSpotPair{} + mi := &file_hypurr_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidSpotPair) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidSpotPair) ProtoMessage() {} + +func (x *HyperliquidSpotPair) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidSpotPair.ProtoReflect.Descriptor instead. +func (*HyperliquidSpotPair) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{7} +} + +func (x *HyperliquidSpotPair) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HyperliquidSpotPair) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *HyperliquidSpotPair) GetBaseId() int64 { + if x != nil { + return x.BaseId + } + return 0 +} + +func (x *HyperliquidSpotPair) GetBase() *HyperliquidToken { + if x != nil { + return x.Base + } + return nil +} + +func (x *HyperliquidSpotPair) GetQuoteId() int64 { + if x != nil { + return x.QuoteId + } + return 0 +} + +func (x *HyperliquidSpotPair) GetQuote() *HyperliquidToken { + if x != nil { + return x.Quote + } + return nil +} + +func (x *HyperliquidSpotPair) GetIndex() int64 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *HyperliquidSpotPair) GetMidPrice() float64 { + if x != nil { + return x.MidPrice + } + return 0 +} + +func (x *HyperliquidSpotPair) GetMarkPrice() float64 { + if x != nil { + return x.MarkPrice + } + return 0 +} + +func (x *HyperliquidSpotPair) GetDailyNtlVolume() float64 { + if x != nil { + return x.DailyNtlVolume + } + return 0 +} + +func (x *HyperliquidSpotPair) GetPreviousDayPx() float64 { + if x != nil { + return x.PreviousDayPx + } + return 0 +} + +type HyperliquidPerpPair struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Index int64 `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"` + MidPrice float64 `protobuf:"fixed64,4,opt,name=mid_price,json=midPrice,proto3" json:"mid_price,omitempty"` + MarkPrice float64 `protobuf:"fixed64,5,opt,name=mark_price,json=markPrice,proto3" json:"mark_price,omitempty"` + DailyNtlVolume float64 `protobuf:"fixed64,6,opt,name=daily_ntl_volume,json=dailyNtlVolume,proto3" json:"daily_ntl_volume,omitempty"` + PreviousDayPx float64 `protobuf:"fixed64,7,opt,name=previous_day_px,json=previousDayPx,proto3" json:"previous_day_px,omitempty"` + Funding float64 `protobuf:"fixed64,8,opt,name=funding,proto3" json:"funding,omitempty"` + OpenInterest float64 `protobuf:"fixed64,9,opt,name=open_interest,json=openInterest,proto3" json:"open_interest,omitempty"` + Premium float64 `protobuf:"fixed64,10,opt,name=premium,proto3" json:"premium,omitempty"` +} + +func (x *HyperliquidPerpPair) Reset() { + *x = HyperliquidPerpPair{} + mi := &file_hypurr_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidPerpPair) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidPerpPair) ProtoMessage() {} + +func (x *HyperliquidPerpPair) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidPerpPair.ProtoReflect.Descriptor instead. +func (*HyperliquidPerpPair) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{8} +} + +func (x *HyperliquidPerpPair) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HyperliquidPerpPair) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *HyperliquidPerpPair) GetIndex() int64 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *HyperliquidPerpPair) GetMidPrice() float64 { + if x != nil { + return x.MidPrice + } + return 0 +} + +func (x *HyperliquidPerpPair) GetMarkPrice() float64 { + if x != nil { + return x.MarkPrice + } + return 0 +} + +func (x *HyperliquidPerpPair) GetDailyNtlVolume() float64 { + if x != nil { + return x.DailyNtlVolume + } + return 0 +} + +func (x *HyperliquidPerpPair) GetPreviousDayPx() float64 { + if x != nil { + return x.PreviousDayPx + } + return 0 +} + +func (x *HyperliquidPerpPair) GetFunding() float64 { + if x != nil { + return x.Funding + } + return 0 +} + +func (x *HyperliquidPerpPair) GetOpenInterest() float64 { + if x != nil { + return x.OpenInterest + } + return 0 +} + +func (x *HyperliquidPerpPair) GetPremium() float64 { + if x != nil { + return x.Premium + } + return 0 +} + +type HyperliquidWallet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + TelegramId *wrapperspb.Int64Value `protobuf:"bytes,3,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + EthereumAddress string `protobuf:"bytes,4,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"` + Points int32 `protobuf:"varint,5,opt,name=points,proto3" json:"points,omitempty"` + Movements []*HyperliquidWalletMovement `protobuf:"bytes,6,rep,name=movements,proto3" json:"movements,omitempty"` + SpotBalances []*HyperliquidWalletBalance `protobuf:"bytes,7,rep,name=spot_balances,json=spotBalances,proto3" json:"spot_balances,omitempty"` + LaunchBalances []*HyperliquidLaunchBalance `protobuf:"bytes,8,rep,name=launch_balances,json=launchBalances,proto3" json:"launch_balances,omitempty"` + IsAgent bool `protobuf:"varint,9,opt,name=is_agent,json=isAgent,proto3" json:"is_agent,omitempty"` + IsReadOnly bool `protobuf:"varint,10,opt,name=is_read_only,json=isReadOnly,proto3" json:"is_read_only,omitempty"` +} + +func (x *HyperliquidWallet) Reset() { + *x = HyperliquidWallet{} + mi := &file_hypurr_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWallet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWallet) ProtoMessage() {} + +func (x *HyperliquidWallet) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWallet.ProtoReflect.Descriptor instead. +func (*HyperliquidWallet) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{9} +} + +func (x *HyperliquidWallet) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HyperliquidWallet) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *HyperliquidWallet) GetTelegramId() *wrapperspb.Int64Value { + if x != nil { + return x.TelegramId + } + return nil +} + +func (x *HyperliquidWallet) GetEthereumAddress() string { + if x != nil { + return x.EthereumAddress + } + return "" +} + +func (x *HyperliquidWallet) GetPoints() int32 { + if x != nil { + return x.Points + } + return 0 +} + +func (x *HyperliquidWallet) GetMovements() []*HyperliquidWalletMovement { + if x != nil { + return x.Movements + } + return nil +} + +func (x *HyperliquidWallet) GetSpotBalances() []*HyperliquidWalletBalance { + if x != nil { + return x.SpotBalances + } + return nil +} + +func (x *HyperliquidWallet) GetLaunchBalances() []*HyperliquidLaunchBalance { + if x != nil { + return x.LaunchBalances + } + return nil +} + +func (x *HyperliquidWallet) GetIsAgent() bool { + if x != nil { + return x.IsAgent + } + return false +} + +func (x *HyperliquidWallet) GetIsReadOnly() bool { + if x != nil { + return x.IsReadOnly + } + return false +} + +type HyperliquidPublicWallet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EthereumAddress string `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"` +} + +func (x *HyperliquidPublicWallet) Reset() { + *x = HyperliquidPublicWallet{} + mi := &file_hypurr_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidPublicWallet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidPublicWallet) ProtoMessage() {} + +func (x *HyperliquidPublicWallet) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidPublicWallet.ProtoReflect.Descriptor instead. +func (*HyperliquidPublicWallet) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{10} +} + +func (x *HyperliquidPublicWallet) GetEthereumAddress() string { + if x != nil { + return x.EthereumAddress + } + return "" +} + +type HyperliquidWalletMovement struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TelegramId *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + Wallet *HyperliquidWallet `protobuf:"bytes,2,opt,name=wallet,proto3" json:"wallet,omitempty"` + WalletId int64 `protobuf:"varint,3,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + Hash string `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` + Type string `protobuf:"bytes,5,opt,name=type,proto3" json:"type,omitempty"` + TokenId int64 `protobuf:"varint,6,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + Token *HyperliquidToken `protobuf:"bytes,7,opt,name=token,proto3" json:"token,omitempty"` + Amount float64 `protobuf:"fixed64,8,opt,name=amount,proto3" json:"amount,omitempty"` + UsdcValue float64 `protobuf:"fixed64,9,opt,name=usdc_value,json=usdcValue,proto3" json:"usdc_value,omitempty"` + Destination string `protobuf:"bytes,10,opt,name=destination,proto3" json:"destination,omitempty"` + Fee float64 `protobuf:"fixed64,11,opt,name=fee,proto3" json:"fee,omitempty"` + Timestamp *wrapperspb.Int64Value `protobuf:"bytes,12,opt,name=timestamp,proto3" json:"timestamp,omitempty"` +} + +func (x *HyperliquidWalletMovement) Reset() { + *x = HyperliquidWalletMovement{} + mi := &file_hypurr_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletMovement) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletMovement) ProtoMessage() {} + +func (x *HyperliquidWalletMovement) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletMovement.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletMovement) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{11} +} + +func (x *HyperliquidWalletMovement) GetTelegramId() *wrapperspb.Int64Value { + if x != nil { + return x.TelegramId + } + return nil +} + +func (x *HyperliquidWalletMovement) GetWallet() *HyperliquidWallet { + if x != nil { + return x.Wallet + } + return nil +} + +func (x *HyperliquidWalletMovement) GetWalletId() int64 { + if x != nil { + return x.WalletId + } + return 0 +} + +func (x *HyperliquidWalletMovement) GetHash() string { + if x != nil { + return x.Hash + } + return "" +} + +func (x *HyperliquidWalletMovement) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *HyperliquidWalletMovement) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +func (x *HyperliquidWalletMovement) GetToken() *HyperliquidToken { + if x != nil { + return x.Token + } + return nil +} + +func (x *HyperliquidWalletMovement) GetAmount() float64 { + if x != nil { + return x.Amount + } + return 0 +} + +func (x *HyperliquidWalletMovement) GetUsdcValue() float64 { + if x != nil { + return x.UsdcValue + } + return 0 +} + +func (x *HyperliquidWalletMovement) GetDestination() string { + if x != nil { + return x.Destination + } + return "" +} + +func (x *HyperliquidWalletMovement) GetFee() float64 { + if x != nil { + return x.Fee + } + return 0 +} + +func (x *HyperliquidWalletMovement) GetTimestamp() *wrapperspb.Int64Value { + if x != nil { + return x.Timestamp + } + return nil +} + +type HyperliquidWalletBalance struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TelegramId *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + WalletId int64 `protobuf:"varint,2,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + TokenId int64 `protobuf:"varint,3,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + Balance float64 `protobuf:"fixed64,4,opt,name=balance,proto3" json:"balance,omitempty"` +} + +func (x *HyperliquidWalletBalance) Reset() { + *x = HyperliquidWalletBalance{} + mi := &file_hypurr_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletBalance) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletBalance) ProtoMessage() {} + +func (x *HyperliquidWalletBalance) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletBalance.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletBalance) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{12} +} + +func (x *HyperliquidWalletBalance) GetTelegramId() *wrapperspb.Int64Value { + if x != nil { + return x.TelegramId + } + return nil +} + +func (x *HyperliquidWalletBalance) GetWalletId() int64 { + if x != nil { + return x.WalletId + } + return 0 +} + +func (x *HyperliquidWalletBalance) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +func (x *HyperliquidWalletBalance) GetBalance() float64 { + if x != nil { + return x.Balance + } + return 0 +} + +type HyperliquidLaunchBalance struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TelegramId *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + WalletId int64 `protobuf:"varint,2,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + LaunchId int64 `protobuf:"varint,3,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` + Balance int64 `protobuf:"varint,4,opt,name=balance,proto3" json:"balance,omitempty"` +} + +func (x *HyperliquidLaunchBalance) Reset() { + *x = HyperliquidLaunchBalance{} + mi := &file_hypurr_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchBalance) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchBalance) ProtoMessage() {} + +func (x *HyperliquidLaunchBalance) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchBalance.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchBalance) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{13} +} + +func (x *HyperliquidLaunchBalance) GetTelegramId() *wrapperspb.Int64Value { + if x != nil { + return x.TelegramId + } + return nil +} + +func (x *HyperliquidLaunchBalance) GetWalletId() int64 { + if x != nil { + return x.WalletId + } + return 0 +} + +func (x *HyperliquidLaunchBalance) GetLaunchId() int64 { + if x != nil { + return x.LaunchId + } + return 0 +} + +func (x *HyperliquidLaunchBalance) GetBalance() int64 { + if x != nil { + return x.Balance + } + return 0 +} + +type HyperliquidWalletDeploySession struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + TelegramId *wrapperspb.Int64Value `protobuf:"bytes,2,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + Step int32 `protobuf:"varint,3,opt,name=step,proto3" json:"step,omitempty"` + TokenName string `protobuf:"bytes,4,opt,name=token_name,json=tokenName,proto3" json:"token_name,omitempty"` + FullName string `protobuf:"bytes,5,opt,name=full_name,json=fullName,proto3" json:"full_name,omitempty"` + TokenDecimals int32 `protobuf:"varint,6,opt,name=token_decimals,json=tokenDecimals,proto3" json:"token_decimals,omitempty"` + TokenWei int32 `protobuf:"varint,7,opt,name=token_wei,json=tokenWei,proto3" json:"token_wei,omitempty"` + TokenSupply float64 `protobuf:"fixed64,8,opt,name=token_supply,json=tokenSupply,proto3" json:"token_supply,omitempty"` + StartMarketCap int32 `protobuf:"varint,9,opt,name=start_market_cap,json=startMarketCap,proto3" json:"start_market_cap,omitempty"` + Anchor1TokenId *wrapperspb.Int64Value `protobuf:"bytes,10,opt,name=anchor1_token_id,json=anchor1TokenId,proto3" json:"anchor1_token_id,omitempty"` + Anchor1Token *HyperliquidToken `protobuf:"bytes,11,opt,name=anchor1_token,json=anchor1Token,proto3" json:"anchor1_token,omitempty"` + Anchor2TokenId *wrapperspb.Int64Value `protobuf:"bytes,12,opt,name=anchor2_token_id,json=anchor2TokenId,proto3" json:"anchor2_token_id,omitempty"` + Anchor2Token *HyperliquidToken `protobuf:"bytes,13,opt,name=anchor2_token,json=anchor2Token,proto3" json:"anchor2_token,omitempty"` + TokenId *wrapperspb.Int64Value `protobuf:"bytes,14,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + SpotPairId int32 `protobuf:"varint,15,opt,name=spot_pair_id,json=spotPairId,proto3" json:"spot_pair_id,omitempty"` + DeployThreshold float64 `protobuf:"fixed64,16,opt,name=deploy_threshold,json=deployThreshold,proto3" json:"deploy_threshold,omitempty"` + Geneses map[string]*HyperliquidWalletDeploySessionGenesis `protobuf:"bytes,17,rep,name=geneses,proto3" json:"geneses,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *HyperliquidWalletDeploySession) Reset() { + *x = HyperliquidWalletDeploySession{} + mi := &file_hypurr_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletDeploySession) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletDeploySession) ProtoMessage() {} + +func (x *HyperliquidWalletDeploySession) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletDeploySession.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletDeploySession) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{14} +} + +func (x *HyperliquidWalletDeploySession) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HyperliquidWalletDeploySession) GetTelegramId() *wrapperspb.Int64Value { + if x != nil { + return x.TelegramId + } + return nil +} + +func (x *HyperliquidWalletDeploySession) GetStep() int32 { + if x != nil { + return x.Step + } + return 0 +} + +func (x *HyperliquidWalletDeploySession) GetTokenName() string { + if x != nil { + return x.TokenName + } + return "" +} + +func (x *HyperliquidWalletDeploySession) GetFullName() string { + if x != nil { + return x.FullName + } + return "" +} + +func (x *HyperliquidWalletDeploySession) GetTokenDecimals() int32 { + if x != nil { + return x.TokenDecimals + } + return 0 +} + +func (x *HyperliquidWalletDeploySession) GetTokenWei() int32 { + if x != nil { + return x.TokenWei + } + return 0 +} + +func (x *HyperliquidWalletDeploySession) GetTokenSupply() float64 { + if x != nil { + return x.TokenSupply + } + return 0 +} + +func (x *HyperliquidWalletDeploySession) GetStartMarketCap() int32 { + if x != nil { + return x.StartMarketCap + } + return 0 +} + +func (x *HyperliquidWalletDeploySession) GetAnchor1TokenId() *wrapperspb.Int64Value { + if x != nil { + return x.Anchor1TokenId + } + return nil +} + +func (x *HyperliquidWalletDeploySession) GetAnchor1Token() *HyperliquidToken { + if x != nil { + return x.Anchor1Token + } + return nil +} + +func (x *HyperliquidWalletDeploySession) GetAnchor2TokenId() *wrapperspb.Int64Value { + if x != nil { + return x.Anchor2TokenId + } + return nil +} + +func (x *HyperliquidWalletDeploySession) GetAnchor2Token() *HyperliquidToken { + if x != nil { + return x.Anchor2Token + } + return nil +} + +func (x *HyperliquidWalletDeploySession) GetTokenId() *wrapperspb.Int64Value { + if x != nil { + return x.TokenId + } + return nil +} + +func (x *HyperliquidWalletDeploySession) GetSpotPairId() int32 { + if x != nil { + return x.SpotPairId + } + return 0 +} + +func (x *HyperliquidWalletDeploySession) GetDeployThreshold() float64 { + if x != nil { + return x.DeployThreshold + } + return 0 +} + +func (x *HyperliquidWalletDeploySession) GetGeneses() map[string]*HyperliquidWalletDeploySessionGenesis { + if x != nil { + return x.Geneses + } + return nil +} + +type HyperliquidLaunch struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + TelegramId int64 `protobuf:"varint,2,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + TelegramUser *TelegramUserPublic `protobuf:"bytes,3,opt,name=telegram_user,json=telegramUser,proto3" json:"telegram_user,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + Listed bool `protobuf:"varint,5,opt,name=listed,proto3" json:"listed,omitempty"` + Settled bool `protobuf:"varint,6,opt,name=settled,proto3" json:"settled,omitempty"` + X0 int64 `protobuf:"varint,7,opt,name=x0,proto3" json:"x0,omitempty"` + SessionId int64 `protobuf:"varint,8,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"` + Session *HyperliquidWalletDeploySession `protobuf:"bytes,9,opt,name=session,proto3" json:"session,omitempty"` + MediaFileId string `protobuf:"bytes,10,opt,name=media_file_id,json=mediaFileId,proto3" json:"media_file_id,omitempty"` + TopicId *wrapperspb.Int64Value `protobuf:"bytes,11,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"` + X int64 `protobuf:"varint,12,opt,name=x,proto3" json:"x,omitempty"` + Y int64 `protobuf:"varint,13,opt,name=y,proto3" json:"y,omitempty"` + K int64 `protobuf:"varint,14,opt,name=k,proto3" json:"k,omitempty"` + Fills []*HyperliquidLaunchFill `protobuf:"bytes,15,rep,name=fills,proto3" json:"fills,omitempty"` + DailyNtlVolume float64 `protobuf:"fixed64,16,opt,name=daily_ntl_volume,json=dailyNtlVolume,proto3" json:"daily_ntl_volume,omitempty"` + PreviousDayPx float64 `protobuf:"fixed64,17,opt,name=previous_day_px,json=previousDayPx,proto3" json:"previous_day_px,omitempty"` + LastEventTimestamp int64 `protobuf:"varint,18,opt,name=last_event_timestamp,json=lastEventTimestamp,proto3" json:"last_event_timestamp,omitempty"` + PoolType HyperliquidLaunchPoolType `protobuf:"varint,19,opt,name=pool_type,json=poolType,proto3,enum=hypurr.HyperliquidLaunchPoolType" json:"pool_type,omitempty"` + Decimals int64 `protobuf:"varint,20,opt,name=decimals,proto3" json:"decimals,omitempty"` + SessionWallet *HyperliquidPublicWallet `protobuf:"bytes,21,opt,name=session_wallet,json=sessionWallet,proto3" json:"session_wallet,omitempty"` + MediaType string `protobuf:"bytes,22,opt,name=media_type,json=mediaType,proto3" json:"media_type,omitempty"` + ListedTimestamp int64 `protobuf:"varint,23,opt,name=listed_timestamp,json=listedTimestamp,proto3" json:"listed_timestamp,omitempty"` + DevWallet *HyperliquidPublicWallet `protobuf:"bytes,24,opt,name=dev_wallet,json=devWallet,proto3" json:"dev_wallet,omitempty"` +} + +func (x *HyperliquidLaunch) Reset() { + *x = HyperliquidLaunch{} + mi := &file_hypurr_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunch) ProtoMessage() {} + +func (x *HyperliquidLaunch) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunch.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunch) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{15} +} + +func (x *HyperliquidLaunch) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HyperliquidLaunch) GetTelegramId() int64 { + if x != nil { + return x.TelegramId + } + return 0 +} + +func (x *HyperliquidLaunch) GetTelegramUser() *TelegramUserPublic { + if x != nil { + return x.TelegramUser + } + return nil +} + +func (x *HyperliquidLaunch) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *HyperliquidLaunch) GetListed() bool { + if x != nil { + return x.Listed + } + return false +} + +func (x *HyperliquidLaunch) GetSettled() bool { + if x != nil { + return x.Settled + } + return false +} + +func (x *HyperliquidLaunch) GetX0() int64 { + if x != nil { + return x.X0 + } + return 0 +} + +func (x *HyperliquidLaunch) GetSessionId() int64 { + if x != nil { + return x.SessionId + } + return 0 +} + +func (x *HyperliquidLaunch) GetSession() *HyperliquidWalletDeploySession { + if x != nil { + return x.Session + } + return nil +} + +func (x *HyperliquidLaunch) GetMediaFileId() string { + if x != nil { + return x.MediaFileId + } + return "" +} + +func (x *HyperliquidLaunch) GetTopicId() *wrapperspb.Int64Value { + if x != nil { + return x.TopicId + } + return nil +} + +func (x *HyperliquidLaunch) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *HyperliquidLaunch) GetY() int64 { + if x != nil { + return x.Y + } + return 0 +} + +func (x *HyperliquidLaunch) GetK() int64 { + if x != nil { + return x.K + } + return 0 +} + +func (x *HyperliquidLaunch) GetFills() []*HyperliquidLaunchFill { + if x != nil { + return x.Fills + } + return nil +} + +func (x *HyperliquidLaunch) GetDailyNtlVolume() float64 { + if x != nil { + return x.DailyNtlVolume + } + return 0 +} + +func (x *HyperliquidLaunch) GetPreviousDayPx() float64 { + if x != nil { + return x.PreviousDayPx + } + return 0 +} + +func (x *HyperliquidLaunch) GetLastEventTimestamp() int64 { + if x != nil { + return x.LastEventTimestamp + } + return 0 +} + +func (x *HyperliquidLaunch) GetPoolType() HyperliquidLaunchPoolType { + if x != nil { + return x.PoolType + } + return HyperliquidLaunchPoolType_Quadratic +} + +func (x *HyperliquidLaunch) GetDecimals() int64 { + if x != nil { + return x.Decimals + } + return 0 +} + +func (x *HyperliquidLaunch) GetSessionWallet() *HyperliquidPublicWallet { + if x != nil { + return x.SessionWallet + } + return nil +} + +func (x *HyperliquidLaunch) GetMediaType() string { + if x != nil { + return x.MediaType + } + return "" +} + +func (x *HyperliquidLaunch) GetListedTimestamp() int64 { + if x != nil { + return x.ListedTimestamp + } + return 0 +} + +func (x *HyperliquidLaunch) GetDevWallet() *HyperliquidPublicWallet { + if x != nil { + return x.DevWallet + } + return nil +} + +type HyperliquidLaunchFill struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + LaunchId int64 `protobuf:"varint,1,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` + TelegramId int64 `protobuf:"varint,2,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + Telegram *TelegramUserPublic `protobuf:"bytes,3,opt,name=telegram,proto3" json:"telegram,omitempty"` + Wallet *HyperliquidPublicWallet `protobuf:"bytes,4,opt,name=wallet,proto3" json:"wallet,omitempty"` + UsdcDelta int64 `protobuf:"varint,5,opt,name=usdc_delta,json=usdcDelta,proto3" json:"usdc_delta,omitempty"` + LaunchDelta int64 `protobuf:"varint,6,opt,name=launch_delta,json=launchDelta,proto3" json:"launch_delta,omitempty"` + Timestamp int64 `protobuf:"varint,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + MovementHash *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=movement_hash,json=movementHash,proto3" json:"movement_hash,omitempty"` + Id int64 `protobuf:"varint,9,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *HyperliquidLaunchFill) Reset() { + *x = HyperliquidLaunchFill{} + mi := &file_hypurr_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchFill) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchFill) ProtoMessage() {} + +func (x *HyperliquidLaunchFill) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchFill.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchFill) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{16} +} + +func (x *HyperliquidLaunchFill) GetLaunchId() int64 { + if x != nil { + return x.LaunchId + } + return 0 +} + +func (x *HyperliquidLaunchFill) GetTelegramId() int64 { + if x != nil { + return x.TelegramId + } + return 0 +} + +func (x *HyperliquidLaunchFill) GetTelegram() *TelegramUserPublic { + if x != nil { + return x.Telegram + } + return nil +} + +func (x *HyperliquidLaunchFill) GetWallet() *HyperliquidPublicWallet { + if x != nil { + return x.Wallet + } + return nil +} + +func (x *HyperliquidLaunchFill) GetUsdcDelta() int64 { + if x != nil { + return x.UsdcDelta + } + return 0 +} + +func (x *HyperliquidLaunchFill) GetLaunchDelta() int64 { + if x != nil { + return x.LaunchDelta + } + return 0 +} + +func (x *HyperliquidLaunchFill) GetTimestamp() int64 { + if x != nil { + return x.Timestamp + } + return 0 +} + +func (x *HyperliquidLaunchFill) GetMovementHash() *wrapperspb.StringValue { + if x != nil { + return x.MovementHash + } + return nil +} + +func (x *HyperliquidLaunchFill) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type TelegramUserPublic struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"` + PictureFileId string `protobuf:"bytes,3,opt,name=picture_file_id,json=pictureFileId,proto3" json:"picture_file_id,omitempty"` + ReputationScore int64 `protobuf:"varint,4,opt,name=reputation_score,json=reputationScore,proto3" json:"reputation_score,omitempty"` +} + +func (x *TelegramUserPublic) Reset() { + *x = TelegramUserPublic{} + mi := &file_hypurr_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TelegramUserPublic) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TelegramUserPublic) ProtoMessage() {} + +func (x *TelegramUserPublic) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TelegramUserPublic.ProtoReflect.Descriptor instead. +func (*TelegramUserPublic) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{17} +} + +func (x *TelegramUserPublic) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *TelegramUserPublic) GetUsername() string { + if x != nil { + return x.Username + } + return "" +} + +func (x *TelegramUserPublic) GetPictureFileId() string { + if x != nil { + return x.PictureFileId + } + return "" +} + +func (x *TelegramUserPublic) GetReputationScore() int64 { + if x != nil { + return x.ReputationScore + } + return 0 +} + +type HyperliquidDeployAuction struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StartTime int64 `protobuf:"varint,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + Duration int64 `protobuf:"varint,2,opt,name=duration,proto3" json:"duration,omitempty"` + StartGas float64 `protobuf:"fixed64,3,opt,name=start_gas,json=startGas,proto3" json:"start_gas,omitempty"` + CurrentGas *wrapperspb.DoubleValue `protobuf:"bytes,4,opt,name=current_gas,json=currentGas,proto3" json:"current_gas,omitempty"` + EndGas *wrapperspb.DoubleValue `protobuf:"bytes,5,opt,name=end_gas,json=endGas,proto3" json:"end_gas,omitempty"` +} + +func (x *HyperliquidDeployAuction) Reset() { + *x = HyperliquidDeployAuction{} + mi := &file_hypurr_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidDeployAuction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidDeployAuction) ProtoMessage() {} + +func (x *HyperliquidDeployAuction) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[18] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidDeployAuction.ProtoReflect.Descriptor instead. +func (*HyperliquidDeployAuction) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{18} +} + +func (x *HyperliquidDeployAuction) GetStartTime() int64 { + if x != nil { + return x.StartTime + } + return 0 +} + +func (x *HyperliquidDeployAuction) GetDuration() int64 { + if x != nil { + return x.Duration + } + return 0 +} + +func (x *HyperliquidDeployAuction) GetStartGas() float64 { + if x != nil { + return x.StartGas + } + return 0 +} + +func (x *HyperliquidDeployAuction) GetCurrentGas() *wrapperspb.DoubleValue { + if x != nil { + return x.CurrentGas + } + return nil +} + +func (x *HyperliquidDeployAuction) GetEndGas() *wrapperspb.DoubleValue { + if x != nil { + return x.EndGas + } + return nil +} + +type HyperliquidDeployAuctionRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *HyperliquidDeployAuctionRequest) Reset() { + *x = HyperliquidDeployAuctionRequest{} + mi := &file_hypurr_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidDeployAuctionRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidDeployAuctionRequest) ProtoMessage() {} + +func (x *HyperliquidDeployAuctionRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[19] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidDeployAuctionRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidDeployAuctionRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{19} +} + +type HyperliquidDeployAuctionResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Auction *HyperliquidDeployAuction `protobuf:"bytes,1,opt,name=auction,proto3" json:"auction,omitempty"` +} + +func (x *HyperliquidDeployAuctionResponse) Reset() { + *x = HyperliquidDeployAuctionResponse{} + mi := &file_hypurr_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidDeployAuctionResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidDeployAuctionResponse) ProtoMessage() {} + +func (x *HyperliquidDeployAuctionResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[20] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidDeployAuctionResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidDeployAuctionResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{20} +} + +func (x *HyperliquidDeployAuctionResponse) GetAuction() *HyperliquidDeployAuction { + if x != nil { + return x.Auction + } + return nil +} + +type HyperliquidTokensRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *HyperliquidTokensRequest) Reset() { + *x = HyperliquidTokensRequest{} + mi := &file_hypurr_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokensRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokensRequest) ProtoMessage() {} + +func (x *HyperliquidTokensRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[21] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokensRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidTokensRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{21} +} + +type HyperliquidTokensResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Tokens []*HyperliquidToken `protobuf:"bytes,1,rep,name=tokens,proto3" json:"tokens,omitempty"` +} + +func (x *HyperliquidTokensResponse) Reset() { + *x = HyperliquidTokensResponse{} + mi := &file_hypurr_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokensResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokensResponse) ProtoMessage() {} + +func (x *HyperliquidTokensResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[22] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokensResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidTokensResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{22} +} + +func (x *HyperliquidTokensResponse) GetTokens() []*HyperliquidToken { + if x != nil { + return x.Tokens + } + return nil +} + +type HyperliquidTokenMessage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Timestamp int64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + TokenId int64 `protobuf:"varint,3,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + TelegramId int64 `protobuf:"varint,4,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + Author *TelegramUserPublic `protobuf:"bytes,5,opt,name=author,proto3" json:"author,omitempty"` + ChatId int64 `protobuf:"varint,6,opt,name=chat_id,json=chatId,proto3" json:"chat_id,omitempty"` + TopicId int64 `protobuf:"varint,7,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"` + Message string `protobuf:"bytes,8,opt,name=message,proto3" json:"message,omitempty"` +} + +func (x *HyperliquidTokenMessage) Reset() { + *x = HyperliquidTokenMessage{} + mi := &file_hypurr_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenMessage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenMessage) ProtoMessage() {} + +func (x *HyperliquidTokenMessage) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenMessage.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenMessage) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{23} +} + +func (x *HyperliquidTokenMessage) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HyperliquidTokenMessage) GetTimestamp() int64 { + if x != nil { + return x.Timestamp + } + return 0 +} + +func (x *HyperliquidTokenMessage) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +func (x *HyperliquidTokenMessage) GetTelegramId() int64 { + if x != nil { + return x.TelegramId + } + return 0 +} + +func (x *HyperliquidTokenMessage) GetAuthor() *TelegramUserPublic { + if x != nil { + return x.Author + } + return nil +} + +func (x *HyperliquidTokenMessage) GetChatId() int64 { + if x != nil { + return x.ChatId + } + return 0 +} + +func (x *HyperliquidTokenMessage) GetTopicId() int64 { + if x != nil { + return x.TopicId + } + return 0 +} + +func (x *HyperliquidTokenMessage) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type HyperliquidTokenMessagesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TokenId int64 `protobuf:"varint,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` +} + +func (x *HyperliquidTokenMessagesRequest) Reset() { + *x = HyperliquidTokenMessagesRequest{} + mi := &file_hypurr_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenMessagesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenMessagesRequest) ProtoMessage() {} + +func (x *HyperliquidTokenMessagesRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[24] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenMessagesRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenMessagesRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{24} +} + +func (x *HyperliquidTokenMessagesRequest) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +type HyperliquidTokenMessagesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Messages []*HyperliquidTokenMessage `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"` +} + +func (x *HyperliquidTokenMessagesResponse) Reset() { + *x = HyperliquidTokenMessagesResponse{} + mi := &file_hypurr_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidTokenMessagesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidTokenMessagesResponse) ProtoMessage() {} + +func (x *HyperliquidTokenMessagesResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidTokenMessagesResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidTokenMessagesResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{25} +} + +func (x *HyperliquidTokenMessagesResponse) GetMessages() []*HyperliquidTokenMessage { + if x != nil { + return x.Messages + } + return nil +} + +type HyperliquidSpotPairRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *HyperliquidSpotPairRequest) Reset() { + *x = HyperliquidSpotPairRequest{} + mi := &file_hypurr_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidSpotPairRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidSpotPairRequest) ProtoMessage() {} + +func (x *HyperliquidSpotPairRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[26] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidSpotPairRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidSpotPairRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{26} +} + +func (x *HyperliquidSpotPairRequest) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type HyperliquidSpotPairResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pair *HyperliquidSpotPair `protobuf:"bytes,1,opt,name=pair,proto3" json:"pair,omitempty"` +} + +func (x *HyperliquidSpotPairResponse) Reset() { + *x = HyperliquidSpotPairResponse{} + mi := &file_hypurr_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidSpotPairResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidSpotPairResponse) ProtoMessage() {} + +func (x *HyperliquidSpotPairResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[27] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidSpotPairResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidSpotPairResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{27} +} + +func (x *HyperliquidSpotPairResponse) GetPair() *HyperliquidSpotPair { + if x != nil { + return x.Pair + } + return nil +} + +type HyperliquidSpotPairsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *HyperliquidSpotPairsRequest) Reset() { + *x = HyperliquidSpotPairsRequest{} + mi := &file_hypurr_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidSpotPairsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidSpotPairsRequest) ProtoMessage() {} + +func (x *HyperliquidSpotPairsRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidSpotPairsRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidSpotPairsRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{28} +} + +type HyperliquidSpotPairsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pairs []*HyperliquidSpotPair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs,omitempty"` +} + +func (x *HyperliquidSpotPairsResponse) Reset() { + *x = HyperliquidSpotPairsResponse{} + mi := &file_hypurr_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidSpotPairsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidSpotPairsResponse) ProtoMessage() {} + +func (x *HyperliquidSpotPairsResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidSpotPairsResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidSpotPairsResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{29} +} + +func (x *HyperliquidSpotPairsResponse) GetPairs() []*HyperliquidSpotPair { + if x != nil { + return x.Pairs + } + return nil +} + +type HyperliquidPerpPairsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *HyperliquidPerpPairsRequest) Reset() { + *x = HyperliquidPerpPairsRequest{} + mi := &file_hypurr_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidPerpPairsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidPerpPairsRequest) ProtoMessage() {} + +func (x *HyperliquidPerpPairsRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidPerpPairsRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidPerpPairsRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{30} +} + +type HyperliquidPerpPairsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pairs []*HyperliquidPerpPair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs,omitempty"` +} + +func (x *HyperliquidPerpPairsResponse) Reset() { + *x = HyperliquidPerpPairsResponse{} + mi := &file_hypurr_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidPerpPairsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidPerpPairsResponse) ProtoMessage() {} + +func (x *HyperliquidPerpPairsResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidPerpPairsResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidPerpPairsResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{31} +} + +func (x *HyperliquidPerpPairsResponse) GetPairs() []*HyperliquidPerpPair { + if x != nil { + return x.Pairs + } + return nil +} + +type HyperliquidWalletRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EthereumAddress *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"` +} + +func (x *HyperliquidWalletRequest) Reset() { + *x = HyperliquidWalletRequest{} + mi := &file_hypurr_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletRequest) ProtoMessage() {} + +func (x *HyperliquidWalletRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[32] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{32} +} + +func (x *HyperliquidWalletRequest) GetEthereumAddress() *wrapperspb.StringValue { + if x != nil { + return x.EthereumAddress + } + return nil +} + +type HyperliquidWalletResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Wallet *HyperliquidWallet `protobuf:"bytes,1,opt,name=wallet,proto3" json:"wallet,omitempty"` +} + +func (x *HyperliquidWalletResponse) Reset() { + *x = HyperliquidWalletResponse{} + mi := &file_hypurr_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletResponse) ProtoMessage() {} + +func (x *HyperliquidWalletResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[33] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{33} +} + +func (x *HyperliquidWalletResponse) GetWallet() *HyperliquidWallet { + if x != nil { + return x.Wallet + } + return nil +} + +type HyperliquidLaunchesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *HyperliquidLaunchesRequest) Reset() { + *x = HyperliquidLaunchesRequest{} + mi := &file_hypurr_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchesRequest) ProtoMessage() {} + +func (x *HyperliquidLaunchesRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[34] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchesRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchesRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{34} +} + +type HyperliquidLaunchesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Launches []*HyperliquidLaunch `protobuf:"bytes,1,rep,name=launches,proto3" json:"launches,omitempty"` +} + +func (x *HyperliquidLaunchesResponse) Reset() { + *x = HyperliquidLaunchesResponse{} + mi := &file_hypurr_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchesResponse) ProtoMessage() {} + +func (x *HyperliquidLaunchesResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[35] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchesResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchesResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{35} +} + +func (x *HyperliquidLaunchesResponse) GetLaunches() []*HyperliquidLaunch { + if x != nil { + return x.Launches + } + return nil +} + +type HyperliquidLaunchStreamRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + LaunchId *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` +} + +func (x *HyperliquidLaunchStreamRequest) Reset() { + *x = HyperliquidLaunchStreamRequest{} + mi := &file_hypurr_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchStreamRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchStreamRequest) ProtoMessage() {} + +func (x *HyperliquidLaunchStreamRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[36] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchStreamRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchStreamRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{36} +} + +func (x *HyperliquidLaunchStreamRequest) GetLaunchId() *wrapperspb.Int64Value { + if x != nil { + return x.LaunchId + } + return nil +} + +type HyperliquidLaunchStreamResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Launches []*HyperliquidLaunch `protobuf:"bytes,1,rep,name=launches,proto3" json:"launches,omitempty"` +} + +func (x *HyperliquidLaunchStreamResponse) Reset() { + *x = HyperliquidLaunchStreamResponse{} + mi := &file_hypurr_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchStreamResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchStreamResponse) ProtoMessage() {} + +func (x *HyperliquidLaunchStreamResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[37] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchStreamResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchStreamResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{37} +} + +func (x *HyperliquidLaunchStreamResponse) GetLaunches() []*HyperliquidLaunch { + if x != nil { + return x.Launches + } + return nil +} + +type HyperliquidWalletDeploySessionsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TelegramId *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + WalletId *wrapperspb.Int64Value `protobuf:"bytes,2,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + SessionId *wrapperspb.Int64Value `protobuf:"bytes,3,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"` + EthereumAddress *wrapperspb.StringValue `protobuf:"bytes,4,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"` +} + +func (x *HyperliquidWalletDeploySessionsRequest) Reset() { + *x = HyperliquidWalletDeploySessionsRequest{} + mi := &file_hypurr_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletDeploySessionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletDeploySessionsRequest) ProtoMessage() {} + +func (x *HyperliquidWalletDeploySessionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[38] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletDeploySessionsRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletDeploySessionsRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{38} +} + +func (x *HyperliquidWalletDeploySessionsRequest) GetTelegramId() *wrapperspb.Int64Value { + if x != nil { + return x.TelegramId + } + return nil +} + +func (x *HyperliquidWalletDeploySessionsRequest) GetWalletId() *wrapperspb.Int64Value { + if x != nil { + return x.WalletId + } + return nil +} + +func (x *HyperliquidWalletDeploySessionsRequest) GetSessionId() *wrapperspb.Int64Value { + if x != nil { + return x.SessionId + } + return nil +} + +func (x *HyperliquidWalletDeploySessionsRequest) GetEthereumAddress() *wrapperspb.StringValue { + if x != nil { + return x.EthereumAddress + } + return nil +} + +type HyperliquidWalletDeploySessionsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Sessions []*HyperliquidWalletDeploySession `protobuf:"bytes,1,rep,name=sessions,proto3" json:"sessions,omitempty"` +} + +func (x *HyperliquidWalletDeploySessionsResponse) Reset() { + *x = HyperliquidWalletDeploySessionsResponse{} + mi := &file_hypurr_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletDeploySessionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletDeploySessionsResponse) ProtoMessage() {} + +func (x *HyperliquidWalletDeploySessionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[39] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletDeploySessionsResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletDeploySessionsResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{39} +} + +func (x *HyperliquidWalletDeploySessionsResponse) GetSessions() []*HyperliquidWalletDeploySession { + if x != nil { + return x.Sessions + } + return nil +} + +type SetHyperliquidWalletDeploySessionTargetRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EthereumAddress *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"` + SessionId int64 `protobuf:"varint,2,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + Target string `protobuf:"bytes,4,opt,name=target,proto3" json:"target,omitempty"` + Share int32 `protobuf:"varint,5,opt,name=share,proto3" json:"share,omitempty"` +} + +func (x *SetHyperliquidWalletDeploySessionTargetRequest) Reset() { + *x = SetHyperliquidWalletDeploySessionTargetRequest{} + mi := &file_hypurr_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetHyperliquidWalletDeploySessionTargetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetHyperliquidWalletDeploySessionTargetRequest) ProtoMessage() {} + +func (x *SetHyperliquidWalletDeploySessionTargetRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[40] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetHyperliquidWalletDeploySessionTargetRequest.ProtoReflect.Descriptor instead. +func (*SetHyperliquidWalletDeploySessionTargetRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{40} +} + +func (x *SetHyperliquidWalletDeploySessionTargetRequest) GetEthereumAddress() *wrapperspb.StringValue { + if x != nil { + return x.EthereumAddress + } + return nil +} + +func (x *SetHyperliquidWalletDeploySessionTargetRequest) GetSessionId() int64 { + if x != nil { + return x.SessionId + } + return 0 +} + +func (x *SetHyperliquidWalletDeploySessionTargetRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *SetHyperliquidWalletDeploySessionTargetRequest) GetTarget() string { + if x != nil { + return x.Target + } + return "" +} + +func (x *SetHyperliquidWalletDeploySessionTargetRequest) GetShare() int32 { + if x != nil { + return x.Share + } + return 0 +} + +type SetHyperliquidWalletDeploySessionTargetResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Session *HyperliquidWalletDeploySession `protobuf:"bytes,1,opt,name=session,proto3" json:"session,omitempty"` +} + +func (x *SetHyperliquidWalletDeploySessionTargetResponse) Reset() { + *x = SetHyperliquidWalletDeploySessionTargetResponse{} + mi := &file_hypurr_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetHyperliquidWalletDeploySessionTargetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetHyperliquidWalletDeploySessionTargetResponse) ProtoMessage() {} + +func (x *SetHyperliquidWalletDeploySessionTargetResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[41] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetHyperliquidWalletDeploySessionTargetResponse.ProtoReflect.Descriptor instead. +func (*SetHyperliquidWalletDeploySessionTargetResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{41} +} + +func (x *SetHyperliquidWalletDeploySessionTargetResponse) GetSession() *HyperliquidWalletDeploySession { + if x != nil { + return x.Session + } + return nil +} + +type DeleteHyperliquidWalletDeploySessionTargetRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EthereumAddress *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"` + SessionId int64 `protobuf:"varint,2,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *DeleteHyperliquidWalletDeploySessionTargetRequest) Reset() { + *x = DeleteHyperliquidWalletDeploySessionTargetRequest{} + mi := &file_hypurr_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteHyperliquidWalletDeploySessionTargetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteHyperliquidWalletDeploySessionTargetRequest) ProtoMessage() {} + +func (x *DeleteHyperliquidWalletDeploySessionTargetRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[42] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteHyperliquidWalletDeploySessionTargetRequest.ProtoReflect.Descriptor instead. +func (*DeleteHyperliquidWalletDeploySessionTargetRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{42} +} + +func (x *DeleteHyperliquidWalletDeploySessionTargetRequest) GetEthereumAddress() *wrapperspb.StringValue { + if x != nil { + return x.EthereumAddress + } + return nil +} + +func (x *DeleteHyperliquidWalletDeploySessionTargetRequest) GetSessionId() int64 { + if x != nil { + return x.SessionId + } + return 0 +} + +func (x *DeleteHyperliquidWalletDeploySessionTargetRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type DeleteHyperliquidWalletDeploySessionTargetResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Session *HyperliquidWalletDeploySession `protobuf:"bytes,1,opt,name=session,proto3" json:"session,omitempty"` +} + +func (x *DeleteHyperliquidWalletDeploySessionTargetResponse) Reset() { + *x = DeleteHyperliquidWalletDeploySessionTargetResponse{} + mi := &file_hypurr_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteHyperliquidWalletDeploySessionTargetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteHyperliquidWalletDeploySessionTargetResponse) ProtoMessage() {} + +func (x *DeleteHyperliquidWalletDeploySessionTargetResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[43] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteHyperliquidWalletDeploySessionTargetResponse.ProtoReflect.Descriptor instead. +func (*DeleteHyperliquidWalletDeploySessionTargetResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{43} +} + +func (x *DeleteHyperliquidWalletDeploySessionTargetResponse) GetSession() *HyperliquidWalletDeploySession { + if x != nil { + return x.Session + } + return nil +} + +type HyperliquidLaunchFillsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + LaunchId *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` +} + +func (x *HyperliquidLaunchFillsRequest) Reset() { + *x = HyperliquidLaunchFillsRequest{} + mi := &file_hypurr_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchFillsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchFillsRequest) ProtoMessage() {} + +func (x *HyperliquidLaunchFillsRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[44] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchFillsRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchFillsRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{44} +} + +func (x *HyperliquidLaunchFillsRequest) GetLaunchId() *wrapperspb.Int64Value { + if x != nil { + return x.LaunchId + } + return nil +} + +type HyperliquidLaunchFillsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Fills []*HyperliquidLaunchFill `protobuf:"bytes,1,rep,name=fills,proto3" json:"fills,omitempty"` + Positions []*HyperliquidLaunchPosition `protobuf:"bytes,2,rep,name=positions,proto3" json:"positions,omitempty"` +} + +func (x *HyperliquidLaunchFillsResponse) Reset() { + *x = HyperliquidLaunchFillsResponse{} + mi := &file_hypurr_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchFillsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchFillsResponse) ProtoMessage() {} + +func (x *HyperliquidLaunchFillsResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[45] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchFillsResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchFillsResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{45} +} + +func (x *HyperliquidLaunchFillsResponse) GetFills() []*HyperliquidLaunchFill { + if x != nil { + return x.Fills + } + return nil +} + +func (x *HyperliquidLaunchFillsResponse) GetPositions() []*HyperliquidLaunchPosition { + if x != nil { + return x.Positions + } + return nil +} + +type HyperliquidLaunchPosition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Balance int64 `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty"` + Cost int64 `protobuf:"varint,3,opt,name=cost,proto3" json:"cost,omitempty"` +} + +func (x *HyperliquidLaunchPosition) Reset() { + *x = HyperliquidLaunchPosition{} + mi := &file_hypurr_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchPosition) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchPosition) ProtoMessage() {} + +func (x *HyperliquidLaunchPosition) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[46] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchPosition.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchPosition) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{46} +} + +func (x *HyperliquidLaunchPosition) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *HyperliquidLaunchPosition) GetBalance() int64 { + if x != nil { + return x.Balance + } + return 0 +} + +func (x *HyperliquidLaunchPosition) GetCost() int64 { + if x != nil { + return x.Cost + } + return 0 +} + +type HyperliquidLaunchCandlesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + LaunchId int64 `protobuf:"varint,1,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` + Interval string `protobuf:"bytes,2,opt,name=interval,proto3" json:"interval,omitempty"` +} + +func (x *HyperliquidLaunchCandlesRequest) Reset() { + *x = HyperliquidLaunchCandlesRequest{} + mi := &file_hypurr_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchCandlesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchCandlesRequest) ProtoMessage() {} + +func (x *HyperliquidLaunchCandlesRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[47] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchCandlesRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchCandlesRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{47} +} + +func (x *HyperliquidLaunchCandlesRequest) GetLaunchId() int64 { + if x != nil { + return x.LaunchId + } + return 0 +} + +func (x *HyperliquidLaunchCandlesRequest) GetInterval() string { + if x != nil { + return x.Interval + } + return "" +} + +type HyperliquidLaunchCandle struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Time int64 `protobuf:"varint,1,opt,name=time,proto3" json:"time,omitempty"` + Open float32 `protobuf:"fixed32,2,opt,name=open,proto3" json:"open,omitempty"` + High float32 `protobuf:"fixed32,3,opt,name=high,proto3" json:"high,omitempty"` + Low float32 `protobuf:"fixed32,4,opt,name=low,proto3" json:"low,omitempty"` + Close float32 `protobuf:"fixed32,5,opt,name=close,proto3" json:"close,omitempty"` + Volume float32 `protobuf:"fixed32,6,opt,name=volume,proto3" json:"volume,omitempty"` +} + +func (x *HyperliquidLaunchCandle) Reset() { + *x = HyperliquidLaunchCandle{} + mi := &file_hypurr_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchCandle) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchCandle) ProtoMessage() {} + +func (x *HyperliquidLaunchCandle) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[48] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchCandle.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchCandle) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{48} +} + +func (x *HyperliquidLaunchCandle) GetTime() int64 { + if x != nil { + return x.Time + } + return 0 +} + +func (x *HyperliquidLaunchCandle) GetOpen() float32 { + if x != nil { + return x.Open + } + return 0 +} + +func (x *HyperliquidLaunchCandle) GetHigh() float32 { + if x != nil { + return x.High + } + return 0 +} + +func (x *HyperliquidLaunchCandle) GetLow() float32 { + if x != nil { + return x.Low + } + return 0 +} + +func (x *HyperliquidLaunchCandle) GetClose() float32 { + if x != nil { + return x.Close + } + return 0 +} + +func (x *HyperliquidLaunchCandle) GetVolume() float32 { + if x != nil { + return x.Volume + } + return 0 +} + +type HyperliquidLaunchCandlesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Candles []*HyperliquidLaunchCandle `protobuf:"bytes,1,rep,name=candles,proto3" json:"candles,omitempty"` +} + +func (x *HyperliquidLaunchCandlesResponse) Reset() { + *x = HyperliquidLaunchCandlesResponse{} + mi := &file_hypurr_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchCandlesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchCandlesResponse) ProtoMessage() {} + +func (x *HyperliquidLaunchCandlesResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[49] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchCandlesResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchCandlesResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{49} +} + +func (x *HyperliquidLaunchCandlesResponse) GetCandles() []*HyperliquidLaunchCandle { + if x != nil { + return x.Candles + } + return nil +} + +type HyperliquidLaunchRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *HyperliquidLaunchRequest) Reset() { + *x = HyperliquidLaunchRequest{} + mi := &file_hypurr_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchRequest) ProtoMessage() {} + +func (x *HyperliquidLaunchRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[50] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{50} +} + +func (x *HyperliquidLaunchRequest) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type HyperliquidLaunchResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Launch *HyperliquidLaunch `protobuf:"bytes,1,opt,name=launch,proto3" json:"launch,omitempty"` +} + +func (x *HyperliquidLaunchResponse) Reset() { + *x = HyperliquidLaunchResponse{} + mi := &file_hypurr_proto_msgTypes[51] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchResponse) ProtoMessage() {} + +func (x *HyperliquidLaunchResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[51] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{51} +} + +func (x *HyperliquidLaunchResponse) GetLaunch() *HyperliquidLaunch { + if x != nil { + return x.Launch + } + return nil +} + +type HyperliquidLaunchMessage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Timestamp int64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + LaunchId int64 `protobuf:"varint,3,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` + TelegramId int64 `protobuf:"varint,4,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + Author *TelegramUserPublic `protobuf:"bytes,5,opt,name=author,proto3" json:"author,omitempty"` + ChatId int64 `protobuf:"varint,6,opt,name=chat_id,json=chatId,proto3" json:"chat_id,omitempty"` + TopicId int64 `protobuf:"varint,7,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"` + Message string `protobuf:"bytes,8,opt,name=message,proto3" json:"message,omitempty"` +} + +func (x *HyperliquidLaunchMessage) Reset() { + *x = HyperliquidLaunchMessage{} + mi := &file_hypurr_proto_msgTypes[52] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchMessage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchMessage) ProtoMessage() {} + +func (x *HyperliquidLaunchMessage) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[52] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchMessage.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchMessage) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{52} +} + +func (x *HyperliquidLaunchMessage) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HyperliquidLaunchMessage) GetTimestamp() int64 { + if x != nil { + return x.Timestamp + } + return 0 +} + +func (x *HyperliquidLaunchMessage) GetLaunchId() int64 { + if x != nil { + return x.LaunchId + } + return 0 +} + +func (x *HyperliquidLaunchMessage) GetTelegramId() int64 { + if x != nil { + return x.TelegramId + } + return 0 +} + +func (x *HyperliquidLaunchMessage) GetAuthor() *TelegramUserPublic { + if x != nil { + return x.Author + } + return nil +} + +func (x *HyperliquidLaunchMessage) GetChatId() int64 { + if x != nil { + return x.ChatId + } + return 0 +} + +func (x *HyperliquidLaunchMessage) GetTopicId() int64 { + if x != nil { + return x.TopicId + } + return 0 +} + +func (x *HyperliquidLaunchMessage) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type HyperliquidLaunchMessagesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + LaunchId int64 `protobuf:"varint,1,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` +} + +func (x *HyperliquidLaunchMessagesRequest) Reset() { + *x = HyperliquidLaunchMessagesRequest{} + mi := &file_hypurr_proto_msgTypes[53] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchMessagesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchMessagesRequest) ProtoMessage() {} + +func (x *HyperliquidLaunchMessagesRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[53] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchMessagesRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchMessagesRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{53} +} + +func (x *HyperliquidLaunchMessagesRequest) GetLaunchId() int64 { + if x != nil { + return x.LaunchId + } + return 0 +} + +type HyperliquidLaunchMessagesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Messages []*HyperliquidLaunchMessage `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"` +} + +func (x *HyperliquidLaunchMessagesResponse) Reset() { + *x = HyperliquidLaunchMessagesResponse{} + mi := &file_hypurr_proto_msgTypes[54] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchMessagesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchMessagesResponse) ProtoMessage() {} + +func (x *HyperliquidLaunchMessagesResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[54] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchMessagesResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchMessagesResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{54} +} + +func (x *HyperliquidLaunchMessagesResponse) GetMessages() []*HyperliquidLaunchMessage { + if x != nil { + return x.Messages + } + return nil +} + +type HyperliquidLaunchHolder struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Balance int64 `protobuf:"varint,1,opt,name=balance,proto3" json:"balance,omitempty"` + Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` + Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"` +} + +func (x *HyperliquidLaunchHolder) Reset() { + *x = HyperliquidLaunchHolder{} + mi := &file_hypurr_proto_msgTypes[55] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchHolder) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchHolder) ProtoMessage() {} + +func (x *HyperliquidLaunchHolder) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[55] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchHolder.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchHolder) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{55} +} + +func (x *HyperliquidLaunchHolder) GetBalance() int64 { + if x != nil { + return x.Balance + } + return 0 +} + +func (x *HyperliquidLaunchHolder) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *HyperliquidLaunchHolder) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +type HyperliquidLaunchHoldersRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + LaunchId int64 `protobuf:"varint,1,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` +} + +func (x *HyperliquidLaunchHoldersRequest) Reset() { + *x = HyperliquidLaunchHoldersRequest{} + mi := &file_hypurr_proto_msgTypes[56] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchHoldersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchHoldersRequest) ProtoMessage() {} + +func (x *HyperliquidLaunchHoldersRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[56] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchHoldersRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchHoldersRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{56} +} + +func (x *HyperliquidLaunchHoldersRequest) GetLaunchId() int64 { + if x != nil { + return x.LaunchId + } + return 0 +} + +type HyperliquidLaunchHoldersResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Holders []*HyperliquidLaunchHolder `protobuf:"bytes,1,rep,name=holders,proto3" json:"holders,omitempty"` +} + +func (x *HyperliquidLaunchHoldersResponse) Reset() { + *x = HyperliquidLaunchHoldersResponse{} + mi := &file_hypurr_proto_msgTypes[57] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchHoldersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchHoldersResponse) ProtoMessage() {} + +func (x *HyperliquidLaunchHoldersResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[57] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchHoldersResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchHoldersResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{57} +} + +func (x *HyperliquidLaunchHoldersResponse) GetHolders() []*HyperliquidLaunchHolder { + if x != nil { + return x.Holders + } + return nil +} + +type LatestHyperliquidLaunchFillsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *LatestHyperliquidLaunchFillsRequest) Reset() { + *x = LatestHyperliquidLaunchFillsRequest{} + mi := &file_hypurr_proto_msgTypes[58] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LatestHyperliquidLaunchFillsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LatestHyperliquidLaunchFillsRequest) ProtoMessage() {} + +func (x *LatestHyperliquidLaunchFillsRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[58] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LatestHyperliquidLaunchFillsRequest.ProtoReflect.Descriptor instead. +func (*LatestHyperliquidLaunchFillsRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{58} +} + +type TelegramUser struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TelegramId int64 `protobuf:"varint,1,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + TelegramUsername string `protobuf:"bytes,2,opt,name=telegram_username,json=telegramUsername,proto3" json:"telegram_username,omitempty"` + PendingFees float64 `protobuf:"fixed64,3,opt,name=pending_fees,json=pendingFees,proto3" json:"pending_fees,omitempty"` + ReferralRewards float64 `protobuf:"fixed64,4,opt,name=referral_rewards,json=referralRewards,proto3" json:"referral_rewards,omitempty"` + ReferralCode string `protobuf:"bytes,5,opt,name=referral_code,json=referralCode,proto3" json:"referral_code,omitempty"` + ReferralScore int64 `protobuf:"varint,6,opt,name=referral_score,json=referralScore,proto3" json:"referral_score,omitempty"` + ReferrerId int64 `protobuf:"varint,7,opt,name=referrer_id,json=referrerId,proto3" json:"referrer_id,omitempty"` + Settings *TelegramUserSettings `protobuf:"bytes,8,opt,name=settings,proto3" json:"settings,omitempty"` + Wallet *HyperliquidWallet `protobuf:"bytes,9,opt,name=wallet,proto3" json:"wallet,omitempty"` + Wallets []*HyperliquidWallet `protobuf:"bytes,10,rep,name=wallets,proto3" json:"wallets,omitempty"` + WalletId int64 `protobuf:"varint,11,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + SniperWallet *HyperliquidWallet `protobuf:"bytes,12,opt,name=sniper_wallet,json=sniperWallet,proto3" json:"sniper_wallet,omitempty"` + SniperWalletId int64 `protobuf:"varint,13,opt,name=sniper_wallet_id,json=sniperWalletId,proto3" json:"sniper_wallet_id,omitempty"` + DumperWallet *HyperliquidWallet `protobuf:"bytes,14,opt,name=dumper_wallet,json=dumperWallet,proto3" json:"dumper_wallet,omitempty"` + DumperWalletId int64 `protobuf:"varint,15,opt,name=dumper_wallet_id,json=dumperWalletId,proto3" json:"dumper_wallet_id,omitempty"` + ReputationId int64 `protobuf:"varint,16,opt,name=reputation_id,json=reputationId,proto3" json:"reputation_id,omitempty"` + Reputation *TelegramUserReputation `protobuf:"bytes,17,opt,name=reputation,proto3" json:"reputation,omitempty"` + Launches []*HyperliquidLaunch `protobuf:"bytes,18,rep,name=launches,proto3" json:"launches,omitempty"` + Balances []*HyperliquidWalletBalance `protobuf:"bytes,19,rep,name=balances,proto3" json:"balances,omitempty"` + Movements []*HyperliquidWalletMovement `protobuf:"bytes,20,rep,name=movements,proto3" json:"movements,omitempty"` + LaunchFills []*HyperliquidLaunchFill `protobuf:"bytes,21,rep,name=launch_fills,json=launchFills,proto3" json:"launch_fills,omitempty"` + Labels []*HyperliquidWalletLabel `protobuf:"bytes,22,rep,name=labels,proto3" json:"labels,omitempty"` +} + +func (x *TelegramUser) Reset() { + *x = TelegramUser{} + mi := &file_hypurr_proto_msgTypes[59] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TelegramUser) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TelegramUser) ProtoMessage() {} + +func (x *TelegramUser) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[59] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TelegramUser.ProtoReflect.Descriptor instead. +func (*TelegramUser) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{59} +} + +func (x *TelegramUser) GetTelegramId() int64 { + if x != nil { + return x.TelegramId + } + return 0 +} + +func (x *TelegramUser) GetTelegramUsername() string { + if x != nil { + return x.TelegramUsername + } + return "" +} + +func (x *TelegramUser) GetPendingFees() float64 { + if x != nil { + return x.PendingFees + } + return 0 +} + +func (x *TelegramUser) GetReferralRewards() float64 { + if x != nil { + return x.ReferralRewards + } + return 0 +} + +func (x *TelegramUser) GetReferralCode() string { + if x != nil { + return x.ReferralCode + } + return "" +} + +func (x *TelegramUser) GetReferralScore() int64 { + if x != nil { + return x.ReferralScore + } + return 0 +} + +func (x *TelegramUser) GetReferrerId() int64 { + if x != nil { + return x.ReferrerId + } + return 0 +} + +func (x *TelegramUser) GetSettings() *TelegramUserSettings { + if x != nil { + return x.Settings + } + return nil +} + +func (x *TelegramUser) GetWallet() *HyperliquidWallet { + if x != nil { + return x.Wallet + } + return nil +} + +func (x *TelegramUser) GetWallets() []*HyperliquidWallet { + if x != nil { + return x.Wallets + } + return nil +} + +func (x *TelegramUser) GetWalletId() int64 { + if x != nil { + return x.WalletId + } + return 0 +} + +func (x *TelegramUser) GetSniperWallet() *HyperliquidWallet { + if x != nil { + return x.SniperWallet + } + return nil +} + +func (x *TelegramUser) GetSniperWalletId() int64 { + if x != nil { + return x.SniperWalletId + } + return 0 +} + +func (x *TelegramUser) GetDumperWallet() *HyperliquidWallet { + if x != nil { + return x.DumperWallet + } + return nil +} + +func (x *TelegramUser) GetDumperWalletId() int64 { + if x != nil { + return x.DumperWalletId + } + return 0 +} + +func (x *TelegramUser) GetReputationId() int64 { + if x != nil { + return x.ReputationId + } + return 0 +} + +func (x *TelegramUser) GetReputation() *TelegramUserReputation { + if x != nil { + return x.Reputation + } + return nil +} + +func (x *TelegramUser) GetLaunches() []*HyperliquidLaunch { + if x != nil { + return x.Launches + } + return nil +} + +func (x *TelegramUser) GetBalances() []*HyperliquidWalletBalance { + if x != nil { + return x.Balances + } + return nil +} + +func (x *TelegramUser) GetMovements() []*HyperliquidWalletMovement { + if x != nil { + return x.Movements + } + return nil +} + +func (x *TelegramUser) GetLaunchFills() []*HyperliquidLaunchFill { + if x != nil { + return x.LaunchFills + } + return nil +} + +func (x *TelegramUser) GetLabels() []*HyperliquidWalletLabel { + if x != nil { + return x.Labels + } + return nil +} + +type TelegramUserSettings struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *TelegramUserSettings) Reset() { + *x = TelegramUserSettings{} + mi := &file_hypurr_proto_msgTypes[60] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TelegramUserSettings) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TelegramUserSettings) ProtoMessage() {} + +func (x *TelegramUserSettings) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[60] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TelegramUserSettings.ProtoReflect.Descriptor instead. +func (*TelegramUserSettings) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{60} +} + +type TelegramUserReputation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *TelegramUserReputation) Reset() { + *x = TelegramUserReputation{} + mi := &file_hypurr_proto_msgTypes[61] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TelegramUserReputation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TelegramUserReputation) ProtoMessage() {} + +func (x *TelegramUserReputation) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[61] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TelegramUserReputation.ProtoReflect.Descriptor instead. +func (*TelegramUserReputation) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{61} +} + +type HyperliquidWalletLabel struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EthereumAddress string `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"` + Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"` +} + +func (x *HyperliquidWalletLabel) Reset() { + *x = HyperliquidWalletLabel{} + mi := &file_hypurr_proto_msgTypes[62] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletLabel) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletLabel) ProtoMessage() {} + +func (x *HyperliquidWalletLabel) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[62] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletLabel.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletLabel) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{62} +} + +func (x *HyperliquidWalletLabel) GetEthereumAddress() string { + if x != nil { + return x.EthereumAddress + } + return "" +} + +func (x *HyperliquidWalletLabel) GetLabel() string { + if x != nil { + return x.Label + } + return "" +} + +type HyperliquidWalletDeploySessionGenesis struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Target string `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"` + Share int32 `protobuf:"varint,2,opt,name=share,proto3" json:"share,omitempty"` +} + +func (x *HyperliquidWalletDeploySessionGenesis) Reset() { + *x = HyperliquidWalletDeploySessionGenesis{} + mi := &file_hypurr_proto_msgTypes[63] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletDeploySessionGenesis) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletDeploySessionGenesis) ProtoMessage() {} + +func (x *HyperliquidWalletDeploySessionGenesis) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[63] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletDeploySessionGenesis.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletDeploySessionGenesis) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{63} +} + +func (x *HyperliquidWalletDeploySessionGenesis) GetTarget() string { + if x != nil { + return x.Target + } + return "" +} + +func (x *HyperliquidWalletDeploySessionGenesis) GetShare() int32 { + if x != nil { + return x.Share + } + return 0 +} + +type HyperliquidWalletPerformanceRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EthereumAddress *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=ethereum_address,json=ethereumAddress,proto3" json:"ethereum_address,omitempty"` + AccountType string `protobuf:"bytes,2,opt,name=account_type,json=accountType,proto3" json:"account_type,omitempty"` +} + +func (x *HyperliquidWalletPerformanceRequest) Reset() { + *x = HyperliquidWalletPerformanceRequest{} + mi := &file_hypurr_proto_msgTypes[64] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletPerformanceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletPerformanceRequest) ProtoMessage() {} + +func (x *HyperliquidWalletPerformanceRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[64] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletPerformanceRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletPerformanceRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{64} +} + +func (x *HyperliquidWalletPerformanceRequest) GetEthereumAddress() *wrapperspb.StringValue { + if x != nil { + return x.EthereumAddress + } + return nil +} + +func (x *HyperliquidWalletPerformanceRequest) GetAccountType() string { + if x != nil { + return x.AccountType + } + return "" +} + +type PerformancePoint struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Time int64 `protobuf:"varint,1,opt,name=time,proto3" json:"time,omitempty"` + Notional float32 `protobuf:"fixed32,2,opt,name=notional,proto3" json:"notional,omitempty"` + Pnl float32 `protobuf:"fixed32,3,opt,name=pnl,proto3" json:"pnl,omitempty"` +} + +func (x *PerformancePoint) Reset() { + *x = PerformancePoint{} + mi := &file_hypurr_proto_msgTypes[65] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PerformancePoint) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PerformancePoint) ProtoMessage() {} + +func (x *PerformancePoint) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[65] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PerformancePoint.ProtoReflect.Descriptor instead. +func (*PerformancePoint) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{65} +} + +func (x *PerformancePoint) GetTime() int64 { + if x != nil { + return x.Time + } + return 0 +} + +func (x *PerformancePoint) GetNotional() float32 { + if x != nil { + return x.Notional + } + return 0 +} + +func (x *PerformancePoint) GetPnl() float32 { + if x != nil { + return x.Pnl + } + return 0 +} + +type PerformanceReport struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TokenId int64 `protobuf:"varint,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"` + TotalPnl float32 `protobuf:"fixed32,2,opt,name=total_pnl,json=totalPnl,proto3" json:"total_pnl,omitempty"` + RunningPnl float32 `protobuf:"fixed32,3,opt,name=running_pnl,json=runningPnl,proto3" json:"running_pnl,omitempty"` + Size float32 `protobuf:"fixed32,4,opt,name=size,proto3" json:"size,omitempty"` + Price float32 `protobuf:"fixed32,5,opt,name=price,proto3" json:"price,omitempty"` + EntryPrice float32 `protobuf:"fixed32,6,opt,name=entry_price,json=entryPrice,proto3" json:"entry_price,omitempty"` + TotalCost float32 `protobuf:"fixed32,7,opt,name=total_cost,json=totalCost,proto3" json:"total_cost,omitempty"` + RunningCost float32 `protobuf:"fixed32,8,opt,name=running_cost,json=runningCost,proto3" json:"running_cost,omitempty"` +} + +func (x *PerformanceReport) Reset() { + *x = PerformanceReport{} + mi := &file_hypurr_proto_msgTypes[66] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PerformanceReport) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PerformanceReport) ProtoMessage() {} + +func (x *PerformanceReport) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[66] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PerformanceReport.ProtoReflect.Descriptor instead. +func (*PerformanceReport) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{66} +} + +func (x *PerformanceReport) GetTokenId() int64 { + if x != nil { + return x.TokenId + } + return 0 +} + +func (x *PerformanceReport) GetTotalPnl() float32 { + if x != nil { + return x.TotalPnl + } + return 0 +} + +func (x *PerformanceReport) GetRunningPnl() float32 { + if x != nil { + return x.RunningPnl + } + return 0 +} + +func (x *PerformanceReport) GetSize() float32 { + if x != nil { + return x.Size + } + return 0 +} + +func (x *PerformanceReport) GetPrice() float32 { + if x != nil { + return x.Price + } + return 0 +} + +func (x *PerformanceReport) GetEntryPrice() float32 { + if x != nil { + return x.EntryPrice + } + return 0 +} + +func (x *PerformanceReport) GetTotalCost() float32 { + if x != nil { + return x.TotalCost + } + return 0 +} + +func (x *PerformanceReport) GetRunningCost() float32 { + if x != nil { + return x.RunningCost + } + return 0 +} + +type Performance struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + NetCash float32 `protobuf:"fixed32,1,opt,name=net_cash,json=netCash,proto3" json:"net_cash,omitempty"` + Notional float32 `protobuf:"fixed32,2,opt,name=notional,proto3" json:"notional,omitempty"` + Reports []*PerformanceReport `protobuf:"bytes,3,rep,name=reports,proto3" json:"reports,omitempty"` + Points []*PerformancePoint `protobuf:"bytes,4,rep,name=points,proto3" json:"points,omitempty"` +} + +func (x *Performance) Reset() { + *x = Performance{} + mi := &file_hypurr_proto_msgTypes[67] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Performance) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Performance) ProtoMessage() {} + +func (x *Performance) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[67] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Performance.ProtoReflect.Descriptor instead. +func (*Performance) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{67} +} + +func (x *Performance) GetNetCash() float32 { + if x != nil { + return x.NetCash + } + return 0 +} + +func (x *Performance) GetNotional() float32 { + if x != nil { + return x.Notional + } + return 0 +} + +func (x *Performance) GetReports() []*PerformanceReport { + if x != nil { + return x.Reports + } + return nil +} + +func (x *Performance) GetPoints() []*PerformancePoint { + if x != nil { + return x.Points + } + return nil +} + +type HyperliquidWalletPerformanceResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Spot *Performance `protobuf:"bytes,1,opt,name=spot,proto3" json:"spot,omitempty"` + Perp *Performance `protobuf:"bytes,2,opt,name=perp,proto3" json:"perp,omitempty"` + Launch *Performance `protobuf:"bytes,3,opt,name=launch,proto3" json:"launch,omitempty"` +} + +func (x *HyperliquidWalletPerformanceResponse) Reset() { + *x = HyperliquidWalletPerformanceResponse{} + mi := &file_hypurr_proto_msgTypes[68] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidWalletPerformanceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidWalletPerformanceResponse) ProtoMessage() {} + +func (x *HyperliquidWalletPerformanceResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[68] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidWalletPerformanceResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidWalletPerformanceResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{68} +} + +func (x *HyperliquidWalletPerformanceResponse) GetSpot() *Performance { + if x != nil { + return x.Spot + } + return nil +} + +func (x *HyperliquidWalletPerformanceResponse) GetPerp() *Performance { + if x != nil { + return x.Perp + } + return nil +} + +func (x *HyperliquidWalletPerformanceResponse) GetLaunch() *Performance { + if x != nil { + return x.Launch + } + return nil +} + +type HypurrFunCabal struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TelegramChatId int64 `protobuf:"varint,1,opt,name=telegram_chat_id,json=telegramChatId,proto3" json:"telegram_chat_id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + PictureFileId string `protobuf:"bytes,3,opt,name=picture_file_id,json=pictureFileId,proto3" json:"picture_file_id,omitempty"` + Users []*HypurrFunCabalUser `protobuf:"bytes,4,rep,name=users,proto3" json:"users,omitempty"` + TrackedWallets []*HypurrFunCabalTrackedWallet `protobuf:"bytes,5,rep,name=tracked_wallets,json=trackedWallets,proto3" json:"tracked_wallets,omitempty"` + UserSeasons []*HypurrFunCabalUserSeason `protobuf:"bytes,6,rep,name=user_seasons,json=userSeasons,proto3" json:"user_seasons,omitempty"` + Summary *HypurrFunCabalSummary `protobuf:"bytes,7,opt,name=summary,proto3" json:"summary,omitempty"` +} + +func (x *HypurrFunCabal) Reset() { + *x = HypurrFunCabal{} + mi := &file_hypurr_proto_msgTypes[69] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HypurrFunCabal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HypurrFunCabal) ProtoMessage() {} + +func (x *HypurrFunCabal) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[69] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HypurrFunCabal.ProtoReflect.Descriptor instead. +func (*HypurrFunCabal) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{69} +} + +func (x *HypurrFunCabal) GetTelegramChatId() int64 { + if x != nil { + return x.TelegramChatId + } + return 0 +} + +func (x *HypurrFunCabal) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *HypurrFunCabal) GetPictureFileId() string { + if x != nil { + return x.PictureFileId + } + return "" +} + +func (x *HypurrFunCabal) GetUsers() []*HypurrFunCabalUser { + if x != nil { + return x.Users + } + return nil +} + +func (x *HypurrFunCabal) GetTrackedWallets() []*HypurrFunCabalTrackedWallet { + if x != nil { + return x.TrackedWallets + } + return nil +} + +func (x *HypurrFunCabal) GetUserSeasons() []*HypurrFunCabalUserSeason { + if x != nil { + return x.UserSeasons + } + return nil +} + +func (x *HypurrFunCabal) GetSummary() *HypurrFunCabalSummary { + if x != nil { + return x.Summary + } + return nil +} + +type HypurrFunCabalSummary struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserCount int64 `protobuf:"varint,1,opt,name=user_count,json=userCount,proto3" json:"user_count,omitempty"` + SeasonSpotPnl float64 `protobuf:"fixed64,2,opt,name=season_spot_pnl,json=seasonSpotPnl,proto3" json:"season_spot_pnl,omitempty"` + SeasonPerpPnl float64 `protobuf:"fixed64,3,opt,name=season_perp_pnl,json=seasonPerpPnl,proto3" json:"season_perp_pnl,omitempty"` + SeasonLaunchPnl float64 `protobuf:"fixed64,4,opt,name=season_launch_pnl,json=seasonLaunchPnl,proto3" json:"season_launch_pnl,omitempty"` +} + +func (x *HypurrFunCabalSummary) Reset() { + *x = HypurrFunCabalSummary{} + mi := &file_hypurr_proto_msgTypes[70] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HypurrFunCabalSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HypurrFunCabalSummary) ProtoMessage() {} + +func (x *HypurrFunCabalSummary) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[70] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HypurrFunCabalSummary.ProtoReflect.Descriptor instead. +func (*HypurrFunCabalSummary) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{70} +} + +func (x *HypurrFunCabalSummary) GetUserCount() int64 { + if x != nil { + return x.UserCount + } + return 0 +} + +func (x *HypurrFunCabalSummary) GetSeasonSpotPnl() float64 { + if x != nil { + return x.SeasonSpotPnl + } + return 0 +} + +func (x *HypurrFunCabalSummary) GetSeasonPerpPnl() float64 { + if x != nil { + return x.SeasonPerpPnl + } + return 0 +} + +func (x *HypurrFunCabalSummary) GetSeasonLaunchPnl() float64 { + if x != nil { + return x.SeasonLaunchPnl + } + return 0 +} + +type HypurrFunCabalUser struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TelegramChatId int64 `protobuf:"varint,1,opt,name=telegram_chat_id,json=telegramChatId,proto3" json:"telegram_chat_id,omitempty"` + TelegramId int64 `protobuf:"varint,2,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + Wallet *HyperliquidWallet `protobuf:"bytes,3,opt,name=wallet,proto3" json:"wallet,omitempty"` + WalletId int64 `protobuf:"varint,4,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + Name string `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"` + SpotPnl float64 `protobuf:"fixed64,6,opt,name=spot_pnl,json=spotPnl,proto3" json:"spot_pnl,omitempty"` + SpotEquity float64 `protobuf:"fixed64,7,opt,name=spot_equity,json=spotEquity,proto3" json:"spot_equity,omitempty"` + LaunchPnl float64 `protobuf:"fixed64,8,opt,name=launch_pnl,json=launchPnl,proto3" json:"launch_pnl,omitempty"` + LaunchEquity float64 `protobuf:"fixed64,9,opt,name=launch_equity,json=launchEquity,proto3" json:"launch_equity,omitempty"` + PerpPnl float64 `protobuf:"fixed64,10,opt,name=perp_pnl,json=perpPnl,proto3" json:"perp_pnl,omitempty"` + PerpEquity float64 `protobuf:"fixed64,11,opt,name=perp_equity,json=perpEquity,proto3" json:"perp_equity,omitempty"` +} + +func (x *HypurrFunCabalUser) Reset() { + *x = HypurrFunCabalUser{} + mi := &file_hypurr_proto_msgTypes[71] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HypurrFunCabalUser) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HypurrFunCabalUser) ProtoMessage() {} + +func (x *HypurrFunCabalUser) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[71] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HypurrFunCabalUser.ProtoReflect.Descriptor instead. +func (*HypurrFunCabalUser) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{71} +} + +func (x *HypurrFunCabalUser) GetTelegramChatId() int64 { + if x != nil { + return x.TelegramChatId + } + return 0 +} + +func (x *HypurrFunCabalUser) GetTelegramId() int64 { + if x != nil { + return x.TelegramId + } + return 0 +} + +func (x *HypurrFunCabalUser) GetWallet() *HyperliquidWallet { + if x != nil { + return x.Wallet + } + return nil +} + +func (x *HypurrFunCabalUser) GetWalletId() int64 { + if x != nil { + return x.WalletId + } + return 0 +} + +func (x *HypurrFunCabalUser) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *HypurrFunCabalUser) GetSpotPnl() float64 { + if x != nil { + return x.SpotPnl + } + return 0 +} + +func (x *HypurrFunCabalUser) GetSpotEquity() float64 { + if x != nil { + return x.SpotEquity + } + return 0 +} + +func (x *HypurrFunCabalUser) GetLaunchPnl() float64 { + if x != nil { + return x.LaunchPnl + } + return 0 +} + +func (x *HypurrFunCabalUser) GetLaunchEquity() float64 { + if x != nil { + return x.LaunchEquity + } + return 0 +} + +func (x *HypurrFunCabalUser) GetPerpPnl() float64 { + if x != nil { + return x.PerpPnl + } + return 0 +} + +func (x *HypurrFunCabalUser) GetPerpEquity() float64 { + if x != nil { + return x.PerpEquity + } + return 0 +} + +type HypurrFunCabalTrackedWallet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TelegramChatId int64 `protobuf:"varint,1,opt,name=telegram_chat_id,json=telegramChatId,proto3" json:"telegram_chat_id,omitempty"` + WalletId int64 `protobuf:"varint,2,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + Wallet *HyperliquidWallet `protobuf:"bytes,3,opt,name=wallet,proto3" json:"wallet,omitempty"` + Label string `protobuf:"bytes,4,opt,name=label,proto3" json:"label,omitempty"` + AlertSpot bool `protobuf:"varint,5,opt,name=alert_spot,json=alertSpot,proto3" json:"alert_spot,omitempty"` + AlertPerp bool `protobuf:"varint,6,opt,name=alert_perp,json=alertPerp,proto3" json:"alert_perp,omitempty"` +} + +func (x *HypurrFunCabalTrackedWallet) Reset() { + *x = HypurrFunCabalTrackedWallet{} + mi := &file_hypurr_proto_msgTypes[72] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HypurrFunCabalTrackedWallet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HypurrFunCabalTrackedWallet) ProtoMessage() {} + +func (x *HypurrFunCabalTrackedWallet) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[72] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HypurrFunCabalTrackedWallet.ProtoReflect.Descriptor instead. +func (*HypurrFunCabalTrackedWallet) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{72} +} + +func (x *HypurrFunCabalTrackedWallet) GetTelegramChatId() int64 { + if x != nil { + return x.TelegramChatId + } + return 0 +} + +func (x *HypurrFunCabalTrackedWallet) GetWalletId() int64 { + if x != nil { + return x.WalletId + } + return 0 +} + +func (x *HypurrFunCabalTrackedWallet) GetWallet() *HyperliquidWallet { + if x != nil { + return x.Wallet + } + return nil +} + +func (x *HypurrFunCabalTrackedWallet) GetLabel() string { + if x != nil { + return x.Label + } + return "" +} + +func (x *HypurrFunCabalTrackedWallet) GetAlertSpot() bool { + if x != nil { + return x.AlertSpot + } + return false +} + +func (x *HypurrFunCabalTrackedWallet) GetAlertPerp() bool { + if x != nil { + return x.AlertPerp + } + return false +} + +type HypurrFunCabalSeason struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + StartTime int64 `protobuf:"varint,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + EndTime int64 `protobuf:"varint,3,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + UserSeasons []*HypurrFunCabalUserSeason `protobuf:"bytes,5,rep,name=user_seasons,json=userSeasons,proto3" json:"user_seasons,omitempty"` + WinnerId *wrapperspb.Int64Value `protobuf:"bytes,6,opt,name=winner_id,json=winnerId,proto3" json:"winner_id,omitempty"` + Winner *HypurrFunCabal `protobuf:"bytes,7,opt,name=winner,proto3" json:"winner,omitempty"` +} + +func (x *HypurrFunCabalSeason) Reset() { + *x = HypurrFunCabalSeason{} + mi := &file_hypurr_proto_msgTypes[73] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HypurrFunCabalSeason) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HypurrFunCabalSeason) ProtoMessage() {} + +func (x *HypurrFunCabalSeason) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[73] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HypurrFunCabalSeason.ProtoReflect.Descriptor instead. +func (*HypurrFunCabalSeason) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{73} +} + +func (x *HypurrFunCabalSeason) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *HypurrFunCabalSeason) GetStartTime() int64 { + if x != nil { + return x.StartTime + } + return 0 +} + +func (x *HypurrFunCabalSeason) GetEndTime() int64 { + if x != nil { + return x.EndTime + } + return 0 +} + +func (x *HypurrFunCabalSeason) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *HypurrFunCabalSeason) GetUserSeasons() []*HypurrFunCabalUserSeason { + if x != nil { + return x.UserSeasons + } + return nil +} + +func (x *HypurrFunCabalSeason) GetWinnerId() *wrapperspb.Int64Value { + if x != nil { + return x.WinnerId + } + return nil +} + +func (x *HypurrFunCabalSeason) GetWinner() *HypurrFunCabal { + if x != nil { + return x.Winner + } + return nil +} + +type HypurrFunCabalUserSeason struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CabalSeasonId int64 `protobuf:"varint,1,opt,name=cabal_season_id,json=cabalSeasonId,proto3" json:"cabal_season_id,omitempty"` + TelegramId int64 `protobuf:"varint,2,opt,name=telegram_id,json=telegramId,proto3" json:"telegram_id,omitempty"` + WalletId int64 `protobuf:"varint,3,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + TelegramChatId int64 `protobuf:"varint,4,opt,name=telegram_chat_id,json=telegramChatId,proto3" json:"telegram_chat_id,omitempty"` + SpotPnl float64 `protobuf:"fixed64,5,opt,name=spot_pnl,json=spotPnl,proto3" json:"spot_pnl,omitempty"` + LaunchPnl float64 `protobuf:"fixed64,6,opt,name=launch_pnl,json=launchPnl,proto3" json:"launch_pnl,omitempty"` + PerpPnl float64 `protobuf:"fixed64,7,opt,name=perp_pnl,json=perpPnl,proto3" json:"perp_pnl,omitempty"` + LastSpotPnl float64 `protobuf:"fixed64,8,opt,name=last_spot_pnl,json=lastSpotPnl,proto3" json:"last_spot_pnl,omitempty"` + LastLaunchPnl float64 `protobuf:"fixed64,9,opt,name=last_launch_pnl,json=lastLaunchPnl,proto3" json:"last_launch_pnl,omitempty"` + LastPerpPnl float64 `protobuf:"fixed64,10,opt,name=last_perp_pnl,json=lastPerpPnl,proto3" json:"last_perp_pnl,omitempty"` +} + +func (x *HypurrFunCabalUserSeason) Reset() { + *x = HypurrFunCabalUserSeason{} + mi := &file_hypurr_proto_msgTypes[74] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HypurrFunCabalUserSeason) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HypurrFunCabalUserSeason) ProtoMessage() {} + +func (x *HypurrFunCabalUserSeason) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[74] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HypurrFunCabalUserSeason.ProtoReflect.Descriptor instead. +func (*HypurrFunCabalUserSeason) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{74} +} + +func (x *HypurrFunCabalUserSeason) GetCabalSeasonId() int64 { + if x != nil { + return x.CabalSeasonId + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetTelegramId() int64 { + if x != nil { + return x.TelegramId + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetWalletId() int64 { + if x != nil { + return x.WalletId + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetTelegramChatId() int64 { + if x != nil { + return x.TelegramChatId + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetSpotPnl() float64 { + if x != nil { + return x.SpotPnl + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetLaunchPnl() float64 { + if x != nil { + return x.LaunchPnl + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetPerpPnl() float64 { + if x != nil { + return x.PerpPnl + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetLastSpotPnl() float64 { + if x != nil { + return x.LastSpotPnl + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetLastLaunchPnl() float64 { + if x != nil { + return x.LastLaunchPnl + } + return 0 +} + +func (x *HypurrFunCabalUserSeason) GetLastPerpPnl() float64 { + if x != nil { + return x.LastPerpPnl + } + return 0 +} + +type HypurrFunCabalsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *HypurrFunCabalsRequest) Reset() { + *x = HypurrFunCabalsRequest{} + mi := &file_hypurr_proto_msgTypes[75] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HypurrFunCabalsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HypurrFunCabalsRequest) ProtoMessage() {} + +func (x *HypurrFunCabalsRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[75] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HypurrFunCabalsRequest.ProtoReflect.Descriptor instead. +func (*HypurrFunCabalsRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{75} +} + +type HypurrFunCabalsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Cabals []*HypurrFunCabal `protobuf:"bytes,1,rep,name=cabals,proto3" json:"cabals,omitempty"` +} + +func (x *HypurrFunCabalsResponse) Reset() { + *x = HypurrFunCabalsResponse{} + mi := &file_hypurr_proto_msgTypes[76] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HypurrFunCabalsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HypurrFunCabalsResponse) ProtoMessage() {} + +func (x *HypurrFunCabalsResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[76] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HypurrFunCabalsResponse.ProtoReflect.Descriptor instead. +func (*HypurrFunCabalsResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{76} +} + +func (x *HypurrFunCabalsResponse) GetCabals() []*HypurrFunCabal { + if x != nil { + return x.Cabals + } + return nil +} + +type TelegramUserRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AuthData map[string]string `protobuf:"bytes,1,rep,name=auth_data,json=authData,proto3" json:"auth_data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *TelegramUserRequest) Reset() { + *x = TelegramUserRequest{} + mi := &file_hypurr_proto_msgTypes[77] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TelegramUserRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TelegramUserRequest) ProtoMessage() {} + +func (x *TelegramUserRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[77] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TelegramUserRequest.ProtoReflect.Descriptor instead. +func (*TelegramUserRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{77} +} + +func (x *TelegramUserRequest) GetAuthData() map[string]string { + if x != nil { + return x.AuthData + } + return nil +} + +type TelegramUserResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + User *TelegramUser `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"` +} + +func (x *TelegramUserResponse) Reset() { + *x = TelegramUserResponse{} + mi := &file_hypurr_proto_msgTypes[78] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TelegramUserResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TelegramUserResponse) ProtoMessage() {} + +func (x *TelegramUserResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[78] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TelegramUserResponse.ProtoReflect.Descriptor instead. +func (*TelegramUserResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{78} +} + +func (x *TelegramUserResponse) GetUser() *TelegramUser { + if x != nil { + return x.User + } + return nil +} + +type TelegramUserWalletsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AuthData map[string]string `protobuf:"bytes,1,rep,name=auth_data,json=authData,proto3" json:"auth_data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *TelegramUserWalletsRequest) Reset() { + *x = TelegramUserWalletsRequest{} + mi := &file_hypurr_proto_msgTypes[79] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TelegramUserWalletsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TelegramUserWalletsRequest) ProtoMessage() {} + +func (x *TelegramUserWalletsRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[79] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TelegramUserWalletsRequest.ProtoReflect.Descriptor instead. +func (*TelegramUserWalletsRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{79} +} + +func (x *TelegramUserWalletsRequest) GetAuthData() map[string]string { + if x != nil { + return x.AuthData + } + return nil +} + +type TelegramUserWalletsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Wallets []*HyperliquidWallet `protobuf:"bytes,1,rep,name=wallets,proto3" json:"wallets,omitempty"` +} + +func (x *TelegramUserWalletsResponse) Reset() { + *x = TelegramUserWalletsResponse{} + mi := &file_hypurr_proto_msgTypes[80] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TelegramUserWalletsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TelegramUserWalletsResponse) ProtoMessage() {} + +func (x *TelegramUserWalletsResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[80] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TelegramUserWalletsResponse.ProtoReflect.Descriptor instead. +func (*TelegramUserWalletsResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{80} +} + +func (x *TelegramUserWalletsResponse) GetWallets() []*HyperliquidWallet { + if x != nil { + return x.Wallets + } + return nil +} + +type HyperliquidLaunchTradeRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AuthData map[string]string `protobuf:"bytes,1,rep,name=auth_data,json=authData,proto3" json:"auth_data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + LaunchId int64 `protobuf:"varint,2,opt,name=launch_id,json=launchId,proto3" json:"launch_id,omitempty"` + WalletId int64 `protobuf:"varint,3,opt,name=wallet_id,json=walletId,proto3" json:"wallet_id,omitempty"` + Direction HyperliquidLaunchTradeDirection `protobuf:"varint,4,opt,name=direction,proto3,enum=hypurr.HyperliquidLaunchTradeDirection" json:"direction,omitempty"` + Amount float64 `protobuf:"fixed64,5,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (x *HyperliquidLaunchTradeRequest) Reset() { + *x = HyperliquidLaunchTradeRequest{} + mi := &file_hypurr_proto_msgTypes[81] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchTradeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchTradeRequest) ProtoMessage() {} + +func (x *HyperliquidLaunchTradeRequest) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[81] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchTradeRequest.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchTradeRequest) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{81} +} + +func (x *HyperliquidLaunchTradeRequest) GetAuthData() map[string]string { + if x != nil { + return x.AuthData + } + return nil +} + +func (x *HyperliquidLaunchTradeRequest) GetLaunchId() int64 { + if x != nil { + return x.LaunchId + } + return 0 +} + +func (x *HyperliquidLaunchTradeRequest) GetWalletId() int64 { + if x != nil { + return x.WalletId + } + return 0 +} + +func (x *HyperliquidLaunchTradeRequest) GetDirection() HyperliquidLaunchTradeDirection { + if x != nil { + return x.Direction + } + return HyperliquidLaunchTradeDirection_BUY +} + +func (x *HyperliquidLaunchTradeRequest) GetAmount() float64 { + if x != nil { + return x.Amount + } + return 0 +} + +type HyperliquidLaunchTradeResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BaseAmount float64 `protobuf:"fixed64,1,opt,name=base_amount,json=baseAmount,proto3" json:"base_amount,omitempty"` + QuoteAmount float64 `protobuf:"fixed64,2,opt,name=quote_amount,json=quoteAmount,proto3" json:"quote_amount,omitempty"` + Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"` + Success bool `protobuf:"varint,4,opt,name=success,proto3" json:"success,omitempty"` +} + +func (x *HyperliquidLaunchTradeResponse) Reset() { + *x = HyperliquidLaunchTradeResponse{} + mi := &file_hypurr_proto_msgTypes[82] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HyperliquidLaunchTradeResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HyperliquidLaunchTradeResponse) ProtoMessage() {} + +func (x *HyperliquidLaunchTradeResponse) ProtoReflect() protoreflect.Message { + mi := &file_hypurr_proto_msgTypes[82] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HyperliquidLaunchTradeResponse.ProtoReflect.Descriptor instead. +func (*HyperliquidLaunchTradeResponse) Descriptor() ([]byte, []int) { + return file_hypurr_proto_rawDescGZIP(), []int{82} +} + +func (x *HyperliquidLaunchTradeResponse) GetBaseAmount() float64 { + if x != nil { + return x.BaseAmount + } + return 0 +} + +func (x *HyperliquidLaunchTradeResponse) GetQuoteAmount() float64 { + if x != nil { + return x.QuoteAmount + } + return 0 +} + +func (x *HyperliquidLaunchTradeResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *HyperliquidLaunchTradeResponse) GetSuccess() bool { + if x != nil { + return x.Success + } + return false +} + +var File_hypurr_proto protoreflect.FileDescriptor + +var file_hypurr_proto_rawDesc = []byte{ + 0x0a, 0x0c, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xdc, 0x03, 0x0a, 0x10, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x7a, 0x5f, 0x64, 0x65, 0x63, 0x69, + 0x6d, 0x61, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x7a, 0x44, 0x65, + 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x77, 0x65, 0x69, 0x5f, 0x64, 0x65, + 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x77, 0x65, + 0x69, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x49, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x69, 0x72, 0x63, 0x75, 0x6c, 0x61, 0x74, + 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x11, 0x63, 0x69, 0x72, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x53, 0x75, 0x70, + 0x70, 0x6c, 0x79, 0x12, 0x43, 0x0a, 0x0b, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x5f, 0x69, 0x6e, + 0x66, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, + 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x64, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x39, 0x0a, 0x07, 0x67, 0x65, 0x6e, 0x65, + 0x73, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, + 0x6b, 0x65, 0x6e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, 0x07, 0x67, 0x65, 0x6e, 0x65, + 0x73, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x6c, 0x71, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x68, 0x6c, 0x71, 0x42, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x75, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x42, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x18, + 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x53, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x69, + 0x73, 0x74, 0x69, 0x63, 0x73, 0x22, 0x60, 0x0a, 0x16, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x12, + 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3b, 0x0a, 0x1e, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x49, 0x64, 0x22, 0x5b, 0x0a, 0x1f, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x07, 0x68, 0x6f, 0x6c, 0x64, 0x65, + 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, + 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x52, 0x07, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, + 0x73, 0x22, 0x97, 0x01, 0x0a, 0x1a, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, + 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x68, + 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0b, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3b, + 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x63, 0x6f, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x18, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x43, 0x6f, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x22, 0xf3, 0x02, 0x0a, 0x1a, + 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x67, + 0x69, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x74, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, + 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x54, 0x78, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x74, 0x78, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x53, 0x70, + 0x6f, 0x74, 0x54, 0x78, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, + 0x74, 0x78, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, + 0x73, 0x54, 0x78, 0x12, 0x2b, 0x0a, 0x11, 0x68, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x69, 0x74, 0x79, 0x5f, 0x74, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, + 0x68, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x54, 0x78, + 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x69, 0x70, 0x32, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x68, 0x69, 0x70, 0x32, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, + 0x28, 0x0a, 0x10, 0x68, 0x69, 0x70, 0x32, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x68, 0x69, 0x70, 0x32, 0x4f, + 0x72, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x68, 0x69, 0x70, + 0x32, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x0d, 0x68, 0x69, 0x70, 0x32, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x69, 0x7a, + 0x65, 0x22, 0xbd, 0x01, 0x0a, 0x17, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x19, 0x0a, + 0x08, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x07, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x43, 0x0a, 0x0f, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x52, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x49, + 0x64, 0x22, 0xef, 0x02, 0x0a, 0x13, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x17, 0x0a, + 0x07, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, + 0x62, 0x61, 0x73, 0x65, 0x49, 0x64, 0x12, 0x2c, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x04, + 0x62, 0x61, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x5f, 0x69, 0x64, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x49, 0x64, 0x12, + 0x2e, 0x0a, 0x05, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x05, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x64, 0x5f, 0x70, 0x72, 0x69, + 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x6d, 0x69, 0x64, 0x50, 0x72, 0x69, + 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x6d, 0x61, 0x72, 0x6b, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x12, 0x28, 0x0a, 0x10, 0x64, 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x74, 0x6c, 0x5f, 0x76, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x64, 0x61, 0x69, + 0x6c, 0x79, 0x4e, 0x74, 0x6c, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x70, + 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x64, 0x61, 0x79, 0x5f, 0x70, 0x78, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x44, 0x61, + 0x79, 0x50, 0x78, 0x22, 0xb6, 0x02, 0x0a, 0x13, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x50, 0x65, 0x72, 0x70, 0x50, 0x61, 0x69, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x64, 0x5f, 0x70, 0x72, 0x69, + 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x6d, 0x69, 0x64, 0x50, 0x72, 0x69, + 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x72, 0x6b, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x6d, 0x61, 0x72, 0x6b, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x12, 0x28, 0x0a, 0x10, 0x64, 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x74, 0x6c, 0x5f, 0x76, + 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x64, 0x61, 0x69, + 0x6c, 0x79, 0x4e, 0x74, 0x6c, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x70, + 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x64, 0x61, 0x79, 0x5f, 0x70, 0x78, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x44, 0x61, + 0x79, 0x50, 0x78, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x23, 0x0a, + 0x0d, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x6f, 0x70, 0x65, 0x6e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x65, + 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x65, 0x6d, 0x69, 0x75, 0x6d, 0x18, 0x0a, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x07, 0x70, 0x72, 0x65, 0x6d, 0x69, 0x75, 0x6d, 0x22, 0xc8, 0x03, 0x0a, + 0x11, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3c, 0x0a, 0x0b, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, + 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, + 0x61, 0x6d, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, + 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, + 0x16, 0x0a, 0x06, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x06, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x3f, 0x0a, 0x09, 0x6d, 0x6f, 0x76, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x09, 0x6d, + 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x45, 0x0a, 0x0d, 0x73, 0x70, 0x6f, 0x74, + 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x52, 0x0c, 0x73, 0x70, 0x6f, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, + 0x49, 0x0a, 0x0f, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, + 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x0e, 0x6c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, + 0x5f, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, + 0x41, 0x67, 0x65, 0x6e, 0x74, 0x12, 0x20, 0x0a, 0x0c, 0x69, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, + 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x52, + 0x65, 0x61, 0x64, 0x4f, 0x6e, 0x6c, 0x79, 0x22, 0x44, 0x0a, 0x17, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x57, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5f, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0xc2, 0x03, + 0x0a, 0x19, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, + 0x6c, 0x65, 0x74, 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x3c, 0x0a, 0x0b, 0x74, + 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0a, 0x74, + 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x31, 0x0a, 0x06, 0x77, 0x61, 0x6c, + 0x6c, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x1b, 0x0a, 0x09, + 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x08, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, + 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x12, 0x0a, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x05, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x68, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x16, 0x0a, 0x06, + 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x73, 0x64, 0x63, 0x5f, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x75, 0x73, 0x64, 0x63, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x39, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x22, 0xaa, 0x01, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, + 0x3c, 0x0a, 0x0b, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1b, 0x0a, + 0x09, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x08, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, + 0xac, 0x01, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x3c, 0x0a, 0x0b, + 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0a, + 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x77, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x77, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x9a, + 0x07, 0x0a, 0x1e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x3c, 0x0a, 0x0b, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x73, 0x74, 0x65, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x73, + 0x74, 0x65, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x75, 0x6c, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x25, 0x0a, 0x0e, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, + 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x44, 0x65, + 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, + 0x77, 0x65, 0x69, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x57, 0x65, 0x69, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x73, 0x75, 0x70, + 0x70, 0x6c, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x5f, 0x63, 0x61, 0x70, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x43, 0x61, 0x70, + 0x12, 0x45, 0x0a, 0x10, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x31, 0x5f, 0x74, 0x6f, 0x6b, 0x65, + 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0e, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x31, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x3d, 0x0a, 0x0d, 0x61, 0x6e, 0x63, 0x68, 0x6f, + 0x72, 0x31, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, + 0x31, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x45, 0x0a, 0x10, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, + 0x32, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0e, 0x61, + 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x32, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x3d, 0x0a, + 0x0d, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x32, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x0c, + 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x32, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x36, 0x0a, 0x08, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0c, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x70, 0x61, 0x69, + 0x72, 0x5f, 0x69, 0x64, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x73, 0x70, 0x6f, 0x74, + 0x50, 0x61, 0x69, 0x72, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, + 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x10, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x0f, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, + 0x64, 0x12, 0x4d, 0x0a, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x65, 0x73, 0x18, 0x11, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, + 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x65, 0x73, + 0x1a, 0x69, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x43, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2d, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, + 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xb7, 0x07, 0x0a, 0x11, + 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, + 0x49, 0x64, 0x12, 0x3f, 0x0a, 0x0d, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x75, + 0x73, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x50, + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x52, 0x0c, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, + 0x73, 0x65, 0x72, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x64, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x64, 0x12, 0x18, 0x0a, + 0x07, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, + 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x78, 0x30, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x02, 0x78, 0x30, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x40, 0x0a, 0x07, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, + 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, + 0x07, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x65, 0x64, 0x69, + 0x61, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x46, 0x69, 0x6c, 0x65, 0x49, 0x64, 0x12, 0x36, 0x0a, 0x08, + 0x74, 0x6f, 0x70, 0x69, 0x63, 0x5f, 0x69, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x74, 0x6f, 0x70, + 0x69, 0x63, 0x49, 0x64, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x01, 0x78, 0x12, 0x0c, 0x0a, 0x01, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x79, + 0x12, 0x0c, 0x0a, 0x01, 0x6b, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x6b, 0x12, 0x33, + 0x0a, 0x05, 0x66, 0x69, 0x6c, 0x6c, 0x73, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x52, 0x05, 0x66, 0x69, + 0x6c, 0x6c, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x64, 0x61, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x74, 0x6c, + 0x5f, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x64, + 0x61, 0x69, 0x6c, 0x79, 0x4e, 0x74, 0x6c, 0x56, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x12, 0x26, 0x0a, + 0x0f, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x64, 0x61, 0x79, 0x5f, 0x70, 0x78, + 0x18, 0x11, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, + 0x44, 0x61, 0x79, 0x50, 0x78, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x12, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x3e, 0x0a, 0x09, 0x70, 0x6f, 0x6f, 0x6c, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6f, 0x6f, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x70, + 0x6f, 0x6f, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x63, 0x69, 0x6d, + 0x61, 0x6c, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x64, 0x65, 0x63, 0x69, 0x6d, + 0x61, 0x6c, 0x73, 0x12, 0x46, 0x0a, 0x0e, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x77, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x68, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x0d, 0x73, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, + 0x65, 0x64, 0x69, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x69, + 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x17, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x3e, 0x0a, 0x0a, 0x64, 0x65, 0x76, 0x5f, 0x77, 0x61, 0x6c, + 0x6c, 0x65, 0x74, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x75, + 0x62, 0x6c, 0x69, 0x63, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x09, 0x64, 0x65, 0x76, 0x57, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x22, 0xf9, 0x02, 0x0a, 0x15, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x12, + 0x1b, 0x0a, 0x09, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x08, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, + 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x36, 0x0a, + 0x08, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, + 0x6d, 0x55, 0x73, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x52, 0x08, 0x74, 0x65, 0x6c, + 0x65, 0x67, 0x72, 0x61, 0x6d, 0x12, 0x37, 0x0a, 0x06, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x1d, + 0x0a, 0x0a, 0x75, 0x73, 0x64, 0x63, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x09, 0x75, 0x73, 0x64, 0x63, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x21, 0x0a, + 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x44, 0x65, 0x6c, 0x74, 0x61, + 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x41, + 0x0a, 0x0d, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x52, 0x0c, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, + 0x68, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, + 0x64, 0x22, 0x93, 0x01, 0x0a, 0x12, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, + 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x75, 0x73, 0x65, 0x72, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x75, 0x73, 0x65, 0x72, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0x5f, + 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, + 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x10, + 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x63, 0x6f, 0x72, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x22, 0xe8, 0x01, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x41, 0x75, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x67, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x08, 0x73, 0x74, 0x61, 0x72, 0x74, 0x47, 0x61, 0x73, 0x12, 0x3d, 0x0a, 0x0b, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x67, 0x61, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, + 0x0a, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x47, 0x61, 0x73, 0x12, 0x35, 0x0a, 0x07, 0x65, + 0x6e, 0x64, 0x5f, 0x67, 0x61, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, + 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x65, 0x6e, 0x64, 0x47, + 0x61, 0x73, 0x22, 0x21, 0x0a, 0x1f, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x41, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x5e, 0x0a, 0x20, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x41, 0x75, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x07, 0x61, 0x75, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x44, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x41, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x61, 0x75, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x1a, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x22, 0x4d, 0x0a, 0x19, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, + 0x0a, 0x06, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x06, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, + 0x22, 0x85, 0x02, 0x0a, 0x17, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x0e, 0x0a, 0x02, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1c, 0x0a, 0x09, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, + 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, + 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, + 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x17, 0x0a, 0x07, 0x63, 0x68, + 0x61, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x63, 0x68, 0x61, + 0x74, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x5f, 0x69, 0x64, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x49, 0x64, 0x12, 0x18, + 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3c, 0x0a, 0x1f, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x22, 0x5f, 0x0a, 0x20, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x08, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x68, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x22, 0x2c, 0x0a, 0x1a, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x02, 0x69, 0x64, 0x22, 0x4e, 0x0a, 0x1b, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x04, 0x70, 0x61, 0x69, 0x72, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x52, + 0x04, 0x70, 0x61, 0x69, 0x72, 0x22, 0x1d, 0x0a, 0x1b, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x22, 0x51, 0x0a, 0x1c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, + 0x52, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0x22, 0x1d, 0x0a, 0x1b, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x65, 0x72, 0x70, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x51, 0x0a, 0x1c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x65, 0x72, 0x70, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x65, 0x72, 0x70, 0x50, 0x61, + 0x69, 0x72, 0x52, 0x05, 0x70, 0x61, 0x69, 0x72, 0x73, 0x22, 0x63, 0x0a, 0x18, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x10, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, + 0x6d, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0f, 0x65, + 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x4e, + 0x0a, 0x19, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, + 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x06, 0x77, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x68, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x22, 0x1c, + 0x0a, 0x1a, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x54, 0x0a, 0x1b, + 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x6c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x52, 0x08, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, + 0x65, 0x73, 0x22, 0x5a, 0x0a, 0x1e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x49, 0x64, 0x22, 0x58, + 0x0a, 0x1f, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x35, 0x0a, 0x08, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x52, 0x08, + 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x22, 0xa5, 0x02, 0x0a, 0x26, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x3c, 0x0a, 0x0b, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, + 0x64, 0x12, 0x38, 0x0a, 0x09, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x52, 0x08, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x49, 0x64, 0x12, 0x3a, 0x0a, 0x0a, 0x73, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x09, 0x73, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x47, 0x0a, 0x10, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, + 0x0f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x22, 0x6d, 0x0a, 0x27, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x08, 0x73, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, + 0xda, 0x01, 0x0a, 0x2e, 0x53, 0x65, 0x74, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x47, 0x0a, 0x10, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5f, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0f, 0x65, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x65, 0x22, 0x73, 0x0a, 0x2f, + 0x53, 0x65, 0x74, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x40, 0x0a, 0x07, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x26, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, + 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x22, 0xaf, 0x01, 0x0a, 0x31, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x10, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, + 0x0f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x22, 0x76, 0x0a, 0x32, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x07, 0x73, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x52, 0x07, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x59, 0x0a, 0x1d, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, + 0x46, 0x69, 0x6c, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x09, + 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x49, 0x64, 0x22, 0x96, 0x01, 0x0a, 0x1e, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x05, 0x66, 0x69, 0x6c, + 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, + 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x52, 0x05, 0x66, 0x69, 0x6c, 0x6c, 0x73, 0x12, 0x3f, + 0x0a, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, + 0x63, 0x0a, 0x19, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, + 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, + 0x63, 0x6f, 0x73, 0x74, 0x22, 0x5a, 0x0a, 0x1f, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, + 0x22, 0x95, 0x01, 0x0a, 0x17, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, + 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x04, + 0x6f, 0x70, 0x65, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x02, 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6c, + 0x6f, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x63, 0x6c, 0x6f, 0x73, 0x65, + 0x12, 0x16, 0x0a, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, + 0x52, 0x06, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x22, 0x5d, 0x0a, 0x20, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, + 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x07, + 0x63, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x07, + 0x63, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x22, 0x2a, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x02, 0x69, 0x64, 0x22, 0x4e, 0x0a, 0x19, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x31, 0x0a, 0x06, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x52, 0x06, 0x6c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x22, 0x88, 0x02, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x1b, + 0x0a, 0x09, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x08, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, + 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x06, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x68, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, + 0x65, 0x72, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x12, 0x17, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x06, 0x63, 0x68, 0x61, 0x74, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x70, + 0x69, 0x63, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, 0x70, + 0x69, 0x63, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x3f, + 0x0a, 0x20, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x49, 0x64, 0x22, + 0x61, 0x0a, 0x21, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, 0x0a, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, + 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x73, 0x22, 0x61, 0x0a, 0x17, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x12, 0x18, 0x0a, + 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, + 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3e, 0x0a, 0x1f, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x49, 0x64, 0x22, 0x5d, 0x0a, 0x20, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x07, 0x68, 0x6f, 0x6c, + 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x52, 0x07, 0x68, 0x6f, 0x6c, + 0x64, 0x65, 0x72, 0x73, 0x22, 0x25, 0x0a, 0x23, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, + 0x69, 0x6c, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xbf, 0x08, 0x0a, 0x0c, + 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1f, 0x0a, 0x0b, + 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x2b, 0x0a, + 0x11, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, + 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x65, + 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x0b, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x46, 0x65, 0x65, 0x73, 0x12, 0x29, 0x0a, + 0x10, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x61, + 0x6c, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x72, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x61, 0x6c, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x25, 0x0a, + 0x0e, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x61, 0x6c, 0x5f, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x61, 0x6c, 0x53, + 0x63, 0x6f, 0x72, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x72, + 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x72, 0x65, 0x66, 0x65, 0x72, + 0x72, 0x65, 0x72, 0x49, 0x64, 0x12, 0x38, 0x0a, 0x08, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, + 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, + 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x74, + 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x08, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, + 0x31, 0x0a, 0x06, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x77, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x12, 0x33, 0x0a, 0x07, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x0a, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x07, + 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x77, 0x61, 0x6c, 0x6c, 0x65, + 0x74, 0x5f, 0x69, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x77, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x0d, 0x73, 0x6e, 0x69, 0x70, 0x65, 0x72, 0x5f, 0x77, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x68, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x0c, 0x73, 0x6e, 0x69, 0x70, 0x65, 0x72, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x6e, 0x69, 0x70, 0x65, 0x72, 0x5f, 0x77, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, + 0x73, 0x6e, 0x69, 0x70, 0x65, 0x72, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x49, 0x64, 0x12, 0x3e, + 0x0a, 0x0d, 0x64, 0x75, 0x6d, 0x70, 0x65, 0x72, 0x5f, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, + 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, + 0x52, 0x0c, 0x64, 0x75, 0x6d, 0x70, 0x65, 0x72, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x28, + 0x0a, 0x10, 0x64, 0x75, 0x6d, 0x70, 0x65, 0x72, 0x5f, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, + 0x69, 0x64, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x64, 0x75, 0x6d, 0x70, 0x65, 0x72, + 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x70, 0x75, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0c, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x3e, 0x0a, + 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x11, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, + 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x35, 0x0a, + 0x08, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x52, 0x08, 0x6c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x08, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, + 0x18, 0x13, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, + 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, + 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x08, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x73, 0x12, 0x3f, 0x0a, 0x09, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, + 0x14, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, + 0x4d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x09, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x66, 0x69, + 0x6c, 0x6c, 0x73, 0x18, 0x15, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x52, 0x0b, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, + 0x46, 0x69, 0x6c, 0x6c, 0x73, 0x12, 0x36, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, + 0x16, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, + 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x22, 0x16, 0x0a, + 0x14, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x74, + 0x74, 0x69, 0x6e, 0x67, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, + 0x6d, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0x59, 0x0a, 0x16, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x22, 0x55, 0x0a, 0x25, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, + 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x47, 0x65, 0x6e, 0x65, + 0x73, 0x69, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, + 0x65, 0x22, 0x91, 0x01, 0x0a, 0x23, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, + 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x47, 0x0a, 0x10, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x52, 0x0f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x54, 0x0a, 0x10, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x6e, 0x63, 0x65, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x69, 0x6d, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x1a, 0x0a, + 0x08, 0x6e, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, + 0x08, 0x6e, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x6e, 0x6c, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x03, 0x70, 0x6e, 0x6c, 0x22, 0xf9, 0x01, 0x0a, 0x11, + 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, + 0x74, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x07, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, + 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, + 0x08, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x6e, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x75, 0x6e, + 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, + 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x6e, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, + 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x70, + 0x72, 0x69, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x5f, 0x70, 0x72, + 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0a, 0x65, 0x6e, 0x74, 0x72, 0x79, + 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, + 0x6f, 0x73, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x74, 0x6f, 0x74, 0x61, 0x6c, + 0x43, 0x6f, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x5f, + 0x63, 0x6f, 0x73, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0b, 0x72, 0x75, 0x6e, 0x6e, + 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x73, 0x74, 0x22, 0xab, 0x01, 0x0a, 0x0b, 0x50, 0x65, 0x72, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x74, 0x5f, 0x63, + 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x02, 0x52, 0x07, 0x6e, 0x65, 0x74, 0x43, 0x61, + 0x73, 0x68, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x02, 0x52, 0x08, 0x6e, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x12, 0x33, + 0x0a, 0x07, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x07, 0x72, 0x65, 0x70, 0x6f, + 0x72, 0x74, 0x73, 0x12, 0x30, 0x0a, 0x06, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x50, 0x65, 0x72, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x06, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0xa5, 0x01, 0x0a, 0x24, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x50, 0x65, 0x72, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, + 0x0a, 0x04, 0x73, 0x70, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x68, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, + 0x65, 0x52, 0x04, 0x73, 0x70, 0x6f, 0x74, 0x12, 0x27, 0x0a, 0x04, 0x70, 0x65, 0x72, 0x70, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x50, + 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x04, 0x70, 0x65, 0x72, 0x70, + 0x12, 0x2b, 0x0a, 0x06, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x13, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x06, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x22, 0xf4, 0x02, + 0x0a, 0x0e, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, + 0x12, 0x28, 0x0a, 0x10, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x63, 0x68, 0x61, + 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x74, 0x65, 0x6c, 0x65, + 0x67, 0x72, 0x61, 0x6d, 0x43, 0x68, 0x61, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x26, + 0x0a, 0x0f, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x69, + 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, + 0x46, 0x69, 0x6c, 0x65, 0x49, 0x64, 0x12, 0x30, 0x0a, 0x05, 0x75, 0x73, 0x65, 0x72, 0x73, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x55, 0x73, 0x65, + 0x72, 0x52, 0x05, 0x75, 0x73, 0x65, 0x72, 0x73, 0x12, 0x4c, 0x0a, 0x0f, 0x74, 0x72, 0x61, 0x63, + 0x6b, 0x65, 0x64, 0x5f, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x75, 0x72, + 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x64, + 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x0e, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x57, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x73, + 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x68, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, + 0x61, 0x62, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x52, 0x0b, + 0x75, 0x73, 0x65, 0x72, 0x53, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x12, 0x37, 0x0a, 0x07, 0x73, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x68, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, + 0x61, 0x62, 0x61, 0x6c, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x07, 0x73, 0x75, 0x6d, + 0x6d, 0x61, 0x72, 0x79, 0x22, 0xb2, 0x01, 0x0a, 0x15, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, + 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x1d, + 0x0a, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x09, 0x75, 0x73, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x26, 0x0a, + 0x0f, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x70, 0x6e, 0x6c, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x53, 0x70, + 0x6f, 0x74, 0x50, 0x6e, 0x6c, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x5f, + 0x70, 0x65, 0x72, 0x70, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, + 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x50, 0x65, 0x72, 0x70, 0x50, 0x6e, 0x6c, 0x12, 0x2a, 0x0a, + 0x11, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x5f, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, + 0x6e, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6e, 0x6c, 0x22, 0xff, 0x02, 0x0a, 0x12, 0x48, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x72, + 0x12, 0x28, 0x0a, 0x10, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x63, 0x68, 0x61, + 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x74, 0x65, 0x6c, 0x65, + 0x67, 0x72, 0x61, 0x6d, 0x43, 0x68, 0x61, 0x74, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x65, + 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x31, 0x0a, 0x06, 0x77, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x68, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x1b, + 0x0a, 0x09, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x08, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x19, 0x0a, 0x08, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x07, 0x73, 0x70, 0x6f, 0x74, 0x50, 0x6e, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x70, + 0x6f, 0x74, 0x5f, 0x65, 0x71, 0x75, 0x69, 0x74, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x0a, 0x73, 0x70, 0x6f, 0x74, 0x45, 0x71, 0x75, 0x69, 0x74, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x09, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6e, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x6c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x65, 0x71, 0x75, 0x69, 0x74, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x0c, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x45, 0x71, 0x75, 0x69, 0x74, 0x79, 0x12, + 0x19, 0x0a, 0x08, 0x70, 0x65, 0x72, 0x70, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x01, 0x52, 0x07, 0x70, 0x65, 0x72, 0x70, 0x50, 0x6e, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x65, + 0x72, 0x70, 0x5f, 0x65, 0x71, 0x75, 0x69, 0x74, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x0a, 0x70, 0x65, 0x72, 0x70, 0x45, 0x71, 0x75, 0x69, 0x74, 0x79, 0x22, 0xeb, 0x01, 0x0a, 0x1b, + 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x54, 0x72, + 0x61, 0x63, 0x6b, 0x65, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x74, + 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x63, 0x68, 0x61, 0x74, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x43, + 0x68, 0x61, 0x74, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, + 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, + 0x49, 0x64, 0x12, 0x31, 0x0a, 0x06, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x77, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x1d, 0x0a, 0x0a, 0x61, + 0x6c, 0x65, 0x72, 0x74, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x09, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x53, 0x70, 0x6f, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x6c, + 0x65, 0x72, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x70, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, + 0x61, 0x6c, 0x65, 0x72, 0x74, 0x50, 0x65, 0x72, 0x70, 0x22, 0xa3, 0x02, 0x0a, 0x14, 0x48, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x53, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x12, 0x43, 0x0a, 0x0c, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, + 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, + 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x55, 0x73, + 0x65, 0x72, 0x53, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x52, 0x0b, 0x75, 0x73, 0x65, 0x72, 0x53, 0x65, + 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x12, 0x38, 0x0a, 0x09, 0x77, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x5f, + 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x77, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x64, 0x12, + 0x2e, 0x0a, 0x06, 0x77, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, + 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x52, 0x06, 0x77, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x22, + 0xef, 0x02, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, + 0x61, 0x6c, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x26, 0x0a, 0x0f, + 0x63, 0x61, 0x62, 0x61, 0x6c, 0x5f, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, 0x61, 0x62, 0x61, 0x6c, 0x53, 0x65, 0x61, 0x73, + 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x65, 0x6c, 0x65, 0x67, + 0x72, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, + 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, + 0x49, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x74, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x5f, 0x63, + 0x68, 0x61, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x74, 0x65, + 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x43, 0x68, 0x61, 0x74, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, + 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, + 0x73, 0x70, 0x6f, 0x74, 0x50, 0x6e, 0x6c, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x6c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x50, 0x6e, 0x6c, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x65, 0x72, 0x70, 0x5f, 0x70, + 0x6e, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x70, 0x65, 0x72, 0x70, 0x50, 0x6e, + 0x6c, 0x12, 0x22, 0x0a, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x73, 0x70, 0x6f, 0x74, 0x5f, 0x70, + 0x6e, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x53, 0x70, + 0x6f, 0x74, 0x50, 0x6e, 0x6c, 0x12, 0x26, 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x6c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, + 0x6c, 0x61, 0x73, 0x74, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6e, 0x6c, 0x12, 0x22, 0x0a, + 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x70, 0x5f, 0x70, 0x6e, 0x6c, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x50, 0x65, 0x72, 0x70, 0x50, 0x6e, + 0x6c, 0x22, 0x18, 0x0a, 0x16, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, + 0x62, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x49, 0x0a, 0x17, 0x48, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x63, 0x61, 0x62, 0x61, 0x6c, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, + 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x52, 0x06, + 0x63, 0x61, 0x62, 0x61, 0x6c, 0x73, 0x22, 0x9a, 0x01, 0x0a, 0x13, 0x54, 0x65, 0x6c, 0x65, 0x67, + 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, + 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x29, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, + 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x41, + 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x61, 0x75, + 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x41, 0x75, 0x74, 0x68, 0x44, 0x61, + 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x40, 0x0a, 0x14, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, + 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x75, + 0x73, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x52, + 0x04, 0x75, 0x73, 0x65, 0x72, 0x22, 0xa8, 0x01, 0x0a, 0x1a, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, + 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x4d, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x64, 0x61, 0x74, + 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, + 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x57, 0x61, 0x6c, + 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x41, 0x75, 0x74, 0x68, + 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x61, 0x75, 0x74, 0x68, 0x44, + 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x41, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x52, 0x0a, 0x1b, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, + 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x33, 0x0a, 0x07, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x07, 0x77, 0x61, 0x6c, + 0x6c, 0x65, 0x74, 0x73, 0x22, 0xc7, 0x02, 0x0a, 0x1d, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x50, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x2e, 0x41, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, + 0x61, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, + 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, + 0x49, 0x64, 0x12, 0x45, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, + 0x54, 0x72, 0x61, 0x64, 0x65, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, + 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x1a, 0x3b, 0x0a, 0x0d, 0x41, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x98, + 0x01, 0x0a, 0x1e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x62, 0x61, 0x73, 0x65, 0x41, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x5f, 0x61, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x41, + 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, + 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x2a, 0x52, 0x0a, 0x19, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x50, 0x6f, + 0x6f, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0d, 0x0a, 0x09, 0x51, 0x75, 0x61, 0x64, 0x72, 0x61, + 0x74, 0x69, 0x63, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x51, 0x75, 0x61, 0x64, 0x72, 0x61, 0x74, + 0x69, 0x63, 0x56, 0x32, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4c, 0x69, 0x6e, 0x65, 0x61, 0x72, + 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x46, 0x69, 0x78, 0x65, 0x64, 0x10, 0x03, 0x2a, 0x34, 0x0a, + 0x1f, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x54, 0x72, 0x61, 0x64, 0x65, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x07, 0x0a, 0x03, 0x42, 0x55, 0x59, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x53, 0x45, 0x4c, + 0x4c, 0x10, 0x01, 0x32, 0x9e, 0x02, 0x0a, 0x08, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, + 0x12, 0x49, 0x0a, 0x0c, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, + 0x12, 0x1b, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, + 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, + 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x13, 0x54, + 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x57, 0x61, 0x6c, 0x6c, 0x65, + 0x74, 0x73, 0x12, 0x22, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x54, 0x65, 0x6c, 0x65, + 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, + 0x54, 0x65, 0x6c, 0x65, 0x67, 0x72, 0x61, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x57, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x67, 0x0a, 0x16, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, + 0x54, 0x72, 0x61, 0x64, 0x65, 0x12, 0x25, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, + 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x68, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x97, 0x13, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x12, + 0x6d, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x44, 0x65, + 0x70, 0x6c, 0x6f, 0x79, 0x41, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x2e, 0x68, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x41, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x41, + 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, + 0x0a, 0x11, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x73, 0x12, 0x20, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6a, 0x0a, 0x17, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, + 0x65, 0x72, 0x73, 0x12, 0x26, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x48, 0x6f, 0x6c, + 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x68, 0x79, + 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6f, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, + 0x12, 0x27, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x54, 0x6f, + 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x5e, 0x0a, 0x13, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x12, 0x22, 0x2e, 0x68, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x23, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x23, 0x2e, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x53, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x69, 0x72, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x14, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x65, 0x72, 0x70, 0x50, 0x61, 0x69, 0x72, 0x73, + 0x12, 0x23, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x65, 0x72, 0x70, 0x50, 0x61, 0x69, 0x72, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x50, 0x65, 0x72, 0x70, 0x50, 0x61, + 0x69, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, + 0x12, 0x20, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x82, 0x01, 0x0a, 0x1f, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, + 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2e, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x68, 0x79, 0x70, 0x75, + 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x79, 0x0a, 0x1c, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x50, + 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, + 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, + 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x12, 0x20, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x68, + 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x5e, 0x0a, 0x13, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x12, 0x22, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, + 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, + 0x68, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x6c, 0x0a, 0x17, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x26, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x74, 0x72, + 0x65, 0x61, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x69, 0x0a, + 0x16, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x73, 0x12, 0x25, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, + 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, + 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x6d, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, + 0x64, 0x6c, 0x65, 0x73, 0x12, 0x27, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, + 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x74, 0x0a, 0x1d, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, 0x64, + 0x6c, 0x65, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x27, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, + 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, + 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x28, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x43, 0x61, 0x6e, 0x64, + 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x72, 0x0a, + 0x19, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x12, 0x28, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, + 0x61, 0x75, 0x6e, 0x63, 0x68, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, + 0x01, 0x12, 0x75, 0x0a, 0x1c, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x48, 0x79, 0x70, 0x65, 0x72, + 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, + 0x73, 0x12, 0x2b, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x4c, 0x61, 0x74, 0x65, 0x73, + 0x74, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, + 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, + 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, + 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x46, 0x69, 0x6c, 0x6c, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x6d, 0x0a, 0x18, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x48, 0x6f, 0x6c, + 0x64, 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x48, + 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, + 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x52, 0x0a, 0x0f, 0x48, 0x79, 0x70, 0x75, 0x72, + 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x73, 0x12, 0x1e, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, + 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x68, 0x79, 0x70, + 0x75, 0x72, 0x72, 0x2e, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, 0x46, 0x75, 0x6e, 0x43, 0x61, 0x62, + 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x9a, 0x01, 0x0a, 0x27, + 0x53, 0x65, 0x74, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x36, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, + 0x2e, 0x53, 0x65, 0x74, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x37, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x53, 0x65, 0x74, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, + 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0xa3, 0x01, 0x0a, 0x2a, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x39, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, + 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, + 0x69, 0x64, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x68, 0x79, 0x70, 0x75, 0x72, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x57, 0x61, 0x6c, + 0x6c, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x26, + 0x5a, 0x24, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4d, 0x61, 0x74, + 0x74, 0x68, 0x65, 0x77, 0x31, 0x37, 0x2d, 0x32, 0x31, 0x2f, 0x48, 0x79, 0x70, 0x75, 0x72, 0x72, + 0x46, 0x75, 0x6e, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_hypurr_proto_rawDescOnce sync.Once + file_hypurr_proto_rawDescData = file_hypurr_proto_rawDesc +) + +func file_hypurr_proto_rawDescGZIP() []byte { + file_hypurr_proto_rawDescOnce.Do(func() { + file_hypurr_proto_rawDescData = protoimpl.X.CompressGZIP(file_hypurr_proto_rawDescData) + }) + return file_hypurr_proto_rawDescData +} + +var file_hypurr_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_hypurr_proto_msgTypes = make([]protoimpl.MessageInfo, 87) +var file_hypurr_proto_goTypes = []any{ + (HyperliquidLaunchPoolType)(0), // 0: hypurr.HyperliquidLaunchPoolType + (HyperliquidLaunchTradeDirection)(0), // 1: hypurr.HyperliquidLaunchTradeDirection + (*HyperliquidToken)(nil), // 2: hypurr.HyperliquidToken + (*HyperliquidTokenHolder)(nil), // 3: hypurr.HyperliquidTokenHolder + (*HyperliquidTokenHoldersRequest)(nil), // 4: hypurr.HyperliquidTokenHoldersRequest + (*HyperliquidTokenHoldersResponse)(nil), // 5: hypurr.HyperliquidTokenHoldersResponse + (*HyperliquidTokenStatistics)(nil), // 6: hypurr.HyperliquidTokenStatistics + (*HyperliquidTokenDeployInfo)(nil), // 7: hypurr.HyperliquidTokenDeployInfo + (*HyperliquidTokenGenesis)(nil), // 8: hypurr.HyperliquidTokenGenesis + (*HyperliquidSpotPair)(nil), // 9: hypurr.HyperliquidSpotPair + (*HyperliquidPerpPair)(nil), // 10: hypurr.HyperliquidPerpPair + (*HyperliquidWallet)(nil), // 11: hypurr.HyperliquidWallet + (*HyperliquidPublicWallet)(nil), // 12: hypurr.HyperliquidPublicWallet + (*HyperliquidWalletMovement)(nil), // 13: hypurr.HyperliquidWalletMovement + (*HyperliquidWalletBalance)(nil), // 14: hypurr.HyperliquidWalletBalance + (*HyperliquidLaunchBalance)(nil), // 15: hypurr.HyperliquidLaunchBalance + (*HyperliquidWalletDeploySession)(nil), // 16: hypurr.HyperliquidWalletDeploySession + (*HyperliquidLaunch)(nil), // 17: hypurr.HyperliquidLaunch + (*HyperliquidLaunchFill)(nil), // 18: hypurr.HyperliquidLaunchFill + (*TelegramUserPublic)(nil), // 19: hypurr.TelegramUserPublic + (*HyperliquidDeployAuction)(nil), // 20: hypurr.HyperliquidDeployAuction + (*HyperliquidDeployAuctionRequest)(nil), // 21: hypurr.HyperliquidDeployAuctionRequest + (*HyperliquidDeployAuctionResponse)(nil), // 22: hypurr.HyperliquidDeployAuctionResponse + (*HyperliquidTokensRequest)(nil), // 23: hypurr.HyperliquidTokensRequest + (*HyperliquidTokensResponse)(nil), // 24: hypurr.HyperliquidTokensResponse + (*HyperliquidTokenMessage)(nil), // 25: hypurr.HyperliquidTokenMessage + (*HyperliquidTokenMessagesRequest)(nil), // 26: hypurr.HyperliquidTokenMessagesRequest + (*HyperliquidTokenMessagesResponse)(nil), // 27: hypurr.HyperliquidTokenMessagesResponse + (*HyperliquidSpotPairRequest)(nil), // 28: hypurr.HyperliquidSpotPairRequest + (*HyperliquidSpotPairResponse)(nil), // 29: hypurr.HyperliquidSpotPairResponse + (*HyperliquidSpotPairsRequest)(nil), // 30: hypurr.HyperliquidSpotPairsRequest + (*HyperliquidSpotPairsResponse)(nil), // 31: hypurr.HyperliquidSpotPairsResponse + (*HyperliquidPerpPairsRequest)(nil), // 32: hypurr.HyperliquidPerpPairsRequest + (*HyperliquidPerpPairsResponse)(nil), // 33: hypurr.HyperliquidPerpPairsResponse + (*HyperliquidWalletRequest)(nil), // 34: hypurr.HyperliquidWalletRequest + (*HyperliquidWalletResponse)(nil), // 35: hypurr.HyperliquidWalletResponse + (*HyperliquidLaunchesRequest)(nil), // 36: hypurr.HyperliquidLaunchesRequest + (*HyperliquidLaunchesResponse)(nil), // 37: hypurr.HyperliquidLaunchesResponse + (*HyperliquidLaunchStreamRequest)(nil), // 38: hypurr.HyperliquidLaunchStreamRequest + (*HyperliquidLaunchStreamResponse)(nil), // 39: hypurr.HyperliquidLaunchStreamResponse + (*HyperliquidWalletDeploySessionsRequest)(nil), // 40: hypurr.HyperliquidWalletDeploySessionsRequest + (*HyperliquidWalletDeploySessionsResponse)(nil), // 41: hypurr.HyperliquidWalletDeploySessionsResponse + (*SetHyperliquidWalletDeploySessionTargetRequest)(nil), // 42: hypurr.SetHyperliquidWalletDeploySessionTargetRequest + (*SetHyperliquidWalletDeploySessionTargetResponse)(nil), // 43: hypurr.SetHyperliquidWalletDeploySessionTargetResponse + (*DeleteHyperliquidWalletDeploySessionTargetRequest)(nil), // 44: hypurr.DeleteHyperliquidWalletDeploySessionTargetRequest + (*DeleteHyperliquidWalletDeploySessionTargetResponse)(nil), // 45: hypurr.DeleteHyperliquidWalletDeploySessionTargetResponse + (*HyperliquidLaunchFillsRequest)(nil), // 46: hypurr.HyperliquidLaunchFillsRequest + (*HyperliquidLaunchFillsResponse)(nil), // 47: hypurr.HyperliquidLaunchFillsResponse + (*HyperliquidLaunchPosition)(nil), // 48: hypurr.HyperliquidLaunchPosition + (*HyperliquidLaunchCandlesRequest)(nil), // 49: hypurr.HyperliquidLaunchCandlesRequest + (*HyperliquidLaunchCandle)(nil), // 50: hypurr.HyperliquidLaunchCandle + (*HyperliquidLaunchCandlesResponse)(nil), // 51: hypurr.HyperliquidLaunchCandlesResponse + (*HyperliquidLaunchRequest)(nil), // 52: hypurr.HyperliquidLaunchRequest + (*HyperliquidLaunchResponse)(nil), // 53: hypurr.HyperliquidLaunchResponse + (*HyperliquidLaunchMessage)(nil), // 54: hypurr.HyperliquidLaunchMessage + (*HyperliquidLaunchMessagesRequest)(nil), // 55: hypurr.HyperliquidLaunchMessagesRequest + (*HyperliquidLaunchMessagesResponse)(nil), // 56: hypurr.HyperliquidLaunchMessagesResponse + (*HyperliquidLaunchHolder)(nil), // 57: hypurr.HyperliquidLaunchHolder + (*HyperliquidLaunchHoldersRequest)(nil), // 58: hypurr.HyperliquidLaunchHoldersRequest + (*HyperliquidLaunchHoldersResponse)(nil), // 59: hypurr.HyperliquidLaunchHoldersResponse + (*LatestHyperliquidLaunchFillsRequest)(nil), // 60: hypurr.LatestHyperliquidLaunchFillsRequest + (*TelegramUser)(nil), // 61: hypurr.TelegramUser + (*TelegramUserSettings)(nil), // 62: hypurr.TelegramUserSettings + (*TelegramUserReputation)(nil), // 63: hypurr.TelegramUserReputation + (*HyperliquidWalletLabel)(nil), // 64: hypurr.HyperliquidWalletLabel + (*HyperliquidWalletDeploySessionGenesis)(nil), // 65: hypurr.HyperliquidWalletDeploySessionGenesis + (*HyperliquidWalletPerformanceRequest)(nil), // 66: hypurr.HyperliquidWalletPerformanceRequest + (*PerformancePoint)(nil), // 67: hypurr.PerformancePoint + (*PerformanceReport)(nil), // 68: hypurr.PerformanceReport + (*Performance)(nil), // 69: hypurr.Performance + (*HyperliquidWalletPerformanceResponse)(nil), // 70: hypurr.HyperliquidWalletPerformanceResponse + (*HypurrFunCabal)(nil), // 71: hypurr.HypurrFunCabal + (*HypurrFunCabalSummary)(nil), // 72: hypurr.HypurrFunCabalSummary + (*HypurrFunCabalUser)(nil), // 73: hypurr.HypurrFunCabalUser + (*HypurrFunCabalTrackedWallet)(nil), // 74: hypurr.HypurrFunCabalTrackedWallet + (*HypurrFunCabalSeason)(nil), // 75: hypurr.HypurrFunCabalSeason + (*HypurrFunCabalUserSeason)(nil), // 76: hypurr.HypurrFunCabalUserSeason + (*HypurrFunCabalsRequest)(nil), // 77: hypurr.HypurrFunCabalsRequest + (*HypurrFunCabalsResponse)(nil), // 78: hypurr.HypurrFunCabalsResponse + (*TelegramUserRequest)(nil), // 79: hypurr.TelegramUserRequest + (*TelegramUserResponse)(nil), // 80: hypurr.TelegramUserResponse + (*TelegramUserWalletsRequest)(nil), // 81: hypurr.TelegramUserWalletsRequest + (*TelegramUserWalletsResponse)(nil), // 82: hypurr.TelegramUserWalletsResponse + (*HyperliquidLaunchTradeRequest)(nil), // 83: hypurr.HyperliquidLaunchTradeRequest + (*HyperliquidLaunchTradeResponse)(nil), // 84: hypurr.HyperliquidLaunchTradeResponse + nil, // 85: hypurr.HyperliquidWalletDeploySession.GenesesEntry + nil, // 86: hypurr.TelegramUserRequest.AuthDataEntry + nil, // 87: hypurr.TelegramUserWalletsRequest.AuthDataEntry + nil, // 88: hypurr.HyperliquidLaunchTradeRequest.AuthDataEntry + (*wrapperspb.Int64Value)(nil), // 89: google.protobuf.Int64Value + (*wrapperspb.StringValue)(nil), // 90: google.protobuf.StringValue + (*wrapperspb.DoubleValue)(nil), // 91: google.protobuf.DoubleValue +} +var file_hypurr_proto_depIdxs = []int32{ + 7, // 0: hypurr.HyperliquidToken.deploy_info:type_name -> hypurr.HyperliquidTokenDeployInfo + 8, // 1: hypurr.HyperliquidToken.geneses:type_name -> hypurr.HyperliquidTokenGenesis + 6, // 2: hypurr.HyperliquidToken.statistics:type_name -> hypurr.HyperliquidTokenStatistics + 3, // 3: hypurr.HyperliquidTokenHoldersResponse.holders:type_name -> hypurr.HyperliquidTokenHolder + 89, // 4: hypurr.HyperliquidTokenGenesis.target_token_id:type_name -> google.protobuf.Int64Value + 2, // 5: hypurr.HyperliquidSpotPair.base:type_name -> hypurr.HyperliquidToken + 2, // 6: hypurr.HyperliquidSpotPair.quote:type_name -> hypurr.HyperliquidToken + 89, // 7: hypurr.HyperliquidWallet.telegram_id:type_name -> google.protobuf.Int64Value + 13, // 8: hypurr.HyperliquidWallet.movements:type_name -> hypurr.HyperliquidWalletMovement + 14, // 9: hypurr.HyperliquidWallet.spot_balances:type_name -> hypurr.HyperliquidWalletBalance + 15, // 10: hypurr.HyperliquidWallet.launch_balances:type_name -> hypurr.HyperliquidLaunchBalance + 89, // 11: hypurr.HyperliquidWalletMovement.telegram_id:type_name -> google.protobuf.Int64Value + 11, // 12: hypurr.HyperliquidWalletMovement.wallet:type_name -> hypurr.HyperliquidWallet + 2, // 13: hypurr.HyperliquidWalletMovement.token:type_name -> hypurr.HyperliquidToken + 89, // 14: hypurr.HyperliquidWalletMovement.timestamp:type_name -> google.protobuf.Int64Value + 89, // 15: hypurr.HyperliquidWalletBalance.telegram_id:type_name -> google.protobuf.Int64Value + 89, // 16: hypurr.HyperliquidLaunchBalance.telegram_id:type_name -> google.protobuf.Int64Value + 89, // 17: hypurr.HyperliquidWalletDeploySession.telegram_id:type_name -> google.protobuf.Int64Value + 89, // 18: hypurr.HyperliquidWalletDeploySession.anchor1_token_id:type_name -> google.protobuf.Int64Value + 2, // 19: hypurr.HyperliquidWalletDeploySession.anchor1_token:type_name -> hypurr.HyperliquidToken + 89, // 20: hypurr.HyperliquidWalletDeploySession.anchor2_token_id:type_name -> google.protobuf.Int64Value + 2, // 21: hypurr.HyperliquidWalletDeploySession.anchor2_token:type_name -> hypurr.HyperliquidToken + 89, // 22: hypurr.HyperliquidWalletDeploySession.token_id:type_name -> google.protobuf.Int64Value + 85, // 23: hypurr.HyperliquidWalletDeploySession.geneses:type_name -> hypurr.HyperliquidWalletDeploySession.GenesesEntry + 19, // 24: hypurr.HyperliquidLaunch.telegram_user:type_name -> hypurr.TelegramUserPublic + 16, // 25: hypurr.HyperliquidLaunch.session:type_name -> hypurr.HyperliquidWalletDeploySession + 89, // 26: hypurr.HyperliquidLaunch.topic_id:type_name -> google.protobuf.Int64Value + 18, // 27: hypurr.HyperliquidLaunch.fills:type_name -> hypurr.HyperliquidLaunchFill + 0, // 28: hypurr.HyperliquidLaunch.pool_type:type_name -> hypurr.HyperliquidLaunchPoolType + 12, // 29: hypurr.HyperliquidLaunch.session_wallet:type_name -> hypurr.HyperliquidPublicWallet + 12, // 30: hypurr.HyperliquidLaunch.dev_wallet:type_name -> hypurr.HyperliquidPublicWallet + 19, // 31: hypurr.HyperliquidLaunchFill.telegram:type_name -> hypurr.TelegramUserPublic + 12, // 32: hypurr.HyperliquidLaunchFill.wallet:type_name -> hypurr.HyperliquidPublicWallet + 90, // 33: hypurr.HyperliquidLaunchFill.movement_hash:type_name -> google.protobuf.StringValue + 91, // 34: hypurr.HyperliquidDeployAuction.current_gas:type_name -> google.protobuf.DoubleValue + 91, // 35: hypurr.HyperliquidDeployAuction.end_gas:type_name -> google.protobuf.DoubleValue + 20, // 36: hypurr.HyperliquidDeployAuctionResponse.auction:type_name -> hypurr.HyperliquidDeployAuction + 2, // 37: hypurr.HyperliquidTokensResponse.tokens:type_name -> hypurr.HyperliquidToken + 19, // 38: hypurr.HyperliquidTokenMessage.author:type_name -> hypurr.TelegramUserPublic + 25, // 39: hypurr.HyperliquidTokenMessagesResponse.messages:type_name -> hypurr.HyperliquidTokenMessage + 9, // 40: hypurr.HyperliquidSpotPairResponse.pair:type_name -> hypurr.HyperliquidSpotPair + 9, // 41: hypurr.HyperliquidSpotPairsResponse.pairs:type_name -> hypurr.HyperliquidSpotPair + 10, // 42: hypurr.HyperliquidPerpPairsResponse.pairs:type_name -> hypurr.HyperliquidPerpPair + 90, // 43: hypurr.HyperliquidWalletRequest.ethereum_address:type_name -> google.protobuf.StringValue + 11, // 44: hypurr.HyperliquidWalletResponse.wallet:type_name -> hypurr.HyperliquidWallet + 17, // 45: hypurr.HyperliquidLaunchesResponse.launches:type_name -> hypurr.HyperliquidLaunch + 89, // 46: hypurr.HyperliquidLaunchStreamRequest.launch_id:type_name -> google.protobuf.Int64Value + 17, // 47: hypurr.HyperliquidLaunchStreamResponse.launches:type_name -> hypurr.HyperliquidLaunch + 89, // 48: hypurr.HyperliquidWalletDeploySessionsRequest.telegram_id:type_name -> google.protobuf.Int64Value + 89, // 49: hypurr.HyperliquidWalletDeploySessionsRequest.wallet_id:type_name -> google.protobuf.Int64Value + 89, // 50: hypurr.HyperliquidWalletDeploySessionsRequest.session_id:type_name -> google.protobuf.Int64Value + 90, // 51: hypurr.HyperliquidWalletDeploySessionsRequest.ethereum_address:type_name -> google.protobuf.StringValue + 16, // 52: hypurr.HyperliquidWalletDeploySessionsResponse.sessions:type_name -> hypurr.HyperliquidWalletDeploySession + 90, // 53: hypurr.SetHyperliquidWalletDeploySessionTargetRequest.ethereum_address:type_name -> google.protobuf.StringValue + 16, // 54: hypurr.SetHyperliquidWalletDeploySessionTargetResponse.session:type_name -> hypurr.HyperliquidWalletDeploySession + 90, // 55: hypurr.DeleteHyperliquidWalletDeploySessionTargetRequest.ethereum_address:type_name -> google.protobuf.StringValue + 16, // 56: hypurr.DeleteHyperliquidWalletDeploySessionTargetResponse.session:type_name -> hypurr.HyperliquidWalletDeploySession + 89, // 57: hypurr.HyperliquidLaunchFillsRequest.launch_id:type_name -> google.protobuf.Int64Value + 18, // 58: hypurr.HyperliquidLaunchFillsResponse.fills:type_name -> hypurr.HyperliquidLaunchFill + 48, // 59: hypurr.HyperliquidLaunchFillsResponse.positions:type_name -> hypurr.HyperliquidLaunchPosition + 50, // 60: hypurr.HyperliquidLaunchCandlesResponse.candles:type_name -> hypurr.HyperliquidLaunchCandle + 17, // 61: hypurr.HyperliquidLaunchResponse.launch:type_name -> hypurr.HyperliquidLaunch + 19, // 62: hypurr.HyperliquidLaunchMessage.author:type_name -> hypurr.TelegramUserPublic + 54, // 63: hypurr.HyperliquidLaunchMessagesResponse.messages:type_name -> hypurr.HyperliquidLaunchMessage + 57, // 64: hypurr.HyperliquidLaunchHoldersResponse.holders:type_name -> hypurr.HyperliquidLaunchHolder + 62, // 65: hypurr.TelegramUser.settings:type_name -> hypurr.TelegramUserSettings + 11, // 66: hypurr.TelegramUser.wallet:type_name -> hypurr.HyperliquidWallet + 11, // 67: hypurr.TelegramUser.wallets:type_name -> hypurr.HyperliquidWallet + 11, // 68: hypurr.TelegramUser.sniper_wallet:type_name -> hypurr.HyperliquidWallet + 11, // 69: hypurr.TelegramUser.dumper_wallet:type_name -> hypurr.HyperliquidWallet + 63, // 70: hypurr.TelegramUser.reputation:type_name -> hypurr.TelegramUserReputation + 17, // 71: hypurr.TelegramUser.launches:type_name -> hypurr.HyperliquidLaunch + 14, // 72: hypurr.TelegramUser.balances:type_name -> hypurr.HyperliquidWalletBalance + 13, // 73: hypurr.TelegramUser.movements:type_name -> hypurr.HyperliquidWalletMovement + 18, // 74: hypurr.TelegramUser.launch_fills:type_name -> hypurr.HyperliquidLaunchFill + 64, // 75: hypurr.TelegramUser.labels:type_name -> hypurr.HyperliquidWalletLabel + 90, // 76: hypurr.HyperliquidWalletPerformanceRequest.ethereum_address:type_name -> google.protobuf.StringValue + 68, // 77: hypurr.Performance.reports:type_name -> hypurr.PerformanceReport + 67, // 78: hypurr.Performance.points:type_name -> hypurr.PerformancePoint + 69, // 79: hypurr.HyperliquidWalletPerformanceResponse.spot:type_name -> hypurr.Performance + 69, // 80: hypurr.HyperliquidWalletPerformanceResponse.perp:type_name -> hypurr.Performance + 69, // 81: hypurr.HyperliquidWalletPerformanceResponse.launch:type_name -> hypurr.Performance + 73, // 82: hypurr.HypurrFunCabal.users:type_name -> hypurr.HypurrFunCabalUser + 74, // 83: hypurr.HypurrFunCabal.tracked_wallets:type_name -> hypurr.HypurrFunCabalTrackedWallet + 76, // 84: hypurr.HypurrFunCabal.user_seasons:type_name -> hypurr.HypurrFunCabalUserSeason + 72, // 85: hypurr.HypurrFunCabal.summary:type_name -> hypurr.HypurrFunCabalSummary + 11, // 86: hypurr.HypurrFunCabalUser.wallet:type_name -> hypurr.HyperliquidWallet + 11, // 87: hypurr.HypurrFunCabalTrackedWallet.wallet:type_name -> hypurr.HyperliquidWallet + 76, // 88: hypurr.HypurrFunCabalSeason.user_seasons:type_name -> hypurr.HypurrFunCabalUserSeason + 89, // 89: hypurr.HypurrFunCabalSeason.winner_id:type_name -> google.protobuf.Int64Value + 71, // 90: hypurr.HypurrFunCabalSeason.winner:type_name -> hypurr.HypurrFunCabal + 71, // 91: hypurr.HypurrFunCabalsResponse.cabals:type_name -> hypurr.HypurrFunCabal + 86, // 92: hypurr.TelegramUserRequest.auth_data:type_name -> hypurr.TelegramUserRequest.AuthDataEntry + 61, // 93: hypurr.TelegramUserResponse.user:type_name -> hypurr.TelegramUser + 87, // 94: hypurr.TelegramUserWalletsRequest.auth_data:type_name -> hypurr.TelegramUserWalletsRequest.AuthDataEntry + 11, // 95: hypurr.TelegramUserWalletsResponse.wallets:type_name -> hypurr.HyperliquidWallet + 88, // 96: hypurr.HyperliquidLaunchTradeRequest.auth_data:type_name -> hypurr.HyperliquidLaunchTradeRequest.AuthDataEntry + 1, // 97: hypurr.HyperliquidLaunchTradeRequest.direction:type_name -> hypurr.HyperliquidLaunchTradeDirection + 65, // 98: hypurr.HyperliquidWalletDeploySession.GenesesEntry.value:type_name -> hypurr.HyperliquidWalletDeploySessionGenesis + 79, // 99: hypurr.Telegram.TelegramUser:input_type -> hypurr.TelegramUserRequest + 81, // 100: hypurr.Telegram.TelegramUserWallets:input_type -> hypurr.TelegramUserWalletsRequest + 83, // 101: hypurr.Telegram.HyperliquidLaunchTrade:input_type -> hypurr.HyperliquidLaunchTradeRequest + 21, // 102: hypurr.Static.HyperliquidDeployAuction:input_type -> hypurr.HyperliquidDeployAuctionRequest + 23, // 103: hypurr.Static.HyperliquidTokens:input_type -> hypurr.HyperliquidTokensRequest + 4, // 104: hypurr.Static.HyperliquidTokenHolders:input_type -> hypurr.HyperliquidTokenHoldersRequest + 26, // 105: hypurr.Static.HyperliquidTokenMessages:input_type -> hypurr.HyperliquidTokenMessagesRequest + 28, // 106: hypurr.Static.HyperliquidSpotPair:input_type -> hypurr.HyperliquidSpotPairRequest + 30, // 107: hypurr.Static.HyperliquidSpotPairs:input_type -> hypurr.HyperliquidSpotPairsRequest + 32, // 108: hypurr.Static.HyperliquidPerpPairs:input_type -> hypurr.HyperliquidPerpPairsRequest + 34, // 109: hypurr.Static.HyperliquidWallet:input_type -> hypurr.HyperliquidWalletRequest + 40, // 110: hypurr.Static.HyperliquidWalletDeploySessions:input_type -> hypurr.HyperliquidWalletDeploySessionsRequest + 66, // 111: hypurr.Static.HyperliquidWalletPerformance:input_type -> hypurr.HyperliquidWalletPerformanceRequest + 52, // 112: hypurr.Static.HyperliquidLaunch:input_type -> hypurr.HyperliquidLaunchRequest + 36, // 113: hypurr.Static.HyperliquidLaunches:input_type -> hypurr.HyperliquidLaunchesRequest + 38, // 114: hypurr.Static.HyperliquidLaunchStream:input_type -> hypurr.HyperliquidLaunchStreamRequest + 46, // 115: hypurr.Static.HyperliquidLaunchFills:input_type -> hypurr.HyperliquidLaunchFillsRequest + 49, // 116: hypurr.Static.HyperliquidLaunchCandles:input_type -> hypurr.HyperliquidLaunchCandlesRequest + 49, // 117: hypurr.Static.HyperliquidLaunchCandleStream:input_type -> hypurr.HyperliquidLaunchCandlesRequest + 55, // 118: hypurr.Static.HyperliquidLaunchMessages:input_type -> hypurr.HyperliquidLaunchMessagesRequest + 60, // 119: hypurr.Static.LatestHyperliquidLaunchFills:input_type -> hypurr.LatestHyperliquidLaunchFillsRequest + 58, // 120: hypurr.Static.HyperliquidLaunchHolders:input_type -> hypurr.HyperliquidLaunchHoldersRequest + 77, // 121: hypurr.Static.HypurrFunCabals:input_type -> hypurr.HypurrFunCabalsRequest + 42, // 122: hypurr.Static.SetHyperliquidWalletDeploySessionTarget:input_type -> hypurr.SetHyperliquidWalletDeploySessionTargetRequest + 44, // 123: hypurr.Static.DeleteHyperliquidWalletDeploySessionTarget:input_type -> hypurr.DeleteHyperliquidWalletDeploySessionTargetRequest + 80, // 124: hypurr.Telegram.TelegramUser:output_type -> hypurr.TelegramUserResponse + 82, // 125: hypurr.Telegram.TelegramUserWallets:output_type -> hypurr.TelegramUserWalletsResponse + 84, // 126: hypurr.Telegram.HyperliquidLaunchTrade:output_type -> hypurr.HyperliquidLaunchTradeResponse + 22, // 127: hypurr.Static.HyperliquidDeployAuction:output_type -> hypurr.HyperliquidDeployAuctionResponse + 24, // 128: hypurr.Static.HyperliquidTokens:output_type -> hypurr.HyperliquidTokensResponse + 5, // 129: hypurr.Static.HyperliquidTokenHolders:output_type -> hypurr.HyperliquidTokenHoldersResponse + 27, // 130: hypurr.Static.HyperliquidTokenMessages:output_type -> hypurr.HyperliquidTokenMessagesResponse + 29, // 131: hypurr.Static.HyperliquidSpotPair:output_type -> hypurr.HyperliquidSpotPairResponse + 31, // 132: hypurr.Static.HyperliquidSpotPairs:output_type -> hypurr.HyperliquidSpotPairsResponse + 33, // 133: hypurr.Static.HyperliquidPerpPairs:output_type -> hypurr.HyperliquidPerpPairsResponse + 35, // 134: hypurr.Static.HyperliquidWallet:output_type -> hypurr.HyperliquidWalletResponse + 41, // 135: hypurr.Static.HyperliquidWalletDeploySessions:output_type -> hypurr.HyperliquidWalletDeploySessionsResponse + 70, // 136: hypurr.Static.HyperliquidWalletPerformance:output_type -> hypurr.HyperliquidWalletPerformanceResponse + 53, // 137: hypurr.Static.HyperliquidLaunch:output_type -> hypurr.HyperliquidLaunchResponse + 37, // 138: hypurr.Static.HyperliquidLaunches:output_type -> hypurr.HyperliquidLaunchesResponse + 39, // 139: hypurr.Static.HyperliquidLaunchStream:output_type -> hypurr.HyperliquidLaunchStreamResponse + 47, // 140: hypurr.Static.HyperliquidLaunchFills:output_type -> hypurr.HyperliquidLaunchFillsResponse + 51, // 141: hypurr.Static.HyperliquidLaunchCandles:output_type -> hypurr.HyperliquidLaunchCandlesResponse + 51, // 142: hypurr.Static.HyperliquidLaunchCandleStream:output_type -> hypurr.HyperliquidLaunchCandlesResponse + 56, // 143: hypurr.Static.HyperliquidLaunchMessages:output_type -> hypurr.HyperliquidLaunchMessagesResponse + 47, // 144: hypurr.Static.LatestHyperliquidLaunchFills:output_type -> hypurr.HyperliquidLaunchFillsResponse + 59, // 145: hypurr.Static.HyperliquidLaunchHolders:output_type -> hypurr.HyperliquidLaunchHoldersResponse + 78, // 146: hypurr.Static.HypurrFunCabals:output_type -> hypurr.HypurrFunCabalsResponse + 43, // 147: hypurr.Static.SetHyperliquidWalletDeploySessionTarget:output_type -> hypurr.SetHyperliquidWalletDeploySessionTargetResponse + 45, // 148: hypurr.Static.DeleteHyperliquidWalletDeploySessionTarget:output_type -> hypurr.DeleteHyperliquidWalletDeploySessionTargetResponse + 124, // [124:149] is the sub-list for method output_type + 99, // [99:124] is the sub-list for method input_type + 99, // [99:99] is the sub-list for extension type_name + 99, // [99:99] is the sub-list for extension extendee + 0, // [0:99] is the sub-list for field type_name +} + +func init() { file_hypurr_proto_init() } +func file_hypurr_proto_init() { + if File_hypurr_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_hypurr_proto_rawDesc, + NumEnums: 2, + NumMessages: 87, + NumExtensions: 0, + NumServices: 2, + }, + GoTypes: file_hypurr_proto_goTypes, + DependencyIndexes: file_hypurr_proto_depIdxs, + EnumInfos: file_hypurr_proto_enumTypes, + MessageInfos: file_hypurr_proto_msgTypes, + }.Build() + File_hypurr_proto = out.File + file_hypurr_proto_rawDesc = nil + file_hypurr_proto_goTypes = nil + file_hypurr_proto_depIdxs = nil +} diff --git a/pb/hypurr.proto b/pb/hypurr.proto new file mode 100644 index 0000000..c707578 --- /dev/null +++ b/pb/hypurr.proto @@ -0,0 +1,613 @@ +syntax = "proto3"; + +package hypurr; + +option go_package = "github.com/Matthew17-21/HypurrFun/pb"; + +// protoc --go_out=. --go_opt=paths=source_relative \ +// --go-grpc_out=. --go-grpc_opt=paths=source_relative \ +// *.proto + +import "google/protobuf/wrappers.proto"; // Needed for google.protobuf.Int64Value + +service Telegram { + rpc TelegramUser (TelegramUserRequest) returns (TelegramUserResponse); + rpc TelegramUserWallets (TelegramUserWalletsRequest) returns (TelegramUserWalletsResponse); + rpc HyperliquidLaunchTrade (HyperliquidLaunchTradeRequest) returns (HyperliquidLaunchTradeResponse); +} + +service Static { + rpc HyperliquidDeployAuction (HyperliquidDeployAuctionRequest) returns (HyperliquidDeployAuctionResponse); + rpc HyperliquidTokens (HyperliquidTokensRequest) returns (HyperliquidTokensResponse); + rpc HyperliquidTokenHolders (HyperliquidTokenHoldersRequest) returns (HyperliquidTokenHoldersResponse); + rpc HyperliquidTokenMessages (HyperliquidTokenMessagesRequest) returns (stream HyperliquidTokenMessagesResponse); + rpc HyperliquidSpotPair (HyperliquidSpotPairRequest) returns (HyperliquidSpotPairResponse); + rpc HyperliquidSpotPairs (HyperliquidSpotPairsRequest) returns (HyperliquidSpotPairsResponse); + rpc HyperliquidPerpPairs (HyperliquidPerpPairsRequest) returns (HyperliquidPerpPairsResponse); + rpc HyperliquidWallet (HyperliquidWalletRequest) returns (HyperliquidWalletResponse); + rpc HyperliquidWalletDeploySessions (HyperliquidWalletDeploySessionsRequest) returns (HyperliquidWalletDeploySessionsResponse); + rpc HyperliquidWalletPerformance (HyperliquidWalletPerformanceRequest) returns (HyperliquidWalletPerformanceResponse); + rpc HyperliquidLaunch (HyperliquidLaunchRequest) returns (HyperliquidLaunchResponse); + rpc HyperliquidLaunches (HyperliquidLaunchesRequest) returns (HyperliquidLaunchesResponse); + rpc HyperliquidLaunchStream (HyperliquidLaunchStreamRequest) returns (stream HyperliquidLaunchStreamResponse); + rpc HyperliquidLaunchFills (HyperliquidLaunchFillsRequest) returns (stream HyperliquidLaunchFillsResponse); + rpc HyperliquidLaunchCandles (HyperliquidLaunchCandlesRequest) returns (HyperliquidLaunchCandlesResponse); + rpc HyperliquidLaunchCandleStream (HyperliquidLaunchCandlesRequest) returns (stream HyperliquidLaunchCandlesResponse); + rpc HyperliquidLaunchMessages (HyperliquidLaunchMessagesRequest) returns (stream HyperliquidLaunchMessagesResponse); + rpc LatestHyperliquidLaunchFills (LatestHyperliquidLaunchFillsRequest) returns (stream HyperliquidLaunchFillsResponse); + rpc HyperliquidLaunchHolders (HyperliquidLaunchHoldersRequest) returns (HyperliquidLaunchHoldersResponse); + rpc HypurrFunCabals (HypurrFunCabalsRequest) returns (HypurrFunCabalsResponse); + rpc SetHyperliquidWalletDeploySessionTarget (SetHyperliquidWalletDeploySessionTargetRequest) returns (SetHyperliquidWalletDeploySessionTargetResponse); + rpc DeleteHyperliquidWalletDeploySessionTarget (DeleteHyperliquidWalletDeploySessionTargetRequest) returns (DeleteHyperliquidWalletDeploySessionTargetResponse); +} + +enum HyperliquidLaunchPoolType { + Quadratic = 0; + QuadraticV2 = 1; + Linear = 2; + Fixed = 3; +} + +enum HyperliquidLaunchTradeDirection { + BUY = 0; + SELL = 1; +} + +message HyperliquidToken { + int64 id = 1; + string name = 2; + int64 index = 3; + int64 sz_decimals = 4; + int64 wei_decimals = 5; + string token_id = 6; + double circulating_supply = 7; + HyperliquidTokenDeployInfo deploy_info = 8; + repeated HyperliquidTokenGenesis geneses = 9; + double hlq_balance = 10; + string full_name = 11; + HyperliquidTokenStatistics statistics = 12; +} + +message HyperliquidTokenHolder { + double balance = 1; + string address = 2; + string type = 3; +} + +message HyperliquidTokenHoldersRequest { + int64 token_id = 1; +} + +message HyperliquidTokenHoldersResponse { + repeated HyperliquidTokenHolder holders = 1; +} + +message HyperliquidTokenStatistics { + int64 token_id = 1; + int64 holder_count = 2; + double concentration_coefficient = 3; +} + +message HyperliquidTokenDeployInfo { + int64 token_id = 1; + int64 height = 2; + string deployer = 3; + string register_tx = 4; + string register_spot_tx = 5; + string genesis_tx = 6; + string hyperliquidity_tx = 7; + double hip2_price = 8; + int32 hip2_order_count = 9; + double hip2_order_size = 10; +} + +message HyperliquidTokenGenesis { + int64 token_id = 1; + string target = 2; + double amount = 3; + string type = 4; + google.protobuf.Int64Value target_token_id = 5; +} + +message HyperliquidSpotPair { + int64 id = 1; + string name = 2; + int64 base_id = 3; + HyperliquidToken base = 4; + int64 quote_id = 5; + HyperliquidToken quote = 6; + int64 index = 7; + double mid_price = 8; + double mark_price = 9; + double daily_ntl_volume = 10; + double previous_day_px = 11; +} + +message HyperliquidPerpPair { + int64 id = 1; + string name = 2; + int64 index = 3; + double mid_price = 4; + double mark_price = 5; + double daily_ntl_volume = 6; + double previous_day_px = 7; + double funding = 8; + double open_interest = 9; + double premium = 10; +} + +message HyperliquidWallet { + int64 id = 1; + string name = 2; + google.protobuf.Int64Value telegram_id = 3; + string ethereum_address = 4; + int32 points = 5; + repeated HyperliquidWalletMovement movements = 6; + repeated HyperliquidWalletBalance spot_balances = 7; + repeated HyperliquidLaunchBalance launch_balances = 8; + bool is_agent = 9; + bool is_read_only = 10; +} + +message HyperliquidPublicWallet { + string ethereum_address = 1; +} + +message HyperliquidWalletMovement { + google.protobuf.Int64Value telegram_id = 1; + HyperliquidWallet wallet = 2; + int64 wallet_id = 3; + string hash = 4; + string type = 5; + int64 token_id = 6; + HyperliquidToken token = 7; + double amount = 8; + double usdc_value = 9; + string destination = 10; + double fee = 11; + google.protobuf.Int64Value timestamp = 12; +} + +message HyperliquidWalletBalance { + google.protobuf.Int64Value telegram_id = 1; + int64 wallet_id = 2; + int64 token_id = 3; + double balance = 4; +} + +message HyperliquidLaunchBalance { + google.protobuf.Int64Value telegram_id = 1; + int64 wallet_id = 2; + int64 launch_id = 3; + int64 balance = 4; +} + +message HyperliquidWalletDeploySession { + int64 id = 1; + google.protobuf.Int64Value telegram_id = 2; + int32 step = 3; + string token_name = 4; + string full_name = 5; + int32 token_decimals = 6; + int32 token_wei = 7; + double token_supply = 8; + int32 start_market_cap = 9; + google.protobuf.Int64Value anchor1_token_id = 10; + HyperliquidToken anchor1_token = 11; + google.protobuf.Int64Value anchor2_token_id = 12; + HyperliquidToken anchor2_token = 13; + google.protobuf.Int64Value token_id = 14; + int32 spot_pair_id = 15; + double deploy_threshold = 16; + map geneses = 17; +} + +message HyperliquidLaunch { + int64 id = 1; + int64 telegram_id = 2; + TelegramUserPublic telegram_user = 3; + string description = 4; + bool listed = 5; + bool settled = 6; + int64 x0 = 7; + int64 session_id = 8; + HyperliquidWalletDeploySession session = 9; + string media_file_id = 10; + google.protobuf.Int64Value topic_id = 11; + int64 x = 12; + int64 y = 13; + int64 k = 14; + repeated HyperliquidLaunchFill fills = 15; + double daily_ntl_volume = 16; + double previous_day_px = 17; + int64 last_event_timestamp = 18; + HyperliquidLaunchPoolType pool_type = 19; + int64 decimals = 20; + HyperliquidPublicWallet session_wallet = 21; + string media_type = 22; + int64 listed_timestamp = 23; + HyperliquidPublicWallet dev_wallet = 24; +} + +message HyperliquidLaunchFill { + int64 launch_id = 1; + int64 telegram_id = 2; + TelegramUserPublic telegram = 3; + HyperliquidPublicWallet wallet = 4; + int64 usdc_delta = 5; + int64 launch_delta = 6; + int64 timestamp = 7; + google.protobuf.StringValue movement_hash = 8; + int64 id = 9; +} + +message TelegramUserPublic { + int64 id = 1; + string username = 2; + string picture_file_id = 3; + int64 reputation_score = 4; +} + +message HyperliquidDeployAuction { + int64 start_time = 1; + int64 duration = 2; + double start_gas = 3; + google.protobuf.DoubleValue current_gas = 4; + google.protobuf.DoubleValue end_gas = 5; +} + +message HyperliquidDeployAuctionRequest {} + +message HyperliquidDeployAuctionResponse { + HyperliquidDeployAuction auction = 1; +} + +message HyperliquidTokensRequest {} + +message HyperliquidTokensResponse { + repeated HyperliquidToken tokens = 1; +} + +message HyperliquidTokenMessage { + int64 id = 1; + int64 timestamp = 2; + int64 token_id = 3; + int64 telegram_id = 4; + TelegramUserPublic author = 5; + int64 chat_id = 6; + int64 topic_id = 7; + string message = 8; +} + +message HyperliquidTokenMessagesRequest { + int64 token_id = 1; +} + +message HyperliquidTokenMessagesResponse { + repeated HyperliquidTokenMessage messages = 1; +} + +message HyperliquidSpotPairRequest { + int64 id = 1; +} + +message HyperliquidSpotPairResponse { + HyperliquidSpotPair pair = 1; +} + +message HyperliquidSpotPairsRequest {} + +message HyperliquidSpotPairsResponse { + repeated HyperliquidSpotPair pairs = 1; +} + +message HyperliquidPerpPairsRequest {} + +message HyperliquidPerpPairsResponse { + repeated HyperliquidPerpPair pairs = 1; +} + +message HyperliquidWalletRequest { + google.protobuf.StringValue ethereum_address = 1; +} + +message HyperliquidWalletResponse { + HyperliquidWallet wallet = 1; +} + +message HyperliquidLaunchesRequest {} + +message HyperliquidLaunchesResponse { + repeated HyperliquidLaunch launches = 1; +} + +message HyperliquidLaunchStreamRequest { + google.protobuf.Int64Value launch_id = 1; +} + +message HyperliquidLaunchStreamResponse { + repeated HyperliquidLaunch launches = 1; +} + +message HyperliquidWalletDeploySessionsRequest { + google.protobuf.Int64Value telegram_id = 1; + google.protobuf.Int64Value wallet_id = 2; + google.protobuf.Int64Value session_id = 3; + google.protobuf.StringValue ethereum_address = 4; +} + +message HyperliquidWalletDeploySessionsResponse { + repeated HyperliquidWalletDeploySession sessions = 1; +} + +message SetHyperliquidWalletDeploySessionTargetRequest { + google.protobuf.StringValue ethereum_address = 1; + int64 session_id = 2; + string name = 3; + string target = 4; + int32 share = 5; +} + +message SetHyperliquidWalletDeploySessionTargetResponse { + HyperliquidWalletDeploySession session = 1; +} + +message DeleteHyperliquidWalletDeploySessionTargetRequest { + google.protobuf.StringValue ethereum_address = 1; + int64 session_id = 2; + string name = 3; +} + +message DeleteHyperliquidWalletDeploySessionTargetResponse { + HyperliquidWalletDeploySession session = 1; +} + +message HyperliquidLaunchFillsRequest { + google.protobuf.Int64Value launch_id = 1; +} + +message HyperliquidLaunchFillsResponse { + repeated HyperliquidLaunchFill fills = 1; + repeated HyperliquidLaunchPosition positions = 2; +} + +message HyperliquidLaunchPosition { + string address = 1; + int64 balance = 2; + int64 cost = 3; +} + +message HyperliquidLaunchCandlesRequest { + int64 launch_id = 1; + string interval = 2; +} + +message HyperliquidLaunchCandle { + int64 time = 1; + float open = 2; + float high = 3; + float low = 4; + float close = 5; + float volume = 6; +} + +message HyperliquidLaunchCandlesResponse { + repeated HyperliquidLaunchCandle candles = 1; +} + +message HyperliquidLaunchRequest { + int64 id = 1; +} + +message HyperliquidLaunchResponse { + HyperliquidLaunch launch = 1; +} + +message HyperliquidLaunchMessage { + int64 id = 1; + int64 timestamp = 2; + int64 launch_id = 3; + int64 telegram_id = 4; + TelegramUserPublic author = 5; + int64 chat_id = 6; + int64 topic_id = 7; + string message = 8; +} + +message HyperliquidLaunchMessagesRequest { + int64 launch_id = 1; +} + +message HyperliquidLaunchMessagesResponse { + repeated HyperliquidLaunchMessage messages = 1; +} + +message HyperliquidLaunchHolder { + int64 balance = 1; + string address = 2; + string type = 3; +} + +message HyperliquidLaunchHoldersRequest { + int64 launch_id = 1; +} + +message HyperliquidLaunchHoldersResponse { + repeated HyperliquidLaunchHolder holders = 1; +} + +message LatestHyperliquidLaunchFillsRequest {} + +message TelegramUser { + int64 telegram_id = 1; + string telegram_username = 2; + double pending_fees = 3; + double referral_rewards = 4; + string referral_code = 5; + int64 referral_score = 6; + int64 referrer_id = 7; + TelegramUserSettings settings = 8; + HyperliquidWallet wallet = 9; + repeated HyperliquidWallet wallets = 10; + int64 wallet_id = 11; + HyperliquidWallet sniper_wallet = 12; + int64 sniper_wallet_id = 13; + HyperliquidWallet dumper_wallet = 14; + int64 dumper_wallet_id = 15; + int64 reputation_id = 16; + TelegramUserReputation reputation = 17; + repeated HyperliquidLaunch launches = 18; + repeated HyperliquidWalletBalance balances = 19; + repeated HyperliquidWalletMovement movements = 20; + repeated HyperliquidLaunchFill launch_fills = 21; + repeated HyperliquidWalletLabel labels = 22; +} + +message TelegramUserSettings {} + +message TelegramUserReputation {} + +message HyperliquidWalletLabel { + string ethereum_address = 1; + string label = 2; +} + +message HyperliquidWalletDeploySessionGenesis { + string target = 1; + int32 share = 2; +} + +message HyperliquidWalletPerformanceRequest { + google.protobuf.StringValue ethereum_address = 1; + string account_type = 2; +} + +message PerformancePoint { + int64 time = 1; + float notional = 2; + float pnl = 3; +} + +message PerformanceReport { + int64 token_id = 1; + float total_pnl = 2; + float running_pnl = 3; + float size = 4; + float price = 5; + float entry_price = 6; + float total_cost = 7; + float running_cost = 8; +} + +message Performance { + float net_cash = 1; + float notional = 2; + repeated PerformanceReport reports = 3; + repeated PerformancePoint points = 4; +} + +message HyperliquidWalletPerformanceResponse { + Performance spot = 1; + Performance perp = 2; + Performance launch = 3; +} + +message HypurrFunCabal { + int64 telegram_chat_id = 1; + string name = 2; + string picture_file_id = 3; + repeated HypurrFunCabalUser users = 4; + repeated HypurrFunCabalTrackedWallet tracked_wallets = 5; + repeated HypurrFunCabalUserSeason user_seasons = 6; + HypurrFunCabalSummary summary = 7; +} + +message HypurrFunCabalSummary { + int64 user_count = 1; + double season_spot_pnl = 2; + double season_perp_pnl = 3; + double season_launch_pnl = 4; +} + +message HypurrFunCabalUser { + int64 telegram_chat_id = 1; + int64 telegram_id = 2; + HyperliquidWallet wallet = 3; + int64 wallet_id = 4; + string name = 5; + double spot_pnl = 6; + double spot_equity = 7; + double launch_pnl = 8; + double launch_equity = 9; + double perp_pnl = 10; + double perp_equity = 11; +} + +message HypurrFunCabalTrackedWallet { + int64 telegram_chat_id = 1; + int64 wallet_id = 2; + HyperliquidWallet wallet = 3; + string label = 4; + bool alert_spot = 5; + bool alert_perp = 6; +} + +message HypurrFunCabalSeason { + int64 id = 1; + int64 start_time = 2; + int64 end_time = 3; + string name = 4; + repeated HypurrFunCabalUserSeason user_seasons = 5; + google.protobuf.Int64Value winner_id = 6; + HypurrFunCabal winner = 7; +} + +message HypurrFunCabalUserSeason { + int64 cabal_season_id = 1; + int64 telegram_id = 2; + int64 wallet_id = 3; + int64 telegram_chat_id = 4; + double spot_pnl = 5; + double launch_pnl = 6; + double perp_pnl = 7; + double last_spot_pnl = 8; + double last_launch_pnl = 9; + double last_perp_pnl = 10; +} + +message HypurrFunCabalsRequest {} + +message HypurrFunCabalsResponse { + repeated HypurrFunCabal cabals = 1; +} + +message TelegramUserRequest { + map auth_data = 1; +} + +message TelegramUserResponse { + TelegramUser user = 1; +} + +message TelegramUserWalletsRequest { + map auth_data = 1; +} + +message TelegramUserWalletsResponse { + repeated HyperliquidWallet wallets = 1; +} + +message HyperliquidLaunchTradeRequest { + map auth_data = 1; + int64 launch_id = 2; + int64 wallet_id = 3; + HyperliquidLaunchTradeDirection direction = 4; + double amount = 5; +} + +message HyperliquidLaunchTradeResponse { + double base_amount = 1; + double quote_amount = 2; + string message = 3; + bool success = 4; +} \ No newline at end of file diff --git a/pb/hypurr_grpc.pb.go b/pb/hypurr_grpc.pb.go new file mode 100644 index 0000000..dc866b5 --- /dev/null +++ b/pb/hypurr_grpc.pb.go @@ -0,0 +1,1116 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.1 +// source: hypurr.proto + +package pb + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + Telegram_TelegramUser_FullMethodName = "/hypurr.Telegram/TelegramUser" + Telegram_TelegramUserWallets_FullMethodName = "/hypurr.Telegram/TelegramUserWallets" + Telegram_HyperliquidLaunchTrade_FullMethodName = "/hypurr.Telegram/HyperliquidLaunchTrade" +) + +// TelegramClient is the client API for Telegram service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type TelegramClient interface { + TelegramUser(ctx context.Context, in *TelegramUserRequest, opts ...grpc.CallOption) (*TelegramUserResponse, error) + TelegramUserWallets(ctx context.Context, in *TelegramUserWalletsRequest, opts ...grpc.CallOption) (*TelegramUserWalletsResponse, error) + HyperliquidLaunchTrade(ctx context.Context, in *HyperliquidLaunchTradeRequest, opts ...grpc.CallOption) (*HyperliquidLaunchTradeResponse, error) +} + +type telegramClient struct { + cc grpc.ClientConnInterface +} + +func NewTelegramClient(cc grpc.ClientConnInterface) TelegramClient { + return &telegramClient{cc} +} + +func (c *telegramClient) TelegramUser(ctx context.Context, in *TelegramUserRequest, opts ...grpc.CallOption) (*TelegramUserResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(TelegramUserResponse) + err := c.cc.Invoke(ctx, Telegram_TelegramUser_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *telegramClient) TelegramUserWallets(ctx context.Context, in *TelegramUserWalletsRequest, opts ...grpc.CallOption) (*TelegramUserWalletsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(TelegramUserWalletsResponse) + err := c.cc.Invoke(ctx, Telegram_TelegramUserWallets_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *telegramClient) HyperliquidLaunchTrade(ctx context.Context, in *HyperliquidLaunchTradeRequest, opts ...grpc.CallOption) (*HyperliquidLaunchTradeResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidLaunchTradeResponse) + err := c.cc.Invoke(ctx, Telegram_HyperliquidLaunchTrade_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// TelegramServer is the server API for Telegram service. +// All implementations must embed UnimplementedTelegramServer +// for forward compatibility. +type TelegramServer interface { + TelegramUser(context.Context, *TelegramUserRequest) (*TelegramUserResponse, error) + TelegramUserWallets(context.Context, *TelegramUserWalletsRequest) (*TelegramUserWalletsResponse, error) + HyperliquidLaunchTrade(context.Context, *HyperliquidLaunchTradeRequest) (*HyperliquidLaunchTradeResponse, error) + mustEmbedUnimplementedTelegramServer() +} + +// UnimplementedTelegramServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedTelegramServer struct{} + +func (UnimplementedTelegramServer) TelegramUser(context.Context, *TelegramUserRequest) (*TelegramUserResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TelegramUser not implemented") +} +func (UnimplementedTelegramServer) TelegramUserWallets(context.Context, *TelegramUserWalletsRequest) (*TelegramUserWalletsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TelegramUserWallets not implemented") +} +func (UnimplementedTelegramServer) HyperliquidLaunchTrade(context.Context, *HyperliquidLaunchTradeRequest) (*HyperliquidLaunchTradeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidLaunchTrade not implemented") +} +func (UnimplementedTelegramServer) mustEmbedUnimplementedTelegramServer() {} +func (UnimplementedTelegramServer) testEmbeddedByValue() {} + +// UnsafeTelegramServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to TelegramServer will +// result in compilation errors. +type UnsafeTelegramServer interface { + mustEmbedUnimplementedTelegramServer() +} + +func RegisterTelegramServer(s grpc.ServiceRegistrar, srv TelegramServer) { + // If the following call pancis, it indicates UnimplementedTelegramServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&Telegram_ServiceDesc, srv) +} + +func _Telegram_TelegramUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TelegramUserRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TelegramServer).TelegramUser(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Telegram_TelegramUser_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TelegramServer).TelegramUser(ctx, req.(*TelegramUserRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Telegram_TelegramUserWallets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TelegramUserWalletsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TelegramServer).TelegramUserWallets(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Telegram_TelegramUserWallets_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TelegramServer).TelegramUserWallets(ctx, req.(*TelegramUserWalletsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Telegram_HyperliquidLaunchTrade_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidLaunchTradeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TelegramServer).HyperliquidLaunchTrade(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Telegram_HyperliquidLaunchTrade_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TelegramServer).HyperliquidLaunchTrade(ctx, req.(*HyperliquidLaunchTradeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Telegram_ServiceDesc is the grpc.ServiceDesc for Telegram service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Telegram_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "hypurr.Telegram", + HandlerType: (*TelegramServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "TelegramUser", + Handler: _Telegram_TelegramUser_Handler, + }, + { + MethodName: "TelegramUserWallets", + Handler: _Telegram_TelegramUserWallets_Handler, + }, + { + MethodName: "HyperliquidLaunchTrade", + Handler: _Telegram_HyperliquidLaunchTrade_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "hypurr.proto", +} + +const ( + Static_HyperliquidDeployAuction_FullMethodName = "/hypurr.Static/HyperliquidDeployAuction" + Static_HyperliquidTokens_FullMethodName = "/hypurr.Static/HyperliquidTokens" + Static_HyperliquidTokenHolders_FullMethodName = "/hypurr.Static/HyperliquidTokenHolders" + Static_HyperliquidTokenMessages_FullMethodName = "/hypurr.Static/HyperliquidTokenMessages" + Static_HyperliquidSpotPair_FullMethodName = "/hypurr.Static/HyperliquidSpotPair" + Static_HyperliquidSpotPairs_FullMethodName = "/hypurr.Static/HyperliquidSpotPairs" + Static_HyperliquidPerpPairs_FullMethodName = "/hypurr.Static/HyperliquidPerpPairs" + Static_HyperliquidWallet_FullMethodName = "/hypurr.Static/HyperliquidWallet" + Static_HyperliquidWalletDeploySessions_FullMethodName = "/hypurr.Static/HyperliquidWalletDeploySessions" + Static_HyperliquidWalletPerformance_FullMethodName = "/hypurr.Static/HyperliquidWalletPerformance" + Static_HyperliquidLaunch_FullMethodName = "/hypurr.Static/HyperliquidLaunch" + Static_HyperliquidLaunches_FullMethodName = "/hypurr.Static/HyperliquidLaunches" + Static_HyperliquidLaunchStream_FullMethodName = "/hypurr.Static/HyperliquidLaunchStream" + Static_HyperliquidLaunchFills_FullMethodName = "/hypurr.Static/HyperliquidLaunchFills" + Static_HyperliquidLaunchCandles_FullMethodName = "/hypurr.Static/HyperliquidLaunchCandles" + Static_HyperliquidLaunchCandleStream_FullMethodName = "/hypurr.Static/HyperliquidLaunchCandleStream" + Static_HyperliquidLaunchMessages_FullMethodName = "/hypurr.Static/HyperliquidLaunchMessages" + Static_LatestHyperliquidLaunchFills_FullMethodName = "/hypurr.Static/LatestHyperliquidLaunchFills" + Static_HyperliquidLaunchHolders_FullMethodName = "/hypurr.Static/HyperliquidLaunchHolders" + Static_HypurrFunCabals_FullMethodName = "/hypurr.Static/HypurrFunCabals" + Static_SetHyperliquidWalletDeploySessionTarget_FullMethodName = "/hypurr.Static/SetHyperliquidWalletDeploySessionTarget" + Static_DeleteHyperliquidWalletDeploySessionTarget_FullMethodName = "/hypurr.Static/DeleteHyperliquidWalletDeploySessionTarget" +) + +// StaticClient is the client API for Static service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type StaticClient interface { + HyperliquidDeployAuction(ctx context.Context, in *HyperliquidDeployAuctionRequest, opts ...grpc.CallOption) (*HyperliquidDeployAuctionResponse, error) + HyperliquidTokens(ctx context.Context, in *HyperliquidTokensRequest, opts ...grpc.CallOption) (*HyperliquidTokensResponse, error) + HyperliquidTokenHolders(ctx context.Context, in *HyperliquidTokenHoldersRequest, opts ...grpc.CallOption) (*HyperliquidTokenHoldersResponse, error) + HyperliquidTokenMessages(ctx context.Context, in *HyperliquidTokenMessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidTokenMessagesResponse], error) + HyperliquidSpotPair(ctx context.Context, in *HyperliquidSpotPairRequest, opts ...grpc.CallOption) (*HyperliquidSpotPairResponse, error) + HyperliquidSpotPairs(ctx context.Context, in *HyperliquidSpotPairsRequest, opts ...grpc.CallOption) (*HyperliquidSpotPairsResponse, error) + HyperliquidPerpPairs(ctx context.Context, in *HyperliquidPerpPairsRequest, opts ...grpc.CallOption) (*HyperliquidPerpPairsResponse, error) + HyperliquidWallet(ctx context.Context, in *HyperliquidWalletRequest, opts ...grpc.CallOption) (*HyperliquidWalletResponse, error) + HyperliquidWalletDeploySessions(ctx context.Context, in *HyperliquidWalletDeploySessionsRequest, opts ...grpc.CallOption) (*HyperliquidWalletDeploySessionsResponse, error) + HyperliquidWalletPerformance(ctx context.Context, in *HyperliquidWalletPerformanceRequest, opts ...grpc.CallOption) (*HyperliquidWalletPerformanceResponse, error) + HyperliquidLaunch(ctx context.Context, in *HyperliquidLaunchRequest, opts ...grpc.CallOption) (*HyperliquidLaunchResponse, error) + HyperliquidLaunches(ctx context.Context, in *HyperliquidLaunchesRequest, opts ...grpc.CallOption) (*HyperliquidLaunchesResponse, error) + HyperliquidLaunchStream(ctx context.Context, in *HyperliquidLaunchStreamRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchStreamResponse], error) + HyperliquidLaunchFills(ctx context.Context, in *HyperliquidLaunchFillsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchFillsResponse], error) + HyperliquidLaunchCandles(ctx context.Context, in *HyperliquidLaunchCandlesRequest, opts ...grpc.CallOption) (*HyperliquidLaunchCandlesResponse, error) + HyperliquidLaunchCandleStream(ctx context.Context, in *HyperliquidLaunchCandlesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchCandlesResponse], error) + HyperliquidLaunchMessages(ctx context.Context, in *HyperliquidLaunchMessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchMessagesResponse], error) + LatestHyperliquidLaunchFills(ctx context.Context, in *LatestHyperliquidLaunchFillsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchFillsResponse], error) + HyperliquidLaunchHolders(ctx context.Context, in *HyperliquidLaunchHoldersRequest, opts ...grpc.CallOption) (*HyperliquidLaunchHoldersResponse, error) + HypurrFunCabals(ctx context.Context, in *HypurrFunCabalsRequest, opts ...grpc.CallOption) (*HypurrFunCabalsResponse, error) + SetHyperliquidWalletDeploySessionTarget(ctx context.Context, in *SetHyperliquidWalletDeploySessionTargetRequest, opts ...grpc.CallOption) (*SetHyperliquidWalletDeploySessionTargetResponse, error) + DeleteHyperliquidWalletDeploySessionTarget(ctx context.Context, in *DeleteHyperliquidWalletDeploySessionTargetRequest, opts ...grpc.CallOption) (*DeleteHyperliquidWalletDeploySessionTargetResponse, error) +} + +type staticClient struct { + cc grpc.ClientConnInterface +} + +func NewStaticClient(cc grpc.ClientConnInterface) StaticClient { + return &staticClient{cc} +} + +func (c *staticClient) HyperliquidDeployAuction(ctx context.Context, in *HyperliquidDeployAuctionRequest, opts ...grpc.CallOption) (*HyperliquidDeployAuctionResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidDeployAuctionResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidDeployAuction_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidTokens(ctx context.Context, in *HyperliquidTokensRequest, opts ...grpc.CallOption) (*HyperliquidTokensResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidTokensResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidTokens_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidTokenHolders(ctx context.Context, in *HyperliquidTokenHoldersRequest, opts ...grpc.CallOption) (*HyperliquidTokenHoldersResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidTokenHoldersResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidTokenHolders_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidTokenMessages(ctx context.Context, in *HyperliquidTokenMessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidTokenMessagesResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Static_ServiceDesc.Streams[0], Static_HyperliquidTokenMessages_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[HyperliquidTokenMessagesRequest, HyperliquidTokenMessagesResponse]{ClientStream: 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 +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidTokenMessagesClient = grpc.ServerStreamingClient[HyperliquidTokenMessagesResponse] + +func (c *staticClient) HyperliquidSpotPair(ctx context.Context, in *HyperliquidSpotPairRequest, opts ...grpc.CallOption) (*HyperliquidSpotPairResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidSpotPairResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidSpotPair_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidSpotPairs(ctx context.Context, in *HyperliquidSpotPairsRequest, opts ...grpc.CallOption) (*HyperliquidSpotPairsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidSpotPairsResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidSpotPairs_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidPerpPairs(ctx context.Context, in *HyperliquidPerpPairsRequest, opts ...grpc.CallOption) (*HyperliquidPerpPairsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidPerpPairsResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidPerpPairs_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidWallet(ctx context.Context, in *HyperliquidWalletRequest, opts ...grpc.CallOption) (*HyperliquidWalletResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidWalletResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidWallet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidWalletDeploySessions(ctx context.Context, in *HyperliquidWalletDeploySessionsRequest, opts ...grpc.CallOption) (*HyperliquidWalletDeploySessionsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidWalletDeploySessionsResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidWalletDeploySessions_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidWalletPerformance(ctx context.Context, in *HyperliquidWalletPerformanceRequest, opts ...grpc.CallOption) (*HyperliquidWalletPerformanceResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidWalletPerformanceResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidWalletPerformance_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidLaunch(ctx context.Context, in *HyperliquidLaunchRequest, opts ...grpc.CallOption) (*HyperliquidLaunchResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidLaunchResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidLaunch_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidLaunches(ctx context.Context, in *HyperliquidLaunchesRequest, opts ...grpc.CallOption) (*HyperliquidLaunchesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidLaunchesResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidLaunches_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidLaunchStream(ctx context.Context, in *HyperliquidLaunchStreamRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchStreamResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Static_ServiceDesc.Streams[1], Static_HyperliquidLaunchStream_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[HyperliquidLaunchStreamRequest, HyperliquidLaunchStreamResponse]{ClientStream: 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 +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidLaunchStreamClient = grpc.ServerStreamingClient[HyperliquidLaunchStreamResponse] + +func (c *staticClient) HyperliquidLaunchFills(ctx context.Context, in *HyperliquidLaunchFillsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchFillsResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Static_ServiceDesc.Streams[2], Static_HyperliquidLaunchFills_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[HyperliquidLaunchFillsRequest, HyperliquidLaunchFillsResponse]{ClientStream: 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 +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidLaunchFillsClient = grpc.ServerStreamingClient[HyperliquidLaunchFillsResponse] + +func (c *staticClient) HyperliquidLaunchCandles(ctx context.Context, in *HyperliquidLaunchCandlesRequest, opts ...grpc.CallOption) (*HyperliquidLaunchCandlesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidLaunchCandlesResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidLaunchCandles_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HyperliquidLaunchCandleStream(ctx context.Context, in *HyperliquidLaunchCandlesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchCandlesResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Static_ServiceDesc.Streams[3], Static_HyperliquidLaunchCandleStream_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[HyperliquidLaunchCandlesRequest, HyperliquidLaunchCandlesResponse]{ClientStream: 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 +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidLaunchCandleStreamClient = grpc.ServerStreamingClient[HyperliquidLaunchCandlesResponse] + +func (c *staticClient) HyperliquidLaunchMessages(ctx context.Context, in *HyperliquidLaunchMessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchMessagesResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Static_ServiceDesc.Streams[4], Static_HyperliquidLaunchMessages_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[HyperliquidLaunchMessagesRequest, HyperliquidLaunchMessagesResponse]{ClientStream: 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 +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidLaunchMessagesClient = grpc.ServerStreamingClient[HyperliquidLaunchMessagesResponse] + +func (c *staticClient) LatestHyperliquidLaunchFills(ctx context.Context, in *LatestHyperliquidLaunchFillsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[HyperliquidLaunchFillsResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Static_ServiceDesc.Streams[5], Static_LatestHyperliquidLaunchFills_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[LatestHyperliquidLaunchFillsRequest, HyperliquidLaunchFillsResponse]{ClientStream: 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 +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_LatestHyperliquidLaunchFillsClient = grpc.ServerStreamingClient[HyperliquidLaunchFillsResponse] + +func (c *staticClient) HyperliquidLaunchHolders(ctx context.Context, in *HyperliquidLaunchHoldersRequest, opts ...grpc.CallOption) (*HyperliquidLaunchHoldersResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HyperliquidLaunchHoldersResponse) + err := c.cc.Invoke(ctx, Static_HyperliquidLaunchHolders_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) HypurrFunCabals(ctx context.Context, in *HypurrFunCabalsRequest, opts ...grpc.CallOption) (*HypurrFunCabalsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HypurrFunCabalsResponse) + err := c.cc.Invoke(ctx, Static_HypurrFunCabals_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) SetHyperliquidWalletDeploySessionTarget(ctx context.Context, in *SetHyperliquidWalletDeploySessionTargetRequest, opts ...grpc.CallOption) (*SetHyperliquidWalletDeploySessionTargetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SetHyperliquidWalletDeploySessionTargetResponse) + err := c.cc.Invoke(ctx, Static_SetHyperliquidWalletDeploySessionTarget_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *staticClient) DeleteHyperliquidWalletDeploySessionTarget(ctx context.Context, in *DeleteHyperliquidWalletDeploySessionTargetRequest, opts ...grpc.CallOption) (*DeleteHyperliquidWalletDeploySessionTargetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(DeleteHyperliquidWalletDeploySessionTargetResponse) + err := c.cc.Invoke(ctx, Static_DeleteHyperliquidWalletDeploySessionTarget_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// StaticServer is the server API for Static service. +// All implementations must embed UnimplementedStaticServer +// for forward compatibility. +type StaticServer interface { + HyperliquidDeployAuction(context.Context, *HyperliquidDeployAuctionRequest) (*HyperliquidDeployAuctionResponse, error) + HyperliquidTokens(context.Context, *HyperliquidTokensRequest) (*HyperliquidTokensResponse, error) + HyperliquidTokenHolders(context.Context, *HyperliquidTokenHoldersRequest) (*HyperliquidTokenHoldersResponse, error) + HyperliquidTokenMessages(*HyperliquidTokenMessagesRequest, grpc.ServerStreamingServer[HyperliquidTokenMessagesResponse]) error + HyperliquidSpotPair(context.Context, *HyperliquidSpotPairRequest) (*HyperliquidSpotPairResponse, error) + HyperliquidSpotPairs(context.Context, *HyperliquidSpotPairsRequest) (*HyperliquidSpotPairsResponse, error) + HyperliquidPerpPairs(context.Context, *HyperliquidPerpPairsRequest) (*HyperliquidPerpPairsResponse, error) + HyperliquidWallet(context.Context, *HyperliquidWalletRequest) (*HyperliquidWalletResponse, error) + HyperliquidWalletDeploySessions(context.Context, *HyperliquidWalletDeploySessionsRequest) (*HyperliquidWalletDeploySessionsResponse, error) + HyperliquidWalletPerformance(context.Context, *HyperliquidWalletPerformanceRequest) (*HyperliquidWalletPerformanceResponse, error) + HyperliquidLaunch(context.Context, *HyperliquidLaunchRequest) (*HyperliquidLaunchResponse, error) + HyperliquidLaunches(context.Context, *HyperliquidLaunchesRequest) (*HyperliquidLaunchesResponse, error) + HyperliquidLaunchStream(*HyperliquidLaunchStreamRequest, grpc.ServerStreamingServer[HyperliquidLaunchStreamResponse]) error + HyperliquidLaunchFills(*HyperliquidLaunchFillsRequest, grpc.ServerStreamingServer[HyperliquidLaunchFillsResponse]) error + HyperliquidLaunchCandles(context.Context, *HyperliquidLaunchCandlesRequest) (*HyperliquidLaunchCandlesResponse, error) + HyperliquidLaunchCandleStream(*HyperliquidLaunchCandlesRequest, grpc.ServerStreamingServer[HyperliquidLaunchCandlesResponse]) error + HyperliquidLaunchMessages(*HyperliquidLaunchMessagesRequest, grpc.ServerStreamingServer[HyperliquidLaunchMessagesResponse]) error + LatestHyperliquidLaunchFills(*LatestHyperliquidLaunchFillsRequest, grpc.ServerStreamingServer[HyperliquidLaunchFillsResponse]) error + HyperliquidLaunchHolders(context.Context, *HyperliquidLaunchHoldersRequest) (*HyperliquidLaunchHoldersResponse, error) + HypurrFunCabals(context.Context, *HypurrFunCabalsRequest) (*HypurrFunCabalsResponse, error) + SetHyperliquidWalletDeploySessionTarget(context.Context, *SetHyperliquidWalletDeploySessionTargetRequest) (*SetHyperliquidWalletDeploySessionTargetResponse, error) + DeleteHyperliquidWalletDeploySessionTarget(context.Context, *DeleteHyperliquidWalletDeploySessionTargetRequest) (*DeleteHyperliquidWalletDeploySessionTargetResponse, error) + mustEmbedUnimplementedStaticServer() +} + +// UnimplementedStaticServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedStaticServer struct{} + +func (UnimplementedStaticServer) HyperliquidDeployAuction(context.Context, *HyperliquidDeployAuctionRequest) (*HyperliquidDeployAuctionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidDeployAuction not implemented") +} +func (UnimplementedStaticServer) HyperliquidTokens(context.Context, *HyperliquidTokensRequest) (*HyperliquidTokensResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidTokens not implemented") +} +func (UnimplementedStaticServer) HyperliquidTokenHolders(context.Context, *HyperliquidTokenHoldersRequest) (*HyperliquidTokenHoldersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidTokenHolders not implemented") +} +func (UnimplementedStaticServer) HyperliquidTokenMessages(*HyperliquidTokenMessagesRequest, grpc.ServerStreamingServer[HyperliquidTokenMessagesResponse]) error { + return status.Errorf(codes.Unimplemented, "method HyperliquidTokenMessages not implemented") +} +func (UnimplementedStaticServer) HyperliquidSpotPair(context.Context, *HyperliquidSpotPairRequest) (*HyperliquidSpotPairResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidSpotPair not implemented") +} +func (UnimplementedStaticServer) HyperliquidSpotPairs(context.Context, *HyperliquidSpotPairsRequest) (*HyperliquidSpotPairsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidSpotPairs not implemented") +} +func (UnimplementedStaticServer) HyperliquidPerpPairs(context.Context, *HyperliquidPerpPairsRequest) (*HyperliquidPerpPairsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidPerpPairs not implemented") +} +func (UnimplementedStaticServer) HyperliquidWallet(context.Context, *HyperliquidWalletRequest) (*HyperliquidWalletResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidWallet not implemented") +} +func (UnimplementedStaticServer) HyperliquidWalletDeploySessions(context.Context, *HyperliquidWalletDeploySessionsRequest) (*HyperliquidWalletDeploySessionsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidWalletDeploySessions not implemented") +} +func (UnimplementedStaticServer) HyperliquidWalletPerformance(context.Context, *HyperliquidWalletPerformanceRequest) (*HyperliquidWalletPerformanceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidWalletPerformance not implemented") +} +func (UnimplementedStaticServer) HyperliquidLaunch(context.Context, *HyperliquidLaunchRequest) (*HyperliquidLaunchResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidLaunch not implemented") +} +func (UnimplementedStaticServer) HyperliquidLaunches(context.Context, *HyperliquidLaunchesRequest) (*HyperliquidLaunchesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidLaunches not implemented") +} +func (UnimplementedStaticServer) HyperliquidLaunchStream(*HyperliquidLaunchStreamRequest, grpc.ServerStreamingServer[HyperliquidLaunchStreamResponse]) error { + return status.Errorf(codes.Unimplemented, "method HyperliquidLaunchStream not implemented") +} +func (UnimplementedStaticServer) HyperliquidLaunchFills(*HyperliquidLaunchFillsRequest, grpc.ServerStreamingServer[HyperliquidLaunchFillsResponse]) error { + return status.Errorf(codes.Unimplemented, "method HyperliquidLaunchFills not implemented") +} +func (UnimplementedStaticServer) HyperliquidLaunchCandles(context.Context, *HyperliquidLaunchCandlesRequest) (*HyperliquidLaunchCandlesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidLaunchCandles not implemented") +} +func (UnimplementedStaticServer) HyperliquidLaunchCandleStream(*HyperliquidLaunchCandlesRequest, grpc.ServerStreamingServer[HyperliquidLaunchCandlesResponse]) error { + return status.Errorf(codes.Unimplemented, "method HyperliquidLaunchCandleStream not implemented") +} +func (UnimplementedStaticServer) HyperliquidLaunchMessages(*HyperliquidLaunchMessagesRequest, grpc.ServerStreamingServer[HyperliquidLaunchMessagesResponse]) error { + return status.Errorf(codes.Unimplemented, "method HyperliquidLaunchMessages not implemented") +} +func (UnimplementedStaticServer) LatestHyperliquidLaunchFills(*LatestHyperliquidLaunchFillsRequest, grpc.ServerStreamingServer[HyperliquidLaunchFillsResponse]) error { + return status.Errorf(codes.Unimplemented, "method LatestHyperliquidLaunchFills not implemented") +} +func (UnimplementedStaticServer) HyperliquidLaunchHolders(context.Context, *HyperliquidLaunchHoldersRequest) (*HyperliquidLaunchHoldersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HyperliquidLaunchHolders not implemented") +} +func (UnimplementedStaticServer) HypurrFunCabals(context.Context, *HypurrFunCabalsRequest) (*HypurrFunCabalsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HypurrFunCabals not implemented") +} +func (UnimplementedStaticServer) SetHyperliquidWalletDeploySessionTarget(context.Context, *SetHyperliquidWalletDeploySessionTargetRequest) (*SetHyperliquidWalletDeploySessionTargetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetHyperliquidWalletDeploySessionTarget not implemented") +} +func (UnimplementedStaticServer) DeleteHyperliquidWalletDeploySessionTarget(context.Context, *DeleteHyperliquidWalletDeploySessionTargetRequest) (*DeleteHyperliquidWalletDeploySessionTargetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteHyperliquidWalletDeploySessionTarget not implemented") +} +func (UnimplementedStaticServer) mustEmbedUnimplementedStaticServer() {} +func (UnimplementedStaticServer) testEmbeddedByValue() {} + +// UnsafeStaticServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to StaticServer will +// result in compilation errors. +type UnsafeStaticServer interface { + mustEmbedUnimplementedStaticServer() +} + +func RegisterStaticServer(s grpc.ServiceRegistrar, srv StaticServer) { + // If the following call pancis, it indicates UnimplementedStaticServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&Static_ServiceDesc, srv) +} + +func _Static_HyperliquidDeployAuction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidDeployAuctionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidDeployAuction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidDeployAuction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidDeployAuction(ctx, req.(*HyperliquidDeployAuctionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidTokens_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidTokensRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidTokens(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidTokens_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidTokens(ctx, req.(*HyperliquidTokensRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidTokenHolders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidTokenHoldersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidTokenHolders(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidTokenHolders_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidTokenHolders(ctx, req.(*HyperliquidTokenHoldersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidTokenMessages_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(HyperliquidTokenMessagesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(StaticServer).HyperliquidTokenMessages(m, &grpc.GenericServerStream[HyperliquidTokenMessagesRequest, HyperliquidTokenMessagesResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidTokenMessagesServer = grpc.ServerStreamingServer[HyperliquidTokenMessagesResponse] + +func _Static_HyperliquidSpotPair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidSpotPairRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidSpotPair(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidSpotPair_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidSpotPair(ctx, req.(*HyperliquidSpotPairRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidSpotPairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidSpotPairsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidSpotPairs(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidSpotPairs_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidSpotPairs(ctx, req.(*HyperliquidSpotPairsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidPerpPairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidPerpPairsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidPerpPairs(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidPerpPairs_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidPerpPairs(ctx, req.(*HyperliquidPerpPairsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidWalletRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidWallet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidWallet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidWallet(ctx, req.(*HyperliquidWalletRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidWalletDeploySessions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidWalletDeploySessionsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidWalletDeploySessions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidWalletDeploySessions_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidWalletDeploySessions(ctx, req.(*HyperliquidWalletDeploySessionsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidWalletPerformance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidWalletPerformanceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidWalletPerformance(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidWalletPerformance_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidWalletPerformance(ctx, req.(*HyperliquidWalletPerformanceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidLaunch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidLaunchRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidLaunch(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidLaunch_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidLaunch(ctx, req.(*HyperliquidLaunchRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidLaunches_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidLaunchesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidLaunches(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidLaunches_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidLaunches(ctx, req.(*HyperliquidLaunchesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidLaunchStream_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(HyperliquidLaunchStreamRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(StaticServer).HyperliquidLaunchStream(m, &grpc.GenericServerStream[HyperliquidLaunchStreamRequest, HyperliquidLaunchStreamResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidLaunchStreamServer = grpc.ServerStreamingServer[HyperliquidLaunchStreamResponse] + +func _Static_HyperliquidLaunchFills_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(HyperliquidLaunchFillsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(StaticServer).HyperliquidLaunchFills(m, &grpc.GenericServerStream[HyperliquidLaunchFillsRequest, HyperliquidLaunchFillsResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidLaunchFillsServer = grpc.ServerStreamingServer[HyperliquidLaunchFillsResponse] + +func _Static_HyperliquidLaunchCandles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidLaunchCandlesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidLaunchCandles(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidLaunchCandles_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidLaunchCandles(ctx, req.(*HyperliquidLaunchCandlesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HyperliquidLaunchCandleStream_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(HyperliquidLaunchCandlesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(StaticServer).HyperliquidLaunchCandleStream(m, &grpc.GenericServerStream[HyperliquidLaunchCandlesRequest, HyperliquidLaunchCandlesResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidLaunchCandleStreamServer = grpc.ServerStreamingServer[HyperliquidLaunchCandlesResponse] + +func _Static_HyperliquidLaunchMessages_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(HyperliquidLaunchMessagesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(StaticServer).HyperliquidLaunchMessages(m, &grpc.GenericServerStream[HyperliquidLaunchMessagesRequest, HyperliquidLaunchMessagesResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_HyperliquidLaunchMessagesServer = grpc.ServerStreamingServer[HyperliquidLaunchMessagesResponse] + +func _Static_LatestHyperliquidLaunchFills_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(LatestHyperliquidLaunchFillsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(StaticServer).LatestHyperliquidLaunchFills(m, &grpc.GenericServerStream[LatestHyperliquidLaunchFillsRequest, HyperliquidLaunchFillsResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Static_LatestHyperliquidLaunchFillsServer = grpc.ServerStreamingServer[HyperliquidLaunchFillsResponse] + +func _Static_HyperliquidLaunchHolders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HyperliquidLaunchHoldersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HyperliquidLaunchHolders(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HyperliquidLaunchHolders_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HyperliquidLaunchHolders(ctx, req.(*HyperliquidLaunchHoldersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_HypurrFunCabals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HypurrFunCabalsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).HypurrFunCabals(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_HypurrFunCabals_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).HypurrFunCabals(ctx, req.(*HypurrFunCabalsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_SetHyperliquidWalletDeploySessionTarget_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetHyperliquidWalletDeploySessionTargetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).SetHyperliquidWalletDeploySessionTarget(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_SetHyperliquidWalletDeploySessionTarget_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).SetHyperliquidWalletDeploySessionTarget(ctx, req.(*SetHyperliquidWalletDeploySessionTargetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Static_DeleteHyperliquidWalletDeploySessionTarget_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteHyperliquidWalletDeploySessionTargetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StaticServer).DeleteHyperliquidWalletDeploySessionTarget(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Static_DeleteHyperliquidWalletDeploySessionTarget_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StaticServer).DeleteHyperliquidWalletDeploySessionTarget(ctx, req.(*DeleteHyperliquidWalletDeploySessionTargetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Static_ServiceDesc is the grpc.ServiceDesc for Static service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Static_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "hypurr.Static", + HandlerType: (*StaticServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "HyperliquidDeployAuction", + Handler: _Static_HyperliquidDeployAuction_Handler, + }, + { + MethodName: "HyperliquidTokens", + Handler: _Static_HyperliquidTokens_Handler, + }, + { + MethodName: "HyperliquidTokenHolders", + Handler: _Static_HyperliquidTokenHolders_Handler, + }, + { + MethodName: "HyperliquidSpotPair", + Handler: _Static_HyperliquidSpotPair_Handler, + }, + { + MethodName: "HyperliquidSpotPairs", + Handler: _Static_HyperliquidSpotPairs_Handler, + }, + { + MethodName: "HyperliquidPerpPairs", + Handler: _Static_HyperliquidPerpPairs_Handler, + }, + { + MethodName: "HyperliquidWallet", + Handler: _Static_HyperliquidWallet_Handler, + }, + { + MethodName: "HyperliquidWalletDeploySessions", + Handler: _Static_HyperliquidWalletDeploySessions_Handler, + }, + { + MethodName: "HyperliquidWalletPerformance", + Handler: _Static_HyperliquidWalletPerformance_Handler, + }, + { + MethodName: "HyperliquidLaunch", + Handler: _Static_HyperliquidLaunch_Handler, + }, + { + MethodName: "HyperliquidLaunches", + Handler: _Static_HyperliquidLaunches_Handler, + }, + { + MethodName: "HyperliquidLaunchCandles", + Handler: _Static_HyperliquidLaunchCandles_Handler, + }, + { + MethodName: "HyperliquidLaunchHolders", + Handler: _Static_HyperliquidLaunchHolders_Handler, + }, + { + MethodName: "HypurrFunCabals", + Handler: _Static_HypurrFunCabals_Handler, + }, + { + MethodName: "SetHyperliquidWalletDeploySessionTarget", + Handler: _Static_SetHyperliquidWalletDeploySessionTarget_Handler, + }, + { + MethodName: "DeleteHyperliquidWalletDeploySessionTarget", + Handler: _Static_DeleteHyperliquidWalletDeploySessionTarget_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "HyperliquidTokenMessages", + Handler: _Static_HyperliquidTokenMessages_Handler, + ServerStreams: true, + }, + { + StreamName: "HyperliquidLaunchStream", + Handler: _Static_HyperliquidLaunchStream_Handler, + ServerStreams: true, + }, + { + StreamName: "HyperliquidLaunchFills", + Handler: _Static_HyperliquidLaunchFills_Handler, + ServerStreams: true, + }, + { + StreamName: "HyperliquidLaunchCandleStream", + Handler: _Static_HyperliquidLaunchCandleStream_Handler, + ServerStreams: true, + }, + { + StreamName: "HyperliquidLaunchMessages", + Handler: _Static_HyperliquidLaunchMessages_Handler, + ServerStreams: true, + }, + { + StreamName: "LatestHyperliquidLaunchFills", + Handler: _Static_LatestHyperliquidLaunchFills_Handler, + ServerStreams: true, + }, + }, + Metadata: "hypurr.proto", +}