Go SDK

Installation

go get github.com/jonah-space/poltrading/sdk

Quick Start

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/jonah-space/poltrading/sdk"
)

func main() {
    client := sdk.NewClient(
        sdk.WithBaseURL("https://outpost.poltrading.com"),
        sdk.WithHMACKey("your-hex-hmac-key"),
    )

    ctx := context.Background()

    // List markets
    markets, err := client.ListMarkets(ctx)
    if err != nil {
        log.Fatal(err)
    }
    for _, m := range markets {
        fmt.Printf("Market: %s\n", m.ConditionID)
    }

    // Get quote
    quote, err := client.GetQuote(ctx, "0x0000...0001")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Price: %s\n", quote.Price)

    // Submit order
    result, err := client.SubmitOrder(ctx, &sdk.Order{
        MarketID: "0x0000...0001",
        Payload:  signedOrderBytes,
        Deadline: time.Now().Add(5 * time.Minute).Unix(),
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Order result: %+v\n", result)
}

API Reference

sdk.NewClient(opts ...Option) *Client

Create a new client with functional options.

Options

Option	Description
sdk.WithBaseURL(url)	Set Outpost endpoint
sdk.WithHMACKey(key)	Set hex-encoded HMAC key
sdk.WithTimeout(d)	Set request timeout
sdk.WithHTTPClient(c)	Use custom *http.Client

Methods

Method	Description
client.ListMarkets(ctx) ([]Market, error)	List active markets
client.GetMarket(ctx, id) (*Market, error)	Get market by condition ID
client.GetQuote(ctx, id) (*Quote, error)	Get quote data
client.SubmitOrder(ctx, *Order) (*OrderResult, error)	Submit signed order
client.Healthz(ctx) (*Health, error)	Get health status

HMAC Signing

func signRequest(hmacKey string, body []byte) map[string]string {
    timestamp := strconv.FormatInt(time.Now().Unix(), 10)
    nonce := make([]byte, 16)
    rand.Read(nonce)
    nonceHex := hex.EncodeToString(nonce)

    mac := hmac.New(sha256.New, []byte(hmacKey))
    mac.Write([]byte(timestamp + "." + nonceHex + "."))
    mac.Write(body)
    sig := "v1=" + hex.EncodeToString(mac.Sum(nil))

    return map[string]string{
        "X-Outpost-Timestamp": timestamp,
        "X-Outpost-Nonce":     nonceHex,
        "X-Outpost-Signature": sig,
    }
}

Error Handling

result, err := client.SubmitOrder(ctx, order)
if err != nil {
    var geoErr *sdk.GeoBlockedError
    if errors.As(err, &geoErr) {
        fmt.Printf("Access blocked in: %s\n", geoErr.Country)
    } else {
        log.Printf("API error: %v", err)
    }
}

Context Propagation

All methods accept context.Context for cancellation and timeouts:

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

markets, err := client.ListMarkets(ctx)