gRPC

Stream real-time trading signals as they are generated by Guardis. Signals are dispatched immediately upon detection, giving you the fastest possible access to actionable opportunities.

Endpoint

enterprise.guardis.io:443

Authentication

Include your API key in the request metadata using the x-api-key field.

x-api-key: your_api_key_here

---

Service Definition

syntax = "proto3";

package enterprise.v1;

import "google/protobuf/timestamp.proto";

// SignalStreamService provides real-time trading signal streaming
service SignalStreamService {
  // StreamSignals streams signal events to connected clients in real-time
  // Signals are emitted when the indicator service detects trading opportunities
  rpc StreamSignals(SignalStreamRequest) returns (stream SignalUpdate);
}

// Request to start streaming signals
message SignalStreamRequest {
  // Optional: Filter by model names. If empty, all signals are streamed.
  // Supported values: "influx_high_on_dip", "smart_money_bounce"
  repeated string model_names = 1;
}

// A trading signal update
message SignalUpdate {
  // The token contract address
  string token_address = 1;
  // The liquidity pool pair address
  string pair_address = 2;
  // Token image URL (optional)
  optional string image = 3;
  // Token name
  string name = 4;
  // Token symbol
  string symbol = 5;
  // Market cap at signal time (as string to preserve precision)
  string signal_market_cap = 6;
  // The model that generated this signal
  string model_name = 7;
  // Timestamp when the signal was generated
  google.protobuf.Timestamp timestamp = 8;
}

---

Request Parameters

StreamSignalsRequest

Field	Type	Required	Description
model_name	string	No	Filter by model name. If omitted, signals from all models are streamed

---

Response Format

Signal

Field	Type	Description
row_id	int64	Unique identifier for this signal
token_address	string	The mint address of the token
pair_address	string	The on-chain address of the liquidity pool
image	string	URL to the token image
name	string	Token name
symbol	string	Token ticker symbol
signal_market_cap	string	Market cap at the time of signal generation (USD)
liquidity_usd	string	Pool liquidity at signal time (USD)
ath_market_cap_usd	string	All-time high market cap achieved after signal (USD)
roi_percentage	string	Maximum ROI percentage from signal to ATH
max_drawdown_percentage	string	Maximum drawdown percentage before reaching ATH
max_drawdown_market_cap	string	Market cap at the point of maximum drawdown (USD)
version	int32	Signal model version
model_name	string	Name of the model that generated this signal
created_at	google.protobuf.Timestamp	Timestamp when the signal was generated

Note: Decimal values are returned as strings to preserve precision.

---

Example Usage

Python:

import grpc
from guardis.signals.v1 import signals_pb2, signals_pb2_grpc

metadata = [("x-api-key", "your_api_key_here")]

with grpc.secure_channel("enterprise.guardis.io:443", grpc.ssl_channel_credentials()) as channel:
    stub = signals_pb2_grpc.SignalsServiceStub(channel)
    
    # Stream all signals
    request = signals_pb2.StreamSignalsRequest()
    
    # Or filter by model
    # request = signals_pb2.StreamSignalsRequest(model_name="influx_high_on_dip")
    
    for signal in stub.StreamSignals(request, metadata=metadata):
        print(f"🚀 New Signal: {signal.name} ({signal.symbol})")
        print(f"   Token: {signal.token_address}")
        print(f"   Market Cap: ${float(signal.signal_market_cap):,.2f}")
        print(f"   Model: {signal.model_name}")
        print(f"   Historical ROI: {float(signal.roi_percentage):.2f}%")
        
        # Execute your trading logic here

Go:

package main

import (
    "context"
    "log"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "google.golang.org/grpc/metadata"
    
    pb "github.com/your-org/guardis-go/signals/v1"
)

func main() {
    creds := credentials.NewTLS(nil)
    conn, err := grpc.Dial("enterprise.guardis.io:443", grpc.WithTransportCredentials(creds))
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }
    defer conn.Close()

    client := pb.NewSignalsServiceClient(conn)

    ctx := metadata.AppendToOutgoingContext(
        context.Background(),
        "x-api-key", "your_api_key_here",
    )

    // Stream all signals
    request := &pb.StreamSignalsRequest{}
    
    // Or filter by model
    // request := &pb.StreamSignalsRequest{ModelName: proto.String("influx_high_on_dip")}

    stream, err := client.StreamSignals(ctx, request)
    if err != nil {
        log.Fatalf("Failed to stream: %v", err)
    }

    for {
        signal, err := stream.Recv()
        if err != nil {
            log.Fatalf("Stream error: %v", err)
        }
        
        log.Printf("🚀 New Signal: %s (%s)", signal.Name, signal.Symbol)
        log.Printf("   Token: %s", signal.TokenAddress)
        log.Printf("   Market Cap: $%s", signal.SignalMarketCap)
        log.Printf("   Model: %s", signal.ModelName)
        log.Printf("   Historical ROI: %s%%", signal.RoiPercentage)
        
        // Execute your trading logic here
    }
}

---

Connection Best Practices

• Act quickly — Signals are time-sensitive; process them immediately upon receipt

• Implement reconnection logic — Network interruptions happen; automatically reconnect with exponential backoff

• Use deadlines — Set appropriate deadlines for your streaming calls to handle stale connections

• Handle stream errors gracefully — Check for io.EOF and gRPC status codes to determine if reconnection is needed

• Log signals — Maintain a local record of received signals for analysis and debugging