@vesper85/strategy-sdk 0.1.0

package/dist/context/osiris-context.d.ts

@@ -0,0 +1,14 @@
+import type { OsirisContext, SignerAPI, PolymarketClientOptions } from "../types/osiris";
+export interface OsirisContextConfig {
+    strategyId: string;
+    market: 'polymarket' | 'hyperliquid';
+    userAddress: string;
+    signer: SignerAPI;
+    /** Options specific to Polymarket trading */
+    polymarketOptions?: PolymarketClientOptions;
+}
+/**
+ * Creates an OsirisContext with the appropriate market APIs based on configuration
+ */
+export declare function createOsirisContext(config: OsirisContextConfig): OsirisContext;
+//# sourceMappingURL=osiris-context.d.ts.map

package/dist/engine/event-runner.d.ts

@@ -0,0 +1,129 @@
+import type { CodeStrategy } from "../types/strategy";
+import type { OsirisContext } from "../types/osiris";
+import type { Logger } from "../utils/logger";
+/**
+ * Configuration for the EventRunner
+ */
+export interface EventRunnerConfig {
+    /** Logger instance for logging */
+    logger: Logger;
+    /** WebSocket URL for the event source server */
+    eventSourceUrl: string;
+    /** Optional strategy ID for logging (defaults to 'unnamed-strategy') */
+    strategyId?: string;
+    /** Reconnection settings */
+    reconnect?: {
+        /** Maximum number of reconnection attempts (default: 10) */
+        maxAttempts?: number;
+        /** Base delay between reconnection attempts in ms (default: 1000) */
+        delayMs?: number;
+        /** Maximum delay between reconnection attempts in ms (default: 30000) */
+        maxDelayMs?: number;
+    };
+}
+/**
+ * Event Runner for event-based strategy execution
+ *
+ * Connects to an external WebSocket event source and dispatches
+ * events to the strategy's onEvent handler.
+ *
+ * @example
+ * ```typescript
+ * const runner = createEventRunner(strategy, {
+ *     strategyId: 'my-strategy',
+ *     market: 'polymarket',
+ *     logger: createConsoleLogger(),
+ *     eventSourceUrl: 'wss://events.example.com/ws',
+ * }, context);
+ *
+ * runner.start();
+ * // ... later
+ * runner.stop();
+ * ```
+ */
+export declare class EventRunner {
+    private strategy;
+    private config;
+    private context;
+    private ws;
+    private isRunning;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private isIntentionallyClosed;
+    private readonly maxReconnectAttempts;
+    private readonly baseReconnectDelay;
+    private readonly maxReconnectDelay;
+    constructor(strategy: CodeStrategy, config: EventRunnerConfig, context: OsirisContext);
+    /**
+     * Start listening to events
+     * Connects to the WebSocket and subscribes to events
+     */
+    start(): void;
+    /**
+     * Stop listening and disconnect from WebSocket
+     */
+    stop(): void;
+    /**
+     * Check if the runner is currently active
+     */
+    isActive(): boolean;
+    /**
+     * Get current connection status
+     */
+    getStatus(): {
+        running: boolean;
+        connected: boolean;
+        reconnectAttempts: number;
+        subscriptionCount: number;
+    };
+    /**
+     * Connect to the WebSocket event source
+     */
+    private connect;
+    /**
+     * Attempt to reconnect with exponential backoff
+     */
+    private attemptReconnect;
+    /**
+     * Subscribe to events based on strategy's subscriptions
+     */
+    private subscribeToEvents;
+    /**
+     * Unsubscribe from events before disconnecting
+     */
+    private unsubscribeFromEvents;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleMessage;
+    /**
+     * Validate that a message is a valid StrategyEvent
+     */
+    private isValidEvent;
+    /**
+     * Dispatch an event to the strategy's onEvent handler
+     */
+    private dispatchEvent;
+}
+/**
+ * Create an EventRunner instance for event-based strategy execution
+ *
+ * @param strategy - The strategy to run (must have subscriptions and onEvent)
+ * @param config - Runner configuration
+ * @param context - Osiris context with market APIs
+ * @returns EventRunner instance
+ *
+ * @example
+ * ```typescript
+ * const runner = createEventRunner(myStrategy, {
+ *     strategyId: 'price-alert-strategy',
+ *     market: 'polymarket',
+ *     logger: createConsoleLogger(),
+ *     eventSourceUrl: 'wss://events.mybackend.com/ws',
+ * }, context);
+ *
+ * runner.start();
+ * ```
+ */
+export declare function createEventRunner(strategy: CodeStrategy, config: EventRunnerConfig, context: OsirisContext): EventRunner;
+//# sourceMappingURL=event-runner.d.ts.map

package/dist/engine/strategy-runner.d.ts

@@ -0,0 +1,65 @@
+import type { CodeStrategy } from "../types/strategy";
+import type { OsirisContext } from "../types/osiris";
+import type { Logger } from "../utils/logger";
+export interface StrategyRunnerConfig {
+    /** Logger instance for logging */
+    logger: Logger;
+    /** Optional strategy ID for logging (defaults to 'unnamed-strategy') */
+    strategyId?: string;
+}
+export interface StrategyEngineConfig extends StrategyRunnerConfig {
+    /** Interval between ticks in milliseconds (default: 60000) */
+    tickIntervalMs?: number;
+}
+/**
+ * Run a strategy once (one-off execution for tick-based strategies)
+ * Returns true if the strategy was triggered, false otherwise
+ *
+ * @throws Error if strategy doesn't have tick-based methods
+ */
+export declare function runStrategy(strategy: CodeStrategy, config: StrategyRunnerConfig, context: OsirisContext): Promise<boolean>;
+/**
+ * Create a strategy engine that runs a strategy on a tick interval
+ * Returns a controller object to start/stop the engine
+ */
+export declare function createStrategyEngine(strategy: CodeStrategy, config: StrategyEngineConfig, context: OsirisContext): StrategyEngine;
+/**
+ * Strategy Engine that runs a strategy on a tick interval
+ */
+export declare class StrategyEngine {
+    private strategy;
+    private config;
+    private context;
+    private intervalId;
+    private isRunning;
+    constructor(strategy: CodeStrategy, config: StrategyEngineConfig, context: OsirisContext);
+    /**
+     * Start the engine with the configured tick interval
+     */
+    start(): void;
+    /**
+     * Stop the engine
+     */
+    stop(): void;
+    /**
+     * Check if the engine is currently running
+     */
+    isActive(): boolean;
+    private tick;
+}
+/**
+ * Check if a strategy is event-based
+ * Event-based strategies have subscriptions and an onEvent handler
+ */
+export declare function isEventBasedStrategy(strategy: CodeStrategy): boolean;
+/**
+ * Check if a strategy is tick-based
+ * Tick-based strategies have shouldTrigger and onTrigger methods
+ */
+export declare function isTickBasedStrategy(strategy: CodeStrategy): boolean;
+/**
+ * Validate that a strategy has the required methods for its execution mode
+ * @throws Error if strategy is invalid
+ */
+export declare function validateStrategy(strategy: CodeStrategy): void;
+//# sourceMappingURL=strategy-runner.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type { CodeStrategy, } from './types/strategy';
+export type { OsirisContext, OsirisState, PolymarketAPI, HyperliquidAPI, TechnicalAnalysisAPI, SignerAPI, PolymarketOrderSide, PolymarketLimitOrderParams, PolymarketMarketOrderParams, PolymarketOrderResponse, PolymarketOpenOrder, PolymarketCancelResponse, PolymarketOrderBook, PolymarketOrderBookEntry, PolymarketApprovalResult, PolymarketClientOptions, } from './types/osiris';
+export type { EventType, EventSubscription, EventConditions, StrategyEvent, EventData, EventSourceSubscribeMessage, EventSourceUnsubscribeMessage, EventSourceMessage, } from './types/event-types';
+export { PolymarketClient, } from './clients/polymarket-client';
+export { HyperliquidClient, } from './clients/hyperliquid-client';
+export { MemoryStateManager, } from './state/memory-state';
+export { RedisStateManager, } from './state/redis-state';
+export { createOsirisContext, type OsirisContextConfig, } from './context/osiris-context';
+export { runStrategy, createStrategyEngine, StrategyEngine, isEventBasedStrategy, isTickBasedStrategy, validateStrategy, type StrategyRunnerConfig, type StrategyEngineConfig, } from './engine/strategy-runner';
+export { EventRunner, createEventRunner, type EventRunnerConfig, } from './engine/event-runner';
+export { createConsoleLogger, type Logger, } from './utils/logger';
+export { Signer, OsirisSigner, PrivateKeySigner, type ISigner, type SignerConfig, type OsirisSignerConfig, type PrivateKeySignerConfig, } from './signer';
+//# sourceMappingURL=index.d.ts.map