@wahoopredict/trading-sdk 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 WahooPredict
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,309 @@
+# WahooPredict Trading SDK
+
+TypeScript SDK for the WahooPredict trading API. Built on [openapi-fetch](https://github.com/drwpow/openapi-typescript/tree/main/packages/openapi-fetch) for type-safe API calls.
+
+## Installation
+
+```bash
+npm install @wahoopredict/trading-sdk
+```
+
+## Quick Start
+
+```typescript
+import { createWahooClient } from "@wahoopredict/trading-sdk";
+
+const client = createWahooClient({
+  apiKey: "your-api-key",
+  secretKey: "your-secret-key",
+});
+
+// Get your balance
+const { data, error } = await client.GET("/user/profile", {
+  params: { query: { fields: ["balance", "totalBalance"] } },
+});
+
+if (error) {
+  console.error("Error:", error);
+} else {
+  console.log("Balance:", data.user?.balance);
+}
+```
+
+## Authentication
+
+The SDK uses HMAC-SHA256 signature-based authentication. You need an API key and secret key from WahooPredict.
+
+The authentication headers are automatically added to every request:
+
+- `X-API-KEY` - Your API key
+- `X-TIMESTAMP` - Current Unix timestamp (seconds)
+- `X-SIGNATURE` - HMAC-SHA256 signature of `apiKey + timestamp + requestBody`
+
+## API Reference
+
+### Market Data
+
+#### Get Events List
+
+```typescript
+const { data, error } = await client.POST("/event/events-list", {
+  body: {
+    page: 1,
+    limit: 20,
+    filter: {
+      status: ["LIVE"],
+      search: "bitcoin",
+    },
+    sort: {
+      sortBy: "volume",
+      sortOrder: "desc",
+    },
+  },
+});
+
+// Access events
+data?.data.forEach((event) => {
+  console.log(event.title, event.status);
+});
+```
+
+#### Get Event Details
+
+```typescript
+const { data, error } = await client.GET("/event/event-details/{eventId}", {
+  params: {
+    path: { eventId: "cmkhbgto400rl01uqr9gn3mna" },
+  },
+});
+
+// data is the Event object directly
+console.log(data?.title);
+console.log(data?.outcomes); // Array of possible outcomes
+```
+
+#### Get Order Book
+
+```typescript
+const { data, error } = await client.GET("/event/orderbook", {
+  params: {
+    query: { outcomeOptionId: "cmkhbgw8f00t001uqprn3a2pk" },
+  },
+});
+
+console.log("Bids:", data?.bids);
+console.log("Asks:", data?.asks);
+```
+
+### Trading
+
+#### Test Order (Simulate)
+
+Before placing an order, you can test it to see the potential return:
+
+```typescript
+const { data, error } = await client.POST("/event/test-order", {
+  body: {
+    eventId: "cmkhbgto400rl01uqr9gn3mna",
+    outcomeOptionId: "cmkhbgw8f00t001uqprn3a2pk",
+    side: "BUY",
+    type: "MARKET",
+    amount: "10.00",
+  },
+});
+
+if (data) {
+  console.log("Potential return:", data.potentialReturn);
+}
+```
+
+#### Place Market Order
+
+```typescript
+const { data, error } = await client.POST("/event/place-order", {
+  body: {
+    eventId: "cmkhbgto400rl01uqr9gn3mna",
+    outcomeOptionId: "cmkhbgw8f00t001uqprn3a2pk",
+    side: "BUY",
+    type: "MARKET",
+    amount: "10.00", // Amount to spend (for BUY)
+  },
+});
+
+if (data) {
+  console.log("Order placed! New balance:", data.newBalance);
+}
+```
+
+#### Place Limit Order
+
+```typescript
+const { data, error } = await client.POST("/event/place-order", {
+  body: {
+    eventId: "cmkhbgto400rl01uqr9gn3mna",
+    outcomeOptionId: "cmkhbgw8f00t001uqprn3a2pk",
+    side: "BUY",
+    type: "LIMIT",
+    size: "100", // Number of shares
+    price: "0.45", // Price per share
+  },
+});
+```
+
+#### Cancel Order
+
+```typescript
+const { data, error } = await client.DELETE("/event/cancel-order", {
+  params: {
+    query: { orderId: "order-id-here" },
+  },
+});
+
+if (data) {
+  console.log("Order cancelled! New balance:", data.newBalance);
+}
+```
+
+### Positions & Orders
+
+#### Get Your Orders
+
+```typescript
+const { data, error } = await client.POST("/event/orders", {
+  body: {
+    page: 1,
+    limit: 20,
+    filter: {
+      isOpen: true, // Only open orders
+    },
+  },
+});
+
+data?.data.forEach((order) => {
+  console.log(`${order.side} ${order.size} @ ${order.price} - ${order.status}`);
+});
+```
+
+#### Get Your Positions
+
+```typescript
+const { data, error } = await client.POST("/event/positions", {
+  body: {
+    page: 1,
+    limit: 20,
+  },
+});
+
+data?.data.forEach((position) => {
+  console.log(
+    `Position: ${position.part} shares, avg price: ${position.avgPrice}`,
+  );
+});
+```
+
+#### Collect Position (After Event Resolution)
+
+```typescript
+const { data, error } = await client.POST("/event/collect-position", {
+  body: {
+    positionId: "position-id-here",
+  },
+});
+
+if (data) {
+  console.log("Position collected! New balance:", data.newBalance);
+}
+```
+
+### User Profile
+
+```typescript
+const { data, error } = await client.GET("/user/profile", {
+  params: {
+    query: {
+      fields: ["id", "username", "balance", "totalBalance", "bonusBalance"],
+    },
+  },
+});
+
+console.log("User:", data?.user?.username);
+console.log("Balance:", data?.user?.balance);
+```
+
+## Error Handling
+
+The SDK returns errors in a consistent format:
+
+```typescript
+const { data, error } = await client.POST("/event/place-order", {
+  body: {
+    /* ... */
+  },
+});
+
+if (error) {
+  // error has type-safe structure based on the endpoint
+  console.error("Error:", error.message);
+  console.error("Error type:", error.error);
+
+  // Handle specific error types
+  if (error.error === "BetsClosed") {
+    console.log("Trading is closed for this outcome");
+  } else if (error.error === "InsufficientBalance") {
+    console.log("Not enough balance");
+  }
+}
+```
+
+Common error types:
+
+- `BetsClosed` - Trading is closed for this outcome
+- `EmptyOrderBook` - No liquidity for market orders
+- `InternalRestriction` - Order restrictions apply
+- `InsufficientBalance` - Not enough balance
+- `EventNotFound` - Event doesn't exist
+- `NotFound` - Resource not found
+
+## TypeScript Support
+
+The SDK provides full TypeScript support with auto-generated types from the OpenAPI specification:
+
+```typescript
+import type { paths, components } from "@wahoopredict/trading-sdk";
+
+// Use component types
+type Event = components["schemas"]["Event"];
+type Order = components["schemas"]["Order"];
+type Position = components["schemas"]["Position"];
+
+// Use path types for custom implementations
+type PlaceOrderBody =
+  paths["/event/place-order"]["post"]["requestBody"]["content"]["application/json"];
+```
+
+## Configuration
+
+### Custom Base URL
+
+```typescript
+const client = createWahooClient({
+  apiKey: "your-api-key",
+  secretKey: "your-secret-key",
+  baseUrl: "https://staging-api.wahoopredict.com/oapi/v2", // Optional
+});
+```
+
+### Environment Variables
+
+We recommend storing credentials in environment variables:
+
+```typescript
+const client = createWahooClient({
+  apiKey: process.env.WAHOO_API_KEY!,
+  secretKey: process.env.WAHOO_SECRET_KEY!,
+});
+```
+
+## License
+
+MIT

package/dist/cjs/client.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_BASE_URL () {
+        return DEFAULT_BASE_URL;
+    },
+    get createAuthMiddleware () {
+        return createAuthMiddleware;
+    },
+    get /**
+ * Creates a type-safe WahooPredict API client
+ *
+ * @param config - Configuration options including API credentials
+ * @returns A configured openapi-fetch client with authentication
+ *
+ * @example
+ * ```typescript
+ * import { createWahooClient } from '@wahoopredict/trading-sdk';
+ *
+ * const client = createWahooClient({
+ *   apiKey: 'your-api-key',
+ *   secretKey: 'your-secret-key',
+ * });
+ *
+ * // Get user profile
+ * const { data, error } = await client.GET('/user/profile', {
+ *   params: { query: { fields: ['balance'] } },
+ * });
+ * ```
+ */ default () {
+        return createWahooClient;
+    },
+    get generateSignature () {
+        return generateSignature;
+    }
+});
+const _openapifetch = /*#__PURE__*/ _interop_require_default(require("openapi-fetch"));
+const _nodecrypto = /*#__PURE__*/ _interop_require_wildcard(require("node:crypto"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/**
+ * Default base URL for the WahooPredict API
+ */ const DEFAULT_BASE_URL = "https://api.wahoopredict.com/oapi/v2";
+/**
+ * Configuration options for the WahooPredict client
+ */ /** Your API key from WahooPredict */ /** Your secret key for signing requests */ /** Optional custom base URL (defaults to production API) */ /**
+ * Generates HMAC-SHA256 signature for API authentication
+ */ function generateSignature(apiKey, secretKey, timestamp, requestBody) {
+    const dataToSign = `${apiKey}${timestamp}${requestBody}`;
+    return _nodecrypto.createHmac("sha256", secretKey).update(dataToSign).digest("hex");
+}
+/**
+ * Creates an authentication middleware for the WahooPredict API
+ */ function createAuthMiddleware(apiKey, secretKey) {
+    return {
+        async onRequest ({ request }) {
+            const timestamp = Math.round(Date.now() / 1000);
+            const urlParts = request.url.split("?");
+            const rawQuery = urlParts.length > 1 ? urlParts[1] : "";
+            const rawBody = await request.clone().text();
+            const requestBody = rawQuery && rawBody ? `${rawQuery}${rawBody}` : rawQuery || rawBody;
+            const signature = generateSignature(apiKey, secretKey, timestamp, requestBody);
+            request.headers.set("X-API-KEY", apiKey);
+            request.headers.set("X-TIMESTAMP", timestamp.toString());
+            request.headers.set("X-SIGNATURE", signature);
+            return request;
+        }
+    };
+}
+function createWahooClient(config) {
+    const { apiKey, secretKey, baseUrl = DEFAULT_BASE_URL } = config;
+    const client = (0, _openapifetch.default)({
+        baseUrl
+    });
+    client.use(createAuthMiddleware(apiKey, secretKey));
+    return client;
+}

package/dist/cjs/client.spec.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _globals = require("@jest/globals");
+const _client = /*#__PURE__*/ _interop_require_wildcard(require("./client.js"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/**
+ * Creates mock middleware callback params for testing
+ */ function createMockMiddlewareParams(request, schemaPath) {
+    return {
+        request,
+        params: {},
+        schemaPath,
+        id: "test-request-id",
+        options: {
+            baseUrl: "https://api.wahoopredict.com/oapi/v2",
+            parseAs: "json",
+            querySerializer: (query)=>new URLSearchParams(query).toString(),
+            bodySerializer: (body)=>JSON.stringify(body),
+            fetch: globalThis.fetch
+        }
+    };
+}
+(0, _globals.describe)("generateSignature", ()=>{
+    (0, _globals.it)("should generate consistent HMAC-SHA256 signature", ()=>{
+        const apiKey = "test-api-key";
+        const secretKey = "test-secret-key";
+        const timestamp = 1704067200;
+        // 2024-01-01 00:00:00 UTC
+        const requestBody = '{"test":"data"}';
+        const signature = (0, _client.generateSignature)(apiKey, secretKey, timestamp, requestBody);
+        // Signature should be a hex string of 64 characters (256 bits = 32 bytes = 64 hex chars)
+        (0, _globals.expect)(signature).toMatch(/^[a-f0-9]{64}$/);
+        // Same inputs should produce same output
+        const signature2 = (0, _client.generateSignature)(apiKey, secretKey, timestamp, requestBody);
+        (0, _globals.expect)(signature).toBe(signature2);
+    });
+    (0, _globals.it)("should produce different signatures for different inputs", ()=>{
+        const apiKey = "test-api-key";
+        const secretKey = "test-secret-key";
+        const timestamp = 1704067200;
+        const sig1 = (0, _client.generateSignature)(apiKey, secretKey, timestamp, '{"a":"1"}');
+        const sig2 = (0, _client.generateSignature)(apiKey, secretKey, timestamp, '{"a":"2"}');
+        (0, _globals.expect)(sig1).not.toBe(sig2);
+    });
+    (0, _globals.it)("should handle empty request body", ()=>{
+        const apiKey = "test-api-key";
+        const secretKey = "test-secret-key";
+        const timestamp = 1704067200;
+        const signature = (0, _client.generateSignature)(apiKey, secretKey, timestamp, "");
+        (0, _globals.expect)(signature).toMatch(/^[a-f0-9]{64}$/);
+    });
+});
+(0, _globals.describe)("createAuthMiddleware", ()=>{
+    (0, _globals.it)("should create middleware that adds auth headers", async ()=>{
+        const apiKey = "test-api-key";
+        const secretKey = "test-secret-key";
+        const middleware = (0, _client.createAuthMiddleware)(apiKey, secretKey);
+        // Create a mock request
+        const mockRequest = new Request("https://api.wahoopredict.com/oapi/v2/user/profile", {
+            method: "GET"
+        });
+        const result = await middleware.onRequest(createMockMiddlewareParams(mockRequest, "/user/profile"));
+        (0, _globals.expect)(result).toBeInstanceOf(Request);
+        const resultRequest = result;
+        (0, _globals.expect)(resultRequest.headers.get("X-API-KEY")).toBe(apiKey);
+        (0, _globals.expect)(resultRequest.headers.get("X-TIMESTAMP")).toMatch(/^\d+$/);
+        (0, _globals.expect)(resultRequest.headers.get("X-SIGNATURE")).toMatch(/^[a-f0-9]{64}$/);
+    });
+    (0, _globals.it)("should include request body in signature calculation", async ()=>{
+        const apiKey = "test-api-key";
+        const secretKey = "test-secret-key";
+        const middleware = (0, _client.createAuthMiddleware)(apiKey, secretKey);
+        const body = JSON.stringify({
+            eventId: "test-event"
+        });
+        const mockRequest = new Request("https://api.wahoopredict.com/oapi/v2/event/place-order", {
+            method: "POST",
+            body,
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+        const result = await middleware.onRequest(createMockMiddlewareParams(mockRequest, "/event/place-order"));
+        const resultRequest = result;
+        (0, _globals.expect)(resultRequest.headers.get("X-SIGNATURE")).toMatch(/^[a-f0-9]{64}$/);
+    });
+});
+(0, _globals.describe)("createWahooClient", ()=>{
+    (0, _globals.it)("should create client with default base URL", ()=>{
+        const client = (0, _client.default)({
+            apiKey: "test-api-key",
+            secretKey: "test-secret-key"
+        });
+        (0, _globals.expect)(client).toBeDefined();
+        (0, _globals.expect)(client.GET).toBeDefined();
+        (0, _globals.expect)(client.POST).toBeDefined();
+        (0, _globals.expect)(client.DELETE).toBeDefined();
+    });
+    (0, _globals.it)("should create client with custom base URL", ()=>{
+        const customUrl = "https://custom.api.com/v2";
+        const client = (0, _client.default)({
+            apiKey: "test-api-key",
+            secretKey: "test-secret-key",
+            baseUrl: customUrl
+        });
+        (0, _globals.expect)(client).toBeDefined();
+    });
+    (0, _globals.it)("should export DEFAULT_BASE_URL", ()=>{
+        (0, _globals.expect)(_client.DEFAULT_BASE_URL).toBe("https://api.wahoopredict.com/oapi/v2");
+    });
+});

package/dist/cjs/index.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_BASE_URL () {
+        return _client.DEFAULT_BASE_URL;
+    },
+    get createAuthMiddleware () {
+        return _client.createAuthMiddleware;
+    },
+    get /**
+ * WahooPredict Trading SDK
+ *
+ * TypeScript SDK for the WahooPredict trading API.
+ * Built on top of openapi-fetch for type-safe API calls.
+ */ createWahooClient () {
+        return _client.default;
+    },
+    get generateSignature () {
+        return _client.generateSignature;
+    }
+});
+const _client = /*#__PURE__*/ _interop_require_wildcard(require("./client.js" // Re-export useful types from openapi-fetch
+));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}

package/dist/cjs/schema.d.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});