Signals.

// Module 17, Signal dispatcher (webhook → validate → size → place).

import express from 'express';
import {
  HttpClient,
  MarketFetcher,
  OrderClient,
  Side,
  OrderType,
  ApiError,
} from '@limitless-exchange/sdk';
import { Wallet } from 'ethers';
import { cappedKelly } from './kelly';  // from Module 14

interface Signal {
  id:          string;        // stable per source-event → powers idempotency
  slug:        string;
  side:        'YES' | 'NO';
  probability: number;        // your estimate in [0, 1]
  marketPrice: number;        // market's current price
  source:      string;
}

const app = express();
app.use(express.json());

const httpClient    = new HttpClient({ apiKey: process.env.LIMITLESS_API_KEY });
const marketFetcher = new MarketFetcher(httpClient);
const wallet        = new Wallet(process.env.PRIVATE_KEY!);
const orderClient   = new OrderClient({ httpClient, wallet, marketFetcher });

const SHARED_SECRET = process.env.SIGNAL_SECRET ?? '';

app.post('/signal', async (req, res) => {
  if (req.header('x-signal-secret') !== SHARED_SECRET) return res.sendStatus(401);

  const sig = req.body as Signal;
  if (!sig.id || !sig.slug) return res.sendStatus(400);
  if (sig.probability <= 0 || sig.probability >= 1) return res.sendStatus(400);
  if (Math.abs(sig.probability - sig.marketPrice) < 0.03) return res.sendStatus(204); // no edge

  const fraction = cappedKelly({
    probability: sig.probability,
    marketPrice: sig.marketPrice,
    nav:         10_000,
  });
  const makerAmount = Math.floor(fraction * 10_000);
  if (makerAmount <= 0) return res.sendStatus(204);

  const market  = await marketFetcher.getMarket(sig.slug);
  const tokenId = sig.side === 'YES' ? market.positionIds[0] : market.positionIds[1];

  try {
    const result = await orderClient.createOrder({
      marketSlug:    sig.slug,
      tokenId,
      side:          Side.BUY,
      makerAmount,
      orderType:     OrderType.FOK,
      clientOrderId: `signal-${sig.id}`,       // 409 on duplicate deliveries
    });

    res.json({
      ok:               true,
      orderId:          result.order.id,
      settlementStatus: result.execution.settlementStatus,
      txHash:           result.execution.txHash ?? null,
    });
  } catch (err) {
    if (err instanceof ApiError && err.status === 409) {
      return res.json({ ok: true, duplicate: true });
    }
    throw err;
  }
});

app.listen(8080, () => console.log('signal dispatcher listening on :8080'));

# Module 17, Signal dispatcher (webhook → validate → size → place).

import os
from fastapi import FastAPI, Header, HTTPException, Request
from eth_account import Account
from limitless_sdk.api import HttpClient, APIError
from limitless_sdk.markets import MarketFetcher
from limitless_sdk.orders import OrderClient
from limitless_sdk.types import Side, OrderType

from kelly import capped_kelly, KellyOpts  # from Module 14

app = FastAPI()

http_client    = HttpClient()
market_fetcher = MarketFetcher(http_client)
wallet         = Account.from_key(os.environ["PRIVATE_KEY"])
order_client   = OrderClient(http_client, wallet=wallet, market_fetcher=market_fetcher)

SHARED_SECRET = os.environ.get("SIGNAL_SECRET", "")


@app.post("/signal")
async def receive_signal(
    req: Request,
    x_signal_secret: str = Header(default=""),
) -> dict:
    if x_signal_secret != SHARED_SECRET:
        raise HTTPException(401)

    sig = await req.json()
    if not sig.get("id") or not sig.get("slug"):
        raise HTTPException(400)
    if not (0 < sig["probability"] < 1):
        raise HTTPException(400)
    if abs(sig["probability"] - sig["market_price"]) < 0.03:
        return {"ok": True, "skipped": "no_edge"}

    fraction = capped_kelly(KellyOpts(
        probability=sig["probability"],
        market_price=sig["market_price"],
        nav=10_000,
    ))
    maker_amount = float(int(fraction * 10_000))
    if maker_amount <= 0:
        return {"ok": True, "skipped": "zero_size"}

    market   = await market_fetcher.get_market(sig["slug"])
    token_id = market["positionIds"][0 if sig["side"] == "YES" else 1]

    try:
        result = await order_client.create_order(
            token_id=token_id,
            maker_amount=maker_amount,
            side=Side.BUY,
            order_type=OrderType.FOK,
            market_slug=sig["slug"],
            client_order_id=f"signal-{sig['id']}",   # 409 on duplicate deliveries
        )
    except APIError as e:
        if e.status_code == 409:
            return {"ok": True, "duplicate": True}
        raise

    return {
        "ok":                True,
        "order_id":          result["order"]["id"],
        "settlement_status": result["execution"]["settlementStatus"],
        "tx_hash":           result["execution"].get("txHash"),
    }

// Module 17, Signal dispatcher (webhook → validate → size → place).

package main

import (
    "context"
    "encoding/json"
    "errors"
    "log"
    "math"
    "net/http"
    "os"

    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

type Signal struct {
    ID          string  `json:"id"`           // stable per source-event
    Slug        string  `json:"slug"`
    Side        string  `json:"side"`         // "YES" | "NO"
    Probability float64 `json:"probability"`
    MarketPrice float64 `json:"market_price"`
    Source      string  `json:"source"`
}

// cappedKelly from Module 14
func cappedKelly(p, price, cap float64) float64 {
    b := (1 - price) / price
    f := (p*b - (1 - p)) / b
    return math.Min(math.Max(0, 0.5*f), cap)
}

func main() {
    ctx := context.Background()

    client        := limitless.NewHttpClient()
    marketFetcher := limitless.NewMarketFetcher(client)
    orderClient, err := limitless.NewOrderClient(client, os.Getenv("PRIVATE_KEY"))
    if err != nil { log.Fatal(err) }

    secret := os.Getenv("SIGNAL_SECRET")

    http.HandleFunc("/signal", func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("x-signal-secret") != secret {
            http.Error(w, "unauthorized", http.StatusUnauthorized); return
        }
        var sig Signal
        if err := json.NewDecoder(r.Body).Decode(&sig); err != nil {
            http.Error(w, "bad json", http.StatusBadRequest); return
        }
        if sig.ID == "" || sig.Slug == "" ||
           sig.Probability <= 0 || sig.Probability >= 1 {
            http.Error(w, "bad signal", http.StatusBadRequest); return
        }
        if math.Abs(sig.Probability-sig.MarketPrice) < 0.03 {
            w.WriteHeader(http.StatusNoContent); return
        }

        fraction    := cappedKelly(sig.Probability, sig.MarketPrice, 0.05)
        makerAmount := float64(int(fraction * 10_000))
        if makerAmount <= 0 {
            w.WriteHeader(http.StatusNoContent); return
        }

        market, err := marketFetcher.GetMarket(ctx, sig.Slug)
        if err != nil { http.Error(w, err.Error(), http.StatusBadGateway); return }

        tokenID := market.Tokens.Yes
        if sig.Side == "NO" { tokenID = market.Tokens.No }

        result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
            OrderType:     limitless.OrderTypeFOK,
            MarketSlug:    sig.Slug,
            ClientOrderID: "signal-" + sig.ID,           // 409 on duplicates
            Args: limitless.FOKOrderArgs{
                TokenID:     tokenID,
                Side:        limitless.SideBuy,
                MakerAmount: makerAmount,
            },
        })

        var apiErr *limitless.APIError
        if errors.As(err, &apiErr) && apiErr.Status == 409 {
            _ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "duplicate": true})
            return
        }
        if err != nil { http.Error(w, err.Error(), http.StatusBadGateway); return }

        _ = json.NewEncoder(w).Encode(map[string]any{
            "ok":                true,
            "order_id":          result.Order.ID,
            "settlement_status": result.Execution.SettlementStatus,
            "tx_hash":           result.Execution.TxHash,
        })
    })

    http.ListenAndServe(":8080", nil)
}