@gistplus/server 0.1.0

package/README.md

@@ -0,0 +1,387 @@
+# @gistplus/server
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/gistplus?style=social)](https://x.com/gistplus)
+
+Server middleware for API providers to monetize endpoints with Gist Plus protocol.
+
+## Installation
+
+```bash
+npm install @gistplus/server
+```
+
+## What is This?
+
+This package enables **API providers** to:
+- 💰 Monetize endpoints automatically
+- 🤝 Negotiate pricing with agents
+- 📝 Generate cryptographic receipts
+- ⚖️ Enforce SLA guarantees
+- 💵 Accept SOL/USDC/USDT payments
+
+## Quick Start
+
+```typescript
+import express from 'express';
+import { Connection, Keypair } from '@solana/web3.js';
+import { gistMiddleware } from '@gistplus/server';
+
+const app = express();
+const connection = new Connection('https://api.devnet.solana.com');
+const wallet = Keypair.generate(); // Your provider wallet
+
+// Add Gist Plus middleware
+app.use('/api/*', gistMiddleware({
+  connection,
+  wallet,
+  endpoint: 'https://your-api.com',
+  pricing: {
+    basePrice: 0.01,
+    token: 'USDC'
+  },
+  sla: {
+    maxLatencyMs: 2000,
+    minUptimePercent: 99.5
+  }
+}));
+
+// Your API endpoint (now monetized!)
+app.post('/api/inference', async (req, res) => {
+  // req.gistSession contains session info
+  const result = await runInference(req.body);
+  
+  // Automatic receipt generation
+  return res.gistReceipt?.(result);
+});
+
+app.listen(3000);
+```
+
+That's it! Your API now:
+- ✅ Responds with 402 Payment Required
+- ✅ Negotiates with agents automatically
+- ✅ Validates sessions
+- ✅ Generates signed receipts
+- ✅ Tracks balances
+
+## Core Features
+
+### Automatic 402 Responses
+
+```typescript
+// When agent hits your endpoint without payment:
+GET /api/inference
+↓
+402 Payment Required
+X-Gist-Offer: {signed offer with your pricing}
+```
+
+### Dynamic Pricing
+
+```typescript
+import { LoadBasedPricingStrategy } from '@gistplus/server';
+
+const pricing = new LoadBasedPricingStrategy(
+  0.01,     // base price
+  'USDC',
+  () => getCurrentLoad()  // returns 0-1
+);
+
+app.use(gistMiddleware({
+  // ...
+  pricing  // Price increases with load
+}));
+```
+
+### Multiple Pricing Strategies
+
+```typescript
+// Static pricing
+pricing: { basePrice: 0.01, token: 'USDC' }
+
+// Load-based
+pricing: new LoadBasedPricingStrategy(0.01, 'USDC', getLoad)
+
+// Time-based (peak hours)
+pricing: new TimeBasedPricingStrategy(
+  0.02,  // peak price
+  0.01,  // off-peak price
+  { start: 9, end: 17 },  // peak hours
+  'USDC'
+)
+
+// SLA-based (stricter SLA = higher price)
+pricing: new SLABasedPricingStrategy(0.01, 'USDC')
+```
+
+### Receipt Generation
+
+```typescript
+app.post('/api/inference', async (req, res) => {
+  const result = await processRequest(req.body);
+  
+  // Middleware automatically:
+  // - Generates receipt
+  // - Signs with your key
+  // - Verifies SLA
+  // - Updates session balance
+  // - Sends X-Gist-Receipt header
+  
+  return res.gistReceipt?.(result);
+});
+```
+
+### Session Management
+
+```typescript
+app.post('/api/inference', async (req, res) => {
+  // Session info automatically attached
+  const session = req.gistSession;
+  
+  console.log(session.remainingBalance);
+  console.log(session.requestCount);
+  console.log(session.expiresAt);
+  
+  // Process request...
+});
+```
+
+## API Reference
+
+### gistMiddleware(config)
+
+Creates Express middleware for Gist Plus protocol.
+
+```typescript
+app.use(gistMiddleware({
+  connection: Connection,           // Solana connection
+  wallet: Keypair,                 // Provider wallet
+  endpoint: string,                // Your API URL
+  pricing: PricingStrategy | {     // Pricing config
+    basePrice: number,
+    token: 'SOL' | 'USDC' | 'USDT' | 'BONK'
+  },
+  sla: {                          // SLA guarantees
+    maxLatencyMs?: number,
+    minUptimePercent?: number,
+    maxErrorRatePercent?: number
+  },
+  sessionDurationMs?: number,     // Default: 10 minutes
+  offerExpirationMs?: number      // Default: 1 minute
+}));
+```
+
+### Request Extensions
+
+The middleware adds these to Express Request:
+
+```typescript
+interface Request {
+  gistSession?: Session;           // Current session
+  x402Intent?: Intent;            // Agent's intent
+  x402RequestStartTime?: number;  // For latency calc
+}
+```
+
+### Response Extensions
+
+The middleware adds these to Express Response:
+
+```typescript
+interface Response {
+  gistReceipt?: (data: any) => Response;  // Generate receipt
+}
+```
+
+## Usage Patterns
+
+### Basic Protected Endpoint
+
+```typescript
+app.use('/api/*', gistMiddleware(config));
+
+app.post('/api/weather', async (req, res) => {
+  const data = await getWeather(req.body.city);
+  return res.gistReceipt?.(data);
+});
+```
+
+### Custom Validation
+
+```typescript
+app.post('/api/premium', async (req, res) => {
+  const session = req.gistSession;
+  
+  // Check if enough balance for premium feature
+  if (session.remainingBalance < 0.1) {
+    return res.status(402).json({
+      error: 'Insufficient balance for premium feature'
+    });
+  }
+  
+  const result = await processPremium(req.body);
+  return res.gistReceipt?.(result);
+});
+```
+
+### Multiple Endpoints, Different Pricing
+
+```typescript
+// Cheap endpoint
+app.use('/api/basic', gistMiddleware({
+  ...config,
+  pricing: { basePrice: 0.001, token: 'USDC' }
+}));
+
+// Expensive endpoint
+app.use('/api/premium', gistMiddleware({
+  ...config,
+  pricing: { basePrice: 0.1, token: 'USDC' }
+}));
+```
+
+### With Error Handling
+
+```typescript
+app.post('/api/inference', async (req, res) => {
+  try {
+    const result = await runInference(req.body);
+    return res.gistReceipt?.(result);
+  } catch (error) {
+    // Errors don't charge the session
+    res.status(500).json({ error: error.message });
+  }
+});
+```
+
+## Pricing Strategies
+
+### Static Pricing
+
+```typescript
+pricing: {
+  basePrice: 0.01,
+  token: 'USDC'
+}
+```
+
+### Load-Based Pricing
+
+```typescript
+import { LoadBasedPricingStrategy } from '@gistplus/server';
+
+const pricing = new LoadBasedPricingStrategy(
+  0.01,  // base price
+  'USDC',
+  () => {
+    // Return load factor 0-1
+    const currentLoad = getCurrentLoad();
+    return currentLoad / maxLoad;
+  }
+);
+// Load 0% → 0.01 USDC
+// Load 50% → 0.015 USDC
+// Load 100% → 0.02 USDC
+```
+
+### Time-Based Pricing
+
+```typescript
+import { TimeBasedPricingStrategy } from '@gistplus/server';
+
+const pricing = new TimeBasedPricingStrategy(
+  0.02,   // peak price
+  0.01,   // off-peak price
+  { start: 9, end: 17 },  // 9 AM - 5 PM
+  'USDC'
+);
+```
+
+### SLA-Based Pricing
+
+```typescript
+import { SLABasedPricingStrategy } from '@gistplus/server';
+
+const pricing = new SLABasedPricingStrategy(0.01, 'USDC');
+// <1s latency SLA → 1.5x price
+// <2s latency SLA → 1.25x price
+// >99.5% uptime → 1.3x price
+```
+
+### Custom Pricing
+
+```typescript
+class MyCustomPricing implements PricingStrategy {
+  getPrice(intent: Intent): number {
+    // Your custom logic
+    if (intent.capability === 'premium') return 0.1;
+    if (isWeekend()) return 0.005;
+    return 0.01;
+  }
+}
+
+const pricing = new MyCustomPricing();
+```
+
+## Examples
+
+### AI Inference API
+
+```typescript
+app.use('/api/inference', gistMiddleware({
+  connection,
+  wallet,
+  endpoint: 'https://ai.example.com',
+  pricing: { basePrice: 0.01, token: 'USDC' },
+  sla: { maxLatencyMs: 3000 }
+}));
+
+app.post('/api/inference', async (req, res) => {
+  const result = await model.generate(req.body.prompt);
+  return res.gistReceipt?.(result);
+});
+```
+
+### Image Generation API
+
+```typescript
+app.use('/api/image', gistMiddleware({
+  connection,
+  wallet,
+  endpoint: 'https://image.example.com',
+  pricing: { basePrice: 0.05, token: 'USDC' },
+  sla: { maxLatencyMs: 10000 }
+}));
+
+app.post('/api/image', async (req, res) => {
+  const imageUrl = await generateImage(req.body);
+  return res.gistReceipt?.({ imageUrl });
+});
+```
+
+### Data API
+
+```typescript
+app.use('/api/data', gistMiddleware({
+  connection,
+  wallet,
+  endpoint: 'https://data.example.com',
+  pricing: { basePrice: 0.001, token: 'USDC' },
+  sla: { maxLatencyMs: 1000 }
+}));
+
+app.post('/api/data', async (req, res) => {
+  const data = await fetchData(req.body.query);
+  return res.gistReceipt?.(data);
+});
+```
+
+## Related Packages
+
+- **[@gistplus/core](https://www.npmjs.com/package/@gistplus/core)** - Core protocol (auto-installed)
+- **[@gistplus/client](https://www.npmjs.com/package/@gistplus/client)** - For AI agents
+
+## License
+
+Apache 2.0
+

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @gistplus/server
+ *
+ * Server-side middleware for API providers to implement Gist Plus protocol.
+ * Handles automatic Intent responses, Offer generation, Session management,
+ * and Receipt creation.
+ */
+export * from './middleware';
+export * from './provider';
+export * from './session-store';
+export * from './pricing';
+export { Intent, Offer, Session, Receipt, SLA, SessionState, SupportedToken, SUPPORTED_TOKENS, } from '@gistplus/core';

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @gistplus/server
+ *
+ * Server-side middleware for API providers to implement Gist Plus protocol.
+ * Handles automatic Intent responses, Offer generation, Session management,
+ * and Receipt creation.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_TOKENS = exports.SessionState = void 0;
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./provider"), exports);
+__exportStar(require("./session-store"), exports);
+__exportStar(require("./pricing"), exports);
+// Re-export core types
+var core_1 = require("@gistplus/core");
+Object.defineProperty(exports, "SessionState", { enumerable: true, get: function () { return core_1.SessionState; } });
+Object.defineProperty(exports, "SUPPORTED_TOKENS", { enumerable: true, get: function () { return core_1.SUPPORTED_TOKENS; } });

package/dist/middleware.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Express middleware for Gist Plus protocol
+ */
+import { Request, Response, NextFunction } from 'express';
+import { Intent, Session } from '@gistplus/core';
+import { GistProvider, GistProviderConfig } from './provider';
+declare global {
+    namespace Express {
+        interface Request {
+            gistSession?: Session;
+            gistIntent?: Intent;
+            gistRequestStartTime?: number;
+        }
+        interface Response {
+            gistReceipt?: (data: any) => Response;
+        }
+    }
+}
+/**
+ * Create Gist Plus middleware for Express
+ *
+ * This middleware handles:
+ * 1. Detecting requests without sessions (402 responses with Offers)
+ * 2. Validating session headers
+ * 3. Attaching session info to request
+ * 4. Generating and attaching Receipts to responses
+ *
+ * @param config - Provider configuration
+ * @returns Express middleware
+ */
+export declare function gistMiddleware(config: GistProviderConfig): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/**
+ * Middleware specifically for session creation endpoint
+ */
+export declare function sessionCreationHandler(provider: GistProvider): (req: Request, res: Response) => Promise<void>;

package/dist/middleware.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Express middleware for Gist Plus protocol
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gistMiddleware = gistMiddleware;
+exports.sessionCreationHandler = sessionCreationHandler;
+const core_1 = require("@gistplus/core");
+const provider_1 = require("./provider");
+/**
+ * Create Gist Plus middleware for Express
+ *
+ * This middleware handles:
+ * 1. Detecting requests without sessions (402 responses with Offers)
+ * 2. Validating session headers
+ * 3. Attaching session info to request
+ * 4. Generating and attaching Receipts to responses
+ *
+ * @param config - Provider configuration
+ * @returns Express middleware
+ */
+function gistMiddleware(config) {
+    const provider = new provider_1.GistProvider(config);
+    return async (req, res, next) => {
+        req.gistRequestStartTime = Date.now();
+        try {
+            // Check for session header
+            const sessionId = req.headers[core_1.HEADERS.SESSION_ID.toLowerCase()];
+            if (sessionId) {
+                // Request has session - validate and attach
+                await handleSessionRequest(req, res, next, provider, sessionId);
+            }
+            else {
+                // No session - check for Intent and respond with Offer
+                await handleIntentRequest(req, res, next, provider);
+            }
+        }
+        catch (error) {
+            console.error('Gist Plus middleware error:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    };
+}
+/**
+ * Handle request with Intent (no session yet)
+ */
+async function handleIntentRequest(req, res, next, provider) {
+    // Check for Intent header
+    const intentHeader = req.headers[core_1.HEADERS.INTENT.toLowerCase()];
+    if (!intentHeader) {
+        // No Intent, no Session -> 402 Quote Required
+        res.status(core_1.HTTP_STATUS.QUOTE_REQUIRED).json({
+            error: 'Payment Required',
+            message: 'This endpoint requires Gist Plus payment. Send an Intent to negotiate.',
+            protocol: 'Gist Plus',
+        });
+        return;
+    }
+    try {
+        // Parse and validate Intent
+        const intent = JSON.parse(intentHeader);
+        (0, core_1.validateIntent)(intent);
+        // Create Offer
+        const offer = await provider.createOfferForIntent(intent);
+        // Respond with 402 and Offer in header
+        res.setHeader(core_1.HEADERS.OFFER, JSON.stringify(offer));
+        res.status(core_1.HTTP_STATUS.QUOTE_REQUIRED).json({
+            message: 'Offer provided',
+            offerId: offer.offerId,
+            pricePerRequest: offer.pricePerRequest,
+            token: offer.token,
+        });
+    }
+    catch (error) {
+        res.status(core_1.HTTP_STATUS.INVALID_OFFER).json({
+            error: 'Invalid Intent',
+            message: String(error),
+        });
+    }
+}
+/**
+ * Handle request with existing Session
+ */
+async function handleSessionRequest(req, res, next, provider, sessionId) {
+    try {
+        // Get session
+        const session = provider.getSession(sessionId);
+        if (!session) {
+            res.status(core_1.HTTP_STATUS.SESSION_EXPIRED).json({
+                error: 'Session not found',
+                message: `Session ${sessionId} does not exist or has expired`,
+            });
+            return;
+        }
+        // Validate session is active
+        // (This would check expiration, balance, etc.)
+        // Attach session to request
+        req.gistSession = session;
+        // Create Receipt helper function
+        res.gistReceipt = (data) => {
+            // This will be called by the route handler
+            provider
+                .createReceiptForRequest(sessionId, req.body, data, req.gistRequestStartTime)
+                .then((receipt) => {
+                // Attach receipt to response header
+                res.setHeader(core_1.HEADERS.RECEIPT, JSON.stringify(receipt));
+                res.setHeader(core_1.HEADERS.SLA_STATUS, receipt.slaVerification.met ? 'met' : 'breached');
+                res.json(data);
+            })
+                .catch((error) => {
+                res.status(500).json({
+                    error: 'Failed to generate receipt',
+                    message: String(error),
+                });
+            });
+            return res;
+        };
+        // Continue to route handler
+        next();
+    }
+    catch (error) {
+        res.status(500).json({
+            error: 'Session error',
+            message: String(error),
+        });
+    }
+}
+/**
+ * Middleware specifically for session creation endpoint
+ */
+function sessionCreationHandler(provider) {
+    return async (req, res) => {
+        try {
+            const { offerId, depositAmount, txSignature } = req.body;
+            if (!offerId || !depositAmount || !txSignature) {
+                res.status(400).json({
+                    error: 'Missing required fields',
+                    required: ['offerId', 'depositAmount', 'txSignature'],
+                });
+                return;
+            }
+            // For MVP, we'll need to reconstruct or store the offer
+            // In production, you'd store offers temporarily
+            // Create session (this includes payment verification)
+            const agentPubkey = req.body.agentPubkey; // Should be derived from tx
+            // This is a simplified version - in production you'd:
+            // 1. Retrieve the stored offer by offerId
+            // 2. Verify the offer hasn't expired
+            // 3. Create the session
+            res.status(core_1.HTTP_STATUS.SESSION_STARTED).json({
+                message: 'Session creation endpoint - implement offer storage',
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: 'Failed to create session',
+                message: String(error),
+            });
+        }
+    };
+}

package/dist/pricing.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Pricing Strategies for Gist Plus providers
+ */
+import { Intent, SupportedToken } from '@gistplus/core';
+/**
+ * PricingStrategy interface
+ *
+ * Allows providers to implement dynamic pricing based on:
+ * - Intent requirements
+ * - Current load
+ * - Token type
+ * - Time of day
+ * - Agent reputation
+ */
+export interface PricingStrategy {
+    getPrice(intent: Intent): Promise<number> | number;
+}
+/**
+ * Static pricing - same price for all requests
+ */
+export declare class StaticPricingStrategy implements PricingStrategy {
+    private basePrice;
+    private token;
+    constructor(basePrice: number, token: SupportedToken);
+    getPrice(intent: Intent): number;
+}
+/**
+ * Load-based pricing - price increases with load
+ */
+export declare class LoadBasedPricingStrategy implements PricingStrategy {
+    private basePrice;
+    private token;
+    private getLoadFactor;
+    constructor(basePrice: number, token: SupportedToken, getLoadFactor: () => number);
+    getPrice(intent: Intent): number;
+}
+/**
+ * Time-based pricing - different prices for different times
+ */
+export declare class TimeBasedPricingStrategy implements PricingStrategy {
+    private peakPrice;
+    private offPeakPrice;
+    private peakHours;
+    private token;
+    constructor(peakPrice: number, offPeakPrice: number, peakHours: {
+        start: number;
+        end: number;
+    }, // 0-23
+    token: SupportedToken);
+    getPrice(intent: Intent): number;
+}
+/**
+ * SLA-based pricing - higher price for stricter SLAs
+ */
+export declare class SLABasedPricingStrategy implements PricingStrategy {
+    private basePrice;
+    private token;
+    constructor(basePrice: number, token: SupportedToken);
+    getPrice(intent: Intent): number;
+}
+/**
+ * Custom pricing strategy - combine multiple strategies
+ */
+export declare class CompositePricingStrategy implements PricingStrategy {
+    private strategies;
+    constructor(strategies: PricingStrategy[]);
+    getPrice(intent: Intent): Promise<number>;
+}

package/dist/pricing.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Pricing Strategies for Gist Plus providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositePricingStrategy = exports.SLABasedPricingStrategy = exports.TimeBasedPricingStrategy = exports.LoadBasedPricingStrategy = exports.StaticPricingStrategy = void 0;
+/**
+ * Static pricing - same price for all requests
+ */
+class StaticPricingStrategy {
+    constructor(basePrice, token) {
+        this.basePrice = basePrice;
+        this.token = token;
+    }
+    getPrice(intent) {
+        return this.basePrice;
+    }
+}
+exports.StaticPricingStrategy = StaticPricingStrategy;
+/**
+ * Load-based pricing - price increases with load
+ */
+class LoadBasedPricingStrategy {
+    constructor(basePrice, token, getLoadFactor // Returns 0-1, multiplies price
+    ) {
+        this.basePrice = basePrice;
+        this.token = token;
+        this.getLoadFactor = getLoadFactor;
+    }
+    getPrice(intent) {
+        const loadFactor = this.getLoadFactor();
+        const multiplier = 1 + loadFactor;
+        return this.basePrice * multiplier;
+    }
+}
+exports.LoadBasedPricingStrategy = LoadBasedPricingStrategy;
+/**
+ * Time-based pricing - different prices for different times
+ */
+class TimeBasedPricingStrategy {
+    constructor(peakPrice, offPeakPrice, peakHours, // 0-23
+    token) {
+        this.peakPrice = peakPrice;
+        this.offPeakPrice = offPeakPrice;
+        this.peakHours = peakHours;
+        this.token = token;
+    }
+    getPrice(intent) {
+        const hour = new Date().getHours();
+        const isPeak = hour >= this.peakHours.start && hour <= this.peakHours.end;
+        return isPeak ? this.peakPrice : this.offPeakPrice;
+    }
+}
+exports.TimeBasedPricingStrategy = TimeBasedPricingStrategy;
+/**
+ * SLA-based pricing - higher price for stricter SLAs
+ */
+class SLABasedPricingStrategy {
+    constructor(basePrice, token) {
+        this.basePrice = basePrice;
+        this.token = token;
+    }
+    getPrice(intent) {
+        let price = this.basePrice;
+        // Charge more for stricter latency requirements
+        if (intent.sla?.maxLatencyMs) {
+            if (intent.sla.maxLatencyMs < 1000) {
+                price *= 1.5; // 50% premium for sub-second latency
+            }
+            else if (intent.sla.maxLatencyMs < 2000) {
+                price *= 1.25; // 25% premium for sub-2s latency
+            }
+        }
+        // Charge more for higher uptime guarantees
+        if (intent.sla?.minUptimePercent && intent.sla.minUptimePercent > 99.5) {
+            price *= 1.3; // 30% premium for 99.5%+ uptime
+        }
+        return price;
+    }
+}
+exports.SLABasedPricingStrategy = SLABasedPricingStrategy;
+/**
+ * Custom pricing strategy - combine multiple strategies
+ */
+class CompositePricingStrategy {
+    constructor(strategies) {
+        this.strategies = strategies;
+    }
+    async getPrice(intent) {
+        const prices = await Promise.all(this.strategies.map(strategy => strategy.getPrice(intent)));
+        // Return average, max, or custom combination
+        return Math.max(...prices);
+    }
+}
+exports.CompositePricingStrategy = CompositePricingStrategy;

package/dist/provider.d.ts

@@ -0,0 +1,91 @@
+/**
+ * GistProvider - Main provider interface for Gist Plus server
+ */
+import { Connection, Keypair } from '@solana/web3.js';
+import { Intent, Offer, Session, Receipt, SLA, SupportedToken } from '@gistplus/core';
+import { PricingStrategy } from './pricing';
+export interface GistProviderConfig {
+    /** Solana connection */
+    connection: Connection;
+    /** Provider's keypair for signing Offers and Receipts */
+    wallet: Keypair;
+    /** Provider's API endpoint base URL */
+    endpoint: string;
+    /** Pricing strategy */
+    pricing: PricingStrategy | {
+        basePrice: number;
+        token: SupportedToken;
+    };
+    /** SLA guarantees */
+    sla: SLA;
+    /** Session duration in milliseconds */
+    sessionDurationMs?: number;
+    /** Offer expiration in milliseconds */
+    offerExpirationMs?: number;
+}
+/**
+ * GistProvider - Server-side provider implementation
+ *
+ * Enables API providers to:
+ * 1. Respond to Intents with Offers
+ * 2. Create and manage Sessions
+ * 3. Generate signed Receipts
+ * 4. Verify payments on Solana
+ */
+export declare class GistProvider {
+    private connection;
+    private wallet;
+    private endpoint;
+    private pricing;
+    private sla;
+    private sessionDurationMs;
+    private offerExpirationMs;
+    private sessionStore;
+    constructor(config: GistProviderConfig);
+    /**
+     * Create an Offer in response to an Intent
+     *
+     * @param intent - Agent's Intent
+     * @returns Signed Offer
+     */
+    createOfferForIntent(intent: Intent): Promise<Offer>;
+    /**
+     * Create a Session from an accepted Offer
+     *
+     * @param offer - Accepted Offer
+     * @param agentPubkey - Agent's public key
+     * @param depositAmount - Amount deposited
+     * @param txSignature - Solana transaction signature for payment
+     * @returns Active Session
+     */
+    createSessionFromOffer(offer: Offer, agentPubkey: string, depositAmount: number, txSignature: string): Promise<Session>;
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId: string): Session | undefined;
+    /**
+     * Create a Receipt for a completed request
+     *
+     * @param sessionId - Session ID
+     * @param inputData - Request input data
+     * @param outputData - Request output data
+     * @param requestStartedAt - Request start timestamp
+     * @returns Signed Receipt
+     */
+    createReceiptForRequest(sessionId: string, inputData: any, outputData: any, requestStartedAt: number): Promise<Receipt>;
+    /**
+     * Close a session and process refund
+     */
+    closeSession(sessionId: string): Promise<{
+        refundAmount: number;
+        txSignature?: string;
+    }>;
+    /**
+     * Verify payment on Solana blockchain
+     */
+    private verifyPayment;
+    /**
+     * Get provider's public key
+     */
+    get publicKey(): import("@solana/web3.js").PublicKey;
+}

package/dist/provider.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * GistProvider - Main provider interface for Gist Plus server
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GistProvider = void 0;
+const core_1 = require("@gistplus/core");
+const session_store_1 = require("./session-store");
+const pricing_1 = require("./pricing");
+/**
+ * GistProvider - Server-side provider implementation
+ *
+ * Enables API providers to:
+ * 1. Respond to Intents with Offers
+ * 2. Create and manage Sessions
+ * 3. Generate signed Receipts
+ * 4. Verify payments on Solana
+ */
+class GistProvider {
+    constructor(config) {
+        this.connection = config.connection;
+        this.wallet = config.wallet;
+        this.endpoint = config.endpoint;
+        this.sla = config.sla;
+        this.sessionDurationMs = config.sessionDurationMs || 600000; // 10 minutes default
+        this.offerExpirationMs = config.offerExpirationMs || 60000; // 1 minute default
+        // Initialize pricing strategy
+        if ('getPrice' in config.pricing) {
+            this.pricing = config.pricing;
+        }
+        else {
+            this.pricing = new pricing_1.StaticPricingStrategy(config.pricing.basePrice, config.pricing.token);
+        }
+        // Initialize session store
+        this.sessionStore = new session_store_1.SessionStore(this.connection, this.wallet);
+    }
+    /**
+     * Create an Offer in response to an Intent
+     *
+     * @param intent - Agent's Intent
+     * @returns Signed Offer
+     */
+    async createOfferForIntent(intent) {
+        // Validate intent
+        (0, core_1.validateIntent)(intent);
+        // Get dynamic price based on intent
+        const price = await this.pricing.getPrice(intent);
+        // Create offer
+        const offer = (0, core_1.createOffer)({
+            intent,
+            providerPubkey: this.wallet.publicKey,
+            pricePerRequest: price,
+            sla: this.sla,
+            sessionDurationMs: intent.sessionDurationMs || this.sessionDurationMs,
+            endpoint: this.endpoint,
+            expirationMs: this.offerExpirationMs,
+        }, this.wallet);
+        return offer;
+    }
+    /**
+     * Create a Session from an accepted Offer
+     *
+     * @param offer - Accepted Offer
+     * @param agentPubkey - Agent's public key
+     * @param depositAmount - Amount deposited
+     * @param txSignature - Solana transaction signature for payment
+     * @returns Active Session
+     */
+    async createSessionFromOffer(offer, agentPubkey, depositAmount, txSignature) {
+        // Verify payment on-chain
+        await this.verifyPayment(txSignature, agentPubkey, depositAmount);
+        // Create session
+        const session = (0, core_1.createSession)({
+            offer,
+            agentPubkey,
+            depositAmount,
+            creationTxSignature: txSignature,
+        });
+        // Store session
+        this.sessionStore.saveSession(session);
+        return session;
+    }
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId) {
+        return this.sessionStore.getSession(sessionId);
+    }
+    /**
+     * Create a Receipt for a completed request
+     *
+     * @param sessionId - Session ID
+     * @param inputData - Request input data
+     * @param outputData - Request output data
+     * @param requestStartedAt - Request start timestamp
+     * @returns Signed Receipt
+     */
+    async createReceiptForRequest(sessionId, inputData, outputData, requestStartedAt) {
+        const session = this.sessionStore.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        const requestCompletedAt = Date.now();
+        // Create receipt
+        const receipt = (0, core_1.createReceipt)({
+            session,
+            requestNumber: session.requestCount + 1,
+            inputData,
+            outputData,
+            requestStartedAt,
+            requestCompletedAt,
+            amountCharged: session.pricePerRequest,
+        }, this.wallet);
+        // Update session
+        this.sessionStore.updateSessionAfterRequest(sessionId, receipt);
+        return receipt;
+    }
+    /**
+     * Close a session and process refund
+     */
+    async closeSession(sessionId) {
+        const session = this.sessionStore.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        const refundAmount = session.remainingBalance;
+        if (refundAmount > 0) {
+            // TODO: Process refund on-chain
+            // const txSignature = await this.processRefund(session.agentPubkey, refundAmount);
+            // return { refundAmount, txSignature };
+        }
+        // Mark session as closed
+        this.sessionStore.closeSession(sessionId);
+        return { refundAmount };
+    }
+    /**
+     * Verify payment on Solana blockchain
+     */
+    async verifyPayment(txSignature, expectedPayer, expectedAmount) {
+        try {
+            const transaction = await this.connection.getTransaction(txSignature, {
+                commitment: 'confirmed',
+            });
+            if (!transaction) {
+                throw new Error('Transaction not found');
+            }
+            // TODO: Verify transaction details match expected values
+            // This would check:
+            // 1. Payer matches expectedPayer
+            // 2. Recipient is this provider
+            // 3. Amount matches expectedAmount
+            // 4. Transaction is successful
+        }
+        catch (error) {
+            throw new Error(`Payment verification failed: ${error}`);
+        }
+    }
+    /**
+     * Get provider's public key
+     */
+    get publicKey() {
+        return this.wallet.publicKey;
+    }
+}
+exports.GistProvider = GistProvider;

package/dist/session-store.d.ts

@@ -0,0 +1,49 @@
+/**
+ * SessionStore - In-memory session storage for providers
+ */
+import { Connection, Keypair } from '@solana/web3.js';
+import { Session, Receipt } from '@gistplus/core';
+/**
+ * SessionStore manages active sessions for a provider
+ *
+ * In production, this would be backed by Redis, PostgreSQL, or similar.
+ * For MVP, we use an in-memory store.
+ */
+export declare class SessionStore {
+    private sessions;
+    private connection;
+    private wallet;
+    constructor(connection: Connection, wallet: Keypair);
+    /**
+     * Save a new session
+     */
+    saveSession(session: Session): void;
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId: string): Session | undefined;
+    /**
+     * Update session after a request
+     */
+    updateSessionAfterRequest(sessionId: string, receipt: Receipt): void;
+    /**
+     * Close a session
+     */
+    closeSession(sessionId: string): void;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): Session[];
+    /**
+     * Clean up expired sessions
+     */
+    private cleanup;
+    /**
+     * Start background cleanup task
+     */
+    private startCleanupTask;
+    /**
+     * Get session count
+     */
+    getSessionCount(): number;
+}

package/dist/session-store.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * SessionStore - In-memory session storage for providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionStore = void 0;
+const core_1 = require("@gistplus/core");
+/**
+ * SessionStore manages active sessions for a provider
+ *
+ * In production, this would be backed by Redis, PostgreSQL, or similar.
+ * For MVP, we use an in-memory store.
+ */
+class SessionStore {
+    constructor(connection, wallet) {
+        this.sessions = new Map();
+        this.connection = connection;
+        this.wallet = wallet;
+        // Start background cleanup
+        this.startCleanupTask();
+    }
+    /**
+     * Save a new session
+     */
+    saveSession(session) {
+        this.sessions.set(session.sessionId, session);
+    }
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return undefined;
+        }
+        // Check if expired
+        if (!(0, core_1.isSessionActive)(session) && session.state === core_1.SessionState.ACTIVE) {
+            const expiredSession = (0, core_1.expireSession)(session);
+            this.sessions.set(sessionId, expiredSession);
+            return expiredSession;
+        }
+        return session;
+    }
+    /**
+     * Update session after a request
+     */
+    updateSessionAfterRequest(sessionId, receipt) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        const updatedSession = (0, core_1.deductFromSession)(session, receipt.amountCharged);
+        this.sessions.set(sessionId, updatedSession);
+    }
+    /**
+     * Close a session
+     */
+    closeSession(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return Array.from(this.sessions.values()).filter(core_1.isSessionActive);
+    }
+    /**
+     * Clean up expired sessions
+     */
+    cleanup() {
+        const now = Date.now();
+        const graceperiod = 3600000; // 1 hour
+        for (const [sessionId, session] of this.sessions.entries()) {
+            if (now > session.expiresAt + graceperiod) {
+                this.sessions.delete(sessionId);
+            }
+        }
+    }
+    /**
+     * Start background cleanup task
+     */
+    startCleanupTask() {
+        setInterval(() => {
+            this.cleanup();
+        }, 300000); // Every 5 minutes
+    }
+    /**
+     * Get session count
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+}
+exports.SessionStore = SessionStore;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@gistplus/server",
+  "version": "0.1.0",
+  "description": "Server middleware for Gist Plus - enables API providers to monetize endpoints with automatic negotiation and payment verification",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "clean": "rimraf dist"
+  },
+  "keywords": [
+    "gistplus",
+    "gist",
+    "server",
+    "middleware",
+    "express",
+    "api-monetization"
+  ],
+  "author": "Gist Plus",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gistplus/gistplus"
+  },
+  "homepage": "https://github.com/gistplus/gistplus#readme",
+  "bugs": {
+    "url": "https://github.com/gistplus/gistplus/issues"
+  },
+  "dependencies": {
+    "@gistplus/core": "^0.1.0",
+    "@solana/web3.js": "^1.87.6",
+    "@solana/spl-token": "^0.3.9",
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.10.6",
+    "@types/express": "^4.17.21",
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.11",
+    "rimraf": "^5.0.5"
+  },
+  "peerDependencies": {
+    "express": "^4.18.0"
+  }
+}