✨ feat: add Casper payment simulation and client integration

Implement Casper payment simulation in settler demo mode, introducing a new client for interacting with CSPR.cloud x402 Facilitator.

- Add support for Casper network in blockchain package
- Enhance header and middleware to handle new payment scheme
- Update go.work to include settler command
- Refactor main.go to incorporate new demo functionality

Author: nathfavour

cmd/settler/main.go

@@ -93,6 +93,28 @@ func runConfig(args []string) {
 }
 
 func runDemo(args []string) {
+	fs := flag.NewFlagSet("demo", flag.ExitOnError)
+	useCasper := fs.Bool("casper", false, "Simulate Casper agent payment verification loop")
+	fs.Parse(args)
+
+	if *useCasper {
+		fmt.Println("🎬 Starting SettlerEngine Agentic Demo (Casper-Native Mode)...")
+		fmt.Println("🤖 [1/3] Generating Casper Ed25519 mock signer parameters...")
+		mockSig := "dGVzdC1zaWduYXR1cmUtYmFzZTY0" // base64 payload "test-signature-base64"
+		fmt.Printf("✅ Mock Signer Signature: %s\n", mockSig)
+
+		fmt.Println("💰 [2/3] Simulating Casper payment challenge parsing...")
+		fmt.Println("Challenge schema matched: Accepts -> Scheme: casper-native, Network: casper-testnet")
+
+		fmt.Println("⚓ [3/3] Triggering Casper Facilitator Verification API...")
+		// Print successful trace mimicking off-chain validation loop
+		fmt.Println("✅ Casper Facilitator: Signature and Nonce validated successfully via off-chain credentials.")
+		fmt.Println("✅ Casper Facilitator: Transferred 1,000,000,000 motes to recipient.")
+		fmt.Println("🚀 SUCCESS! Casper transaction broadcasted.")
+		fmt.Println("🔗 Transaction Hash: 0x9a8b7c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f1a0b")
+		return
+	}
+
 	fmt.Println("🎬 Starting SettlerEngine Agentic Demo...")
 
 	cfg, _ := config.LoadConfig()
@@ -221,8 +243,8 @@ func runProxy(args []string) {
 	target := fs.String("target", "http://localhost:8081", "Target URL to proxy to")
 	listen := fs.String("listen", ":8080", "Listen address")
 	recipient := fs.String("recipient", "0x1234567890AbcdEF1234567890aBcdef12345678", "Merchant recipient address")
-	chainID := fs.Int64("chain-id", 84532, "Chain ID (default Base Sepolia)")
-	asset := fs.String("asset", "0x036CbD53842c5426634e7929541eC2318f3dCF7e", "Asset address (USDC)")
+	chainIDStr := fs.String("chain-id", "84532", "Chain ID (default Base Sepolia or 'casper-testnet')")
+	asset := fs.String("asset", "0x036CbD53842c5426634e7929541eC2318f3dCF7e", "Asset address (USDC) or 'CSPR'")
 	amount := fs.String("amount", "1000000", "Amount in atomic units")
 	fs.Parse(args)
 
@@ -248,9 +270,20 @@ func runProxy(args []string) {
 
 	proxy := httputil.NewSingleHostReverseProxy(targetURL)
 
+	var parsedChainID *big.Int
+	if *chainIDStr == "casper-testnet" {
+		parsedChainID = big.NewInt(0)
+	} else {
+		id, ok := new(big.Int).SetString(*chainIDStr, 10)
+		if !ok {
+			id = big.NewInt(84532)
+		}
+		parsedChainID = id
+	}
+
 	cfg := x402.Config{
 		DomainParams: crypto.DomainParams{
-			ChainID:           big.NewInt(*chainID),
+			ChainID:           parsedChainID,
 			VerifyingContract: common.HexToAddress("0x0000000000000000000000000000000000000000"),
 		},
 		NonceExpiry: 5 * time.Minute,

go.work

@@ -6,4 +6,5 @@ use (
 	./apps/settlerd
 	./core
 	./pkg
+	./cmd/settler
 )

internal/ports/blockchain.go

@@ -14,6 +14,7 @@ const (
 	NetworkMonero   ChainNetwork = "XMR"
 	NetworkSolana   ChainNetwork = "SOL"
 	NetworkTron     ChainNetwork = "TRX"
+	NetworkCasper   ChainNetwork = "CSPR"
 )
 
 type InvoicePaymentSignal struct {

pkg/crypto/casper/client.go

@@ -0,0 +1,145 @@
+package casper
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+// PaymentDetails represents the payment transaction parameters verified/settled by CSPR.cloud x402 Facilitator.
+type PaymentDetails struct {
+	Recipient string `json:"recipient"` // Casper public key hex
+	Amount    string `json:"amount"`    // Amount in motes (1 CSPR = 10^9 motes)
+	Asset     string `json:"asset"`     // e.g. "CSPR"
+	Nonce     string `json:"nonce"`     // Unique session UUID for replay protection
+	Network   string `json:"network"`   // e.g. "casper-testnet"
+}
+
+// CasperFacilitatorClient represents the client wrapper for interacting with CSPR.cloud x402 Facilitator.
+type CasperFacilitatorClient struct {
+	BaseURL    string
+	APIKey     string
+	HTTPClient *http.Client
+}
+
+// NewCasperFacilitatorClient initializes a new Casper x402 Facilitator client.
+func NewCasperFacilitatorClient(baseURL, apiKey string) *CasperFacilitatorClient {
+	if baseURL == "" {
+		baseURL = "https://x402-facilitator.cspr.cloud"
+	}
+	return &CasperFacilitatorClient{
+		BaseURL: baseURL,
+		APIKey:  apiKey,
+		HTTPClient: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+	}
+}
+
+type verifyRequest struct {
+	Signature string         `json:"signature"` // base64-encoded Casper Ed25519 signature
+	Details   PaymentDetails `json:"details"`
+}
+
+type verifyResponse struct {
+	Valid bool   `json:"valid"`
+	Error string `json:"error,omitempty"`
+}
+
+type settleRequest struct {
+	Signature string         `json:"signature"` // base64-encoded Casper Ed25519 signature
+	Details   PaymentDetails `json:"details"`
+}
+
+type settleResponse struct {
+	TxHash string `json:"txHash"`
+	Error  string `json:"error,omitempty"`
+}
+
+// VerifyPayload sends the payment signature and details to the facilitator for verification.
+func (c *CasperFacilitatorClient) VerifyPayload(signature string, details PaymentDetails) (bool, error) {
+	url := fmt.Sprintf("%s/verify", c.BaseURL)
+	reqBody, err := json.Marshal(verifyRequest{
+		Signature: signature,
+		Details:   details,
+	})
+	if err != nil {
+		return false, fmt.Errorf("failed to marshal verify request: %w", err)
+	}
+
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(reqBody))
+	if err != nil {
+		return false, fmt.Errorf("failed to create http request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if c.APIKey != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.APIKey))
+	}
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return false, fmt.Errorf("failed to send verify request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return false, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	var res verifyResponse
+	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
+		return false, fmt.Errorf("failed to decode verify response: %w", err)
+	}
+
+	if res.Error != "" {
+		return false, fmt.Errorf("facilitator error: %s", res.Error)
+	}
+
+	return res.Valid, nil
+}
+
+// SettlePayload forwards the signature and details to the facilitator to execute the Casper payment.
+func (c *CasperFacilitatorClient) SettlePayload(signature string, details PaymentDetails) (string, error) {
+	url := fmt.Sprintf("%s/settle", c.BaseURL)
+	reqBody, err := json.Marshal(settleRequest{
+		Signature: signature,
+		Details:   details,
+	})
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal settle request: %w", err)
+	}
+
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(reqBody))
+	if err != nil {
+		return "", fmt.Errorf("failed to create http request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if c.APIKey != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.APIKey))
+	}
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("failed to send settle request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	var res settleResponse
+	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
+		return "", fmt.Errorf("failed to decode settle response: %w", err)
+	}
+
+	if res.Error != "" {
+		return "", fmt.Errorf("facilitator error: %s", res.Error)
+	}
+
+	return res.TxHash, nil
+}

pkg/x402/header.go

@@ -11,12 +11,14 @@ import (
 const (
 	HeaderPayment          = "X-Payment"
 	HeaderPaymentSignature = "X-Payment-Signature"
+	HeaderPaymentRequired  = "Payment-Required"
 )
 
 // PaymentPayload represents the data extracted from the payment header.
 type PaymentPayload struct {
 	Intent    crypto.IntentToPay `json:"intent"`
 	Signature string             `json:"signature"`
+	Scheme    string             `json:"scheme,omitempty"`
 }
 
 // ParseHeader extracts and decodes the payment information from a request.
@@ -30,9 +32,14 @@ func ParseHeader(r *http.Request) (*PaymentPayload, error) {
 		return &payload, nil
 	}
 
-	// Fallback to separate signature header (simplified version)
-	// This would require the intent to be reconstructible or passed elsewhere.
-	// For MVP, we'll focus on the self-contained JSON payload.
+	// Fallback to separate signature header (X-Payment-Signature)
+	if sig := r.Header.Get(HeaderPaymentSignature); sig != "" {
+		// Attempt to reconstruct or build a minimal payload using URL query parameters or default headers.
+		return &PaymentPayload{
+			Signature: sig,
+			Scheme:    "casper-native",
+		}, nil
+	}
 
 	return nil, fmt.Errorf("no payment header found")
 }

pkg/x402/middleware.go

@@ -12,6 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/nathfavour/settlerengine/internal/ports"
 	"github.com/nathfavour/settlerengine/pkg/crypto"
+	"github.com/nathfavour/settlerengine/pkg/crypto/casper"
 	"github.com/nathfavour/settlerengine/pkg/storage"
 )
 
@@ -24,25 +25,28 @@ const (
 
 // Config defines the configuration for the x402 middleware.
 type Config struct {
-	DomainParams  crypto.DomainParams
-	NonceExpiry   time.Duration
-	Recipient     string
-	Asset         string
-	Amount        string
-	PriceResolver PriceResolver
-	DB            *storage.DB
-	Registry      ports.AgentRegistry
-	MinReputation *big.Int // Optional: block agents with score below this
+	DomainParams           crypto.DomainParams
+	NonceExpiry            time.Duration
+	Recipient              string
+	Asset                  string
+	Amount                 string
+	PriceResolver          PriceResolver
+	DB                     *storage.DB
+	Registry               ports.AgentRegistry
+	MinReputation          *big.Int // Optional: block agents with score below this
+	CasperFacilitatorURL   string
+	CasperFacilitatorToken string
 }
 
 // PriceResolver dynamically determines the payment requirements for a request.
 type PriceResolver func(r *http.Request) (amount, asset, recipient string, err error)
 
 // Middleware handles the x402 handshake.
 type Middleware struct {
-	config   Config
-	nonces   *NonceManager
-	verified sync.Map // Map of signature hash to Address
+	config       Config
+	nonces       *NonceManager
+	verified     sync.Map // Map of signature hash to Address
+	casperClient *casper.CasperFacilitatorClient
 }
 
 func NewMiddleware(cfg Config) *Middleware {
@@ -53,8 +57,9 @@ func NewMiddleware(cfg Config) *Middleware {
 	}
 
 	return &Middleware{
-		config: cfg,
-		nonces: NewNonceManager(),
+		config:       cfg,
+		nonces:       NewNonceManager(),
+		casperClient: casper.NewCasperFacilitatorClient(cfg.CasperFacilitatorURL, cfg.CasperFacilitatorToken),
 	}
 }
 
@@ -76,6 +81,38 @@ func (m *Middleware) Handler(next http.Handler) http.Handler {
 		// 1. Try to parse payment header
 		payload, err := ParseHeader(r)
 		if err == nil {
+			// Check if we are running in Casper mode (either explicitly marked, or chain-id is casper-testnet)
+			isCasper := payload.Scheme == "casper-native" || 
+				m.config.DomainParams.ChainID != nil && m.config.DomainParams.ChainID.String() == "0" && m.config.Asset == "CSPR" ||
+				payload.Intent.Asset == "CSPR"
+
+			if isCasper {
+				// Verify via Casper Facilitator
+				details := casper.PaymentDetails{
+					Recipient: m.config.Recipient,
+					Amount:    m.config.Amount,
+					Asset:     "CSPR",
+					Nonce:     payload.Intent.Nonce,
+					Network:   "casper-testnet",
+				}
+				if details.Nonce == "" {
+					details.Nonce = "demo-nonce"
+				}
+
+				valid, err := m.casperClient.VerifyPayload(payload.Signature, details)
+				if err == nil && valid {
+					// Auto settle/forward payment via facilitator
+					txHash, err := m.casperClient.SettlePayload(payload.Signature, details)
+					if err == nil && txHash != "" {
+						fmt.Printf("✅ Casper Facilitator: Verified and settled transaction: %s\n", txHash)
+						// Store dummy address for signer in context for downstream handlers
+						ctx := context.WithValue(r.Context(), SignerContextKey, common.HexToAddress("0x0"))
+						next.ServeHTTP(w, r.WithContext(ctx))
+						return
+					}
+				}
+			}
+
 			// 2. Check Cache & DB (Idempotency)
 			if addr, ok := m.verified.Load(payload.Signature); ok {
 				ctx := context.WithValue(r.Context(), SignerContextKey, addr.(common.Address))
@@ -145,6 +182,20 @@ func (m *Middleware) Handler(next http.Handler) http.Handler {
 
 		nonce, _ := m.nonces.Generate(m.config.NonceExpiry)
 
+		// Set the Payment-Required header formatted for Casper native agents
+		casperChallenge := map[string]interface{}{
+			"accepts": []map[string]interface{}{
+				{
+					"scheme":    "casper-native",
+					"networkId": "casper-testnet",
+					"amount":    amount,
+					"recipient": recipient,
+				},
+			},
+		}
+		challengeBytes, _ := json.Marshal(casperChallenge)
+		w.Header().Set(HeaderPaymentRequired, string(challengeBytes))
+
 		resp := ChallengeResponse{
 			Status:      http.StatusPaymentRequired,
 			Title:       "Payment Required",