@puul/partner-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,248 @@
+// src/types.ts
+var PuulError = class extends Error {
+  constructor(apiError) {
+    const msg = Array.isArray(apiError.message) ? apiError.message.join(", ") : apiError.message;
+    super(msg);
+    this.name = "PuulError";
+    this.statusCode = apiError.statusCode;
+    this.code = apiError.code;
+    this.requestId = apiError.requestId;
+    this.details = apiError.details;
+    this.retryable = apiError.retryable ?? false;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.joinpuul.com/api/v1";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var PuulPartner = class {
+  constructor(config) {
+    this.tokenCache = null;
+    this.config = {
+      clientId: config.clientId,
+      clientSecret: config.clientSecret,
+      baseUrl: (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, ""),
+      timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+    };
+    this.sessions = new SessionsAPI(this);
+    this.markets = new MarketsAPI(this);
+    this.predictions = new PredictionsAPI(this);
+    this.wallet = new WalletAPI(this);
+  }
+  // ==========================================================
+  // Internal HTTP layer
+  // ==========================================================
+  /** Get a valid access token, refreshing if needed */
+  async getAccessToken() {
+    if (this.tokenCache && Date.now() < this.tokenCache.expiresAt - 3e4) {
+      return this.tokenCache.accessToken;
+    }
+    const response = await this.rawRequest(
+      "POST",
+      "/partner/oauth/token",
+      {
+        client_id: this.config.clientId,
+        client_secret: this.config.clientSecret,
+        grant_type: "client_credentials"
+      },
+      false
+      // Don't use auth for the auth endpoint itself
+    );
+    this.tokenCache = {
+      accessToken: response.access_token,
+      expiresAt: Date.now() + response.expires_in * 1e3
+    };
+    return this.tokenCache.accessToken;
+  }
+  /** Authenticated request */
+  async request(method, path, body) {
+    return this.rawRequest(method, path, body, true);
+  }
+  /** Raw HTTP request */
+  async rawRequest(method, path, body, authenticate = true) {
+    const url = `${this.config.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json"
+    };
+    if (authenticate) {
+      const token = await this.getAccessToken();
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      const responseBody = await response.text();
+      let parsed;
+      try {
+        parsed = JSON.parse(responseBody);
+      } catch {
+        if (!response.ok) {
+          throw new PuulError({
+            statusCode: response.status,
+            message: responseBody || response.statusText,
+            code: "UNKNOWN_ERROR"
+          });
+        }
+        return responseBody;
+      }
+      if (!response.ok) {
+        throw new PuulError(parsed);
+      }
+      return parsed;
+    } catch (error) {
+      if (error instanceof PuulError) throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new PuulError({
+          statusCode: 0,
+          message: `Request timed out after ${this.config.timeoutMs}ms`,
+          code: "REQUEST_TIMEOUT",
+          retryable: true
+        });
+      }
+      throw new PuulError({
+        statusCode: 0,
+        message: error instanceof Error ? error.message : "Unknown network error",
+        code: "NETWORK_ERROR",
+        retryable: true
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+var SessionsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a link token for user linking */
+  async createLinkToken(params) {
+    return this.client.request("POST", "/partner/link-tokens", params);
+  }
+  /** Exchange a link token for a user session */
+  async create(linkToken) {
+    return this.client.request("POST", "/partner/sessions", { linkToken });
+  }
+};
+var MarketsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all live markets, optionally filtered by country */
+  async list(countries) {
+    const query = countries?.length ? `?countries=${countries.join(",")}` : "";
+    return this.client.request("GET", `/partner/markets${query}`);
+  }
+};
+var PredictionsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a binding quote for slippage protection (expires in 10s) */
+  async createQuote(params) {
+    return this.client.request("POST", "/partner/predictions/quote", params);
+  }
+  /** Place a prediction on a market outcome */
+  async place(params) {
+    return this.client.request("POST", "/partner/predictions", params);
+  }
+  /** Get a specific prediction by ID */
+  async get(predictionId) {
+    return this.client.request("GET", `/partner/predictions/${predictionId}`);
+  }
+  /** List user predictions with optional filters */
+  async list(options) {
+    const params = new URLSearchParams();
+    if (options?.status) params.set("status", options.status);
+    if (options?.limit) params.set("limit", String(options.limit));
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.client.request("GET", `/partner/predictions${query}`);
+  }
+  /** Create a pending prediction (JIT funding flow) */
+  async createPending(params) {
+    return this.client.request("POST", "/partner/predictions/pending", params);
+  }
+  /** Get pending prediction status */
+  async getPending(pendingId) {
+    return this.client.request("GET", `/partner/predictions/pending/${pendingId}`);
+  }
+};
+var WalletAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get partner deposit account details */
+  async getDepositAccount() {
+    return this.client.request("GET", "/partner/wallet/deposit-account");
+  }
+  /** Get user wallet balance */
+  async getBalance() {
+    return this.client.request("GET", "/partner/wallet/balance");
+  }
+  /** Get omnibus wallet balance */
+  async getOmnibusBalance(currency) {
+    const query = currency ? `?currency=${currency}` : "";
+    return this.client.request("GET", `/partner/wallet/omnibus-balance${query}`);
+  }
+  /** Deposit funds to a linked user wallet */
+  async deposit(params) {
+    return this.client.request("POST", "/partner/wallet/deposit", params);
+  }
+  /** Get withdrawal fee estimate */
+  async getWithdrawalFees(currency, amount) {
+    return this.client.request("GET", `/partner/wallet/withdrawal-fees?currency=${currency}&amount=${amount}`);
+  }
+};
+
+// src/webhooks.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function verifyWebhookSignature(payload, signature, secret) {
+  if (!payload || !signature || !secret) {
+    return false;
+  }
+  const expectedSignature = createHmac("sha256", secret).update(payload).digest("hex");
+  try {
+    const sigBuffer = Buffer.from(signature, "hex");
+    const expectedBuffer = Buffer.from(expectedSignature, "hex");
+    if (sigBuffer.length !== expectedBuffer.length) {
+      return false;
+    }
+    return timingSafeEqual(sigBuffer, expectedBuffer);
+  } catch {
+    return false;
+  }
+}
+function parseWebhookEvent(body) {
+  if (!body || typeof body !== "object") {
+    throw new Error("Invalid webhook body: expected an object");
+  }
+  const event = body;
+  if (typeof event.event !== "string") {
+    throw new Error('Invalid webhook body: missing "event" field');
+  }
+  return {
+    event: event.event,
+    timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    data: event.data || {}
+  };
+}
+function isPredictionSettledEvent(event) {
+  return event.event === "prediction.settled";
+}
+function asPredictionSettledData(event) {
+  return event.data;
+}
+export {
+  PuulError,
+  PuulPartner,
+  asPredictionSettledData,
+  isPredictionSettledEvent,
+  parseWebhookEvent,
+  verifyWebhookSignature
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@puul/partner-sdk",
+    "version": "1.0.0",
+    "description": "Official TypeScript SDK for the Puul Partner API — integrate prediction markets into your platform",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+        "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+        "typecheck": "tsc --noEmit",
+        "prepublishOnly": "npm run build"
+    },
+    "devDependencies": {
+        "@types/node": "^25.2.3",
+        "tsup": "^8.5.1",
+        "typescript": "^5.9.3"
+    },
+    "keywords": [
+        "puul",
+        "prediction-markets",
+        "parimutuel",
+        "partner-api",
+        "sdk"
+    ],
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Puul-Market/puul"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    }
+}