@vesper85/strategy-sdk 0.1.0

package/dist/signer/index.d.ts

@@ -0,0 +1,54 @@
+import type { ISigner, SignerConfig } from './types';
+/**
+ * Signer class that supports multiple signing modes:
+ * - 'osiris': Signs via Osiris Hub API (requires OAuth token and connection)
+ * - 'privateKey': Signs directly with a private key (EVM chains)
+ *
+ * @example Osiris mode
+ * ```typescript
+ * const signer = new Signer({
+ *   mode: 'osiris',
+ *   config: {
+ *     hubBaseUrl: 'https://api.osirislabs.xyz/v1',
+ *     accessToken: 'your-oauth-token',
+ *     connectionId: 'wallet-connection-id'
+ *   }
+ * });
+ * ```
+ *
+ * @example Private Key mode
+ * ```typescript
+ * const signer = new Signer({
+ *   mode: 'privateKey',
+ *   config: {
+ *     privateKey: '0x...',
+ *     chain: 'evm:eip155:1' // optional, defaults to mainnet
+ *   }
+ * });
+ * ```
+ */
+export declare class Signer implements ISigner {
+    private impl;
+    constructor(config: SignerConfig);
+    /**
+     * Get the wallet address (only available for privateKey mode)
+     */
+    getAddress(): string | undefined;
+    /**
+     * Sign a transaction via Osiris Hub
+     */
+    signTransaction(transaction: string | any, chain: string, walletAddress: string): Promise<string>;
+    /**
+     * Sign typed data (EIP-712 for EVM) via Osiris Hub
+     */
+    signTypedData(typedData: any, chain: string, walletAddress: string): Promise<string>;
+    /**
+     * Sign a message via Osiris Hub
+     */
+    signMessage(message: string | Uint8Array, chain: string, walletAddress: string): Promise<string>;
+    getPrivateKey(): string | undefined;
+}
+export { OsirisSigner } from './osiris-signer';
+export { PrivateKeySigner } from './privatekey-signer';
+export type { ISigner, SignerConfig, OsirisSignerConfig, PrivateKeySignerConfig } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+import type { ISigner } from './types';
+import type { OsirisSignerConfig } from './types';
+/**
+ * Osiris signer implementation using the Osiris Hub API
+ * Signs transactions through the hub's wallet signing endpoint
+ */
+export declare class OsirisSigner implements ISigner {
+    private hubBaseUrl;
+    private accessToken;
+    private connectionId;
+    constructor(config: OsirisSignerConfig);
+    /**
+     * Sign a transaction via Osiris Hub API
+     * @param walletAddress - Required wallet address for signing
+     */
+    signTransaction(transaction: string | any, chain: string, walletAddress: string): Promise<string>;
+    /**
+     * Sign typed data (EIP-712) via Osiris Hub API
+     * @param walletAddress - Required wallet address for signing
+     */
+    signTypedData(typedData: any, chain: string, walletAddress: string): Promise<string>;
+    /**
+     * Sign a message via Osiris Hub API
+     * @param walletAddress - Required wallet address for signing
+     */
+    signMessage(message: string | Uint8Array, chain: string, walletAddress: string): Promise<string>;
+    getPrivateKey(): string | undefined;
+}
+//# sourceMappingURL=osiris-signer.d.ts.map

package/dist/signer/privatekey-signer.d.ts

@@ -0,0 +1,41 @@
+import type { ISigner, PrivateKeySignerConfig } from './types';
+/**
+ * Private key signer implementation for EVM chains
+ * Signs transactions directly using a private key
+ */
+export declare class PrivateKeySigner implements ISigner {
+    private account;
+    private defaultChain;
+    private clientCache;
+    private privateKey;
+    constructor(config: PrivateKeySignerConfig);
+    /**
+     * Get the wallet address derived from the private key
+     */
+    getAddress(): string;
+    /**
+     * Get the private key (needed for CLOB client initialization)
+     * @returns The private key with 0x prefix
+     */
+    getPrivateKey(): string;
+    /**
+     * Get or create a wallet client for the specified chain
+     */
+    private getClient;
+    /**
+     * Sign a transaction with the private key
+     * @param walletAddress - Ignored for private key signer (uses derived address)
+     */
+    signTransaction(transaction: string | any, chain: string, _walletAddress: string): Promise<string>;
+    /**
+     * Sign typed data (EIP-712) with the private key
+     * @param walletAddress - Ignored for private key signer (uses derived address)
+     */
+    signTypedData(typedData: any, chain: string, _walletAddress: string): Promise<string>;
+    /**
+     * Sign a message with the private key
+     * @param walletAddress - Ignored for private key signer (uses derived address)
+     */
+    signMessage(message: string | Uint8Array, chain: string, _walletAddress: string): Promise<string>;
+}
+//# sourceMappingURL=privatekey-signer.d.ts.map

package/dist/signer/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Signer method types
+ */
+export type SignerMethod = 'signTransaction' | 'signTypedData' | 'signMessage';
+/**
+ * Signer interface for Osiris Hub-based signing
+ */
+export interface ISigner {
+    /**
+     * Sign a transaction via Osiris Hub
+     * @param transaction - Serialized transaction or transaction object
+     * @param chain - Chain identifier (e.g., 'evm:eip155:1' or 'solana:mainnet')
+     * @param walletAddress - Wallet address (required)
+     * @returns Signed transaction as hex string
+     */
+    signTransaction(transaction: string | any, chain: string, walletAddress: string): Promise<string>;
+    /**
+     * Sign typed data (EIP-712 for EVM) via Osiris Hub
+     * @param typedData - Typed data object
+     * @param chain - Chain identifier
+     * @param walletAddress - Wallet address (required)
+     * @returns Signature as hex string
+     */
+    signTypedData(typedData: any, chain: string, walletAddress: string): Promise<string>;
+    /**
+     * Sign a message via Osiris Hub
+     * @param message - Message to sign (string or bytes)
+     * @param chain - Chain identifier
+     * @param walletAddress - Wallet address (required)
+     * @returns Signature as hex string
+     */
+    signMessage(message: string | Uint8Array, chain: string, walletAddress: string): Promise<string>;
+    getPrivateKey(): string | undefined;
+}
+/**
+ * Configuration for Osiris signer mode
+ */
+export interface OsirisSignerConfig {
+    hubBaseUrl: string;
+    accessToken: string;
+    connectionId: string;
+}
+/**
+ * Configuration for Private Key signer mode
+ */
+export interface PrivateKeySignerConfig {
+    /** Private key (with or without 0x prefix) */
+    privateKey: string;
+    /** Default chain identifier (e.g., 'evm:eip155:1') */
+    chain?: string;
+}
+/**
+ * Signer configuration - supports Osiris Hub or Private Key modes
+ */
+export type SignerConfig = {
+    mode: 'osiris';
+    config: OsirisSignerConfig;
+} | {
+    mode: 'privateKey';
+    config: PrivateKeySignerConfig;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/state/memory-state.d.ts

@@ -0,0 +1,17 @@
+import type { OsirisState } from "../types/osiris";
+/**
+ * In-memory state manager for standalone strategy execution
+ * Perfect for testing and development
+ */
+export declare class MemoryStateManager implements OsirisState {
+    private storage;
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    /**
+     * Get all keys (useful for debugging)
+     */
+    getAllKeys(): string[];
+}
+//# sourceMappingURL=memory-state.d.ts.map

package/dist/state/redis-state.d.ts

@@ -0,0 +1,20 @@
+import type { OsirisState } from "../types/osiris";
+import type { Logger } from "../utils/logger";
+/**
+ * Redis-based state manager for persistent state across strategy executions
+ * Requires a Redis connection
+ */
+export declare class RedisStateManager implements OsirisState {
+    private client;
+    private strategyId;
+    private logger;
+    constructor(redisUrl: string, strategyId: string, logger: Logger);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private getKey;
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=redis-state.d.ts.map

package/dist/types/event-types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Event types for event-based strategy execution
+ */
+/**
+ * Supported event types
+ */
+export type EventType = 'price' | 'orderbook' | 'time' | 'trade' | 'fill' | 'liquidation' | 'custom';
+/**
+ * Conditions for filtering events
+ */
+export interface EventConditions {
+    /** Trigger when price goes above this value */
+    priceAbove?: number;
+    /** Trigger when price goes below this value */
+    priceBelow?: number;
+    /** Trigger on percentage price change */
+    priceChangePercent?: number;
+    /** Cron expression for scheduled events (e.g., "0 * * * *" for hourly) */
+    cron?: string;
+    /** Interval in milliseconds for recurring events */
+    interval?: number;
+    /** Trigger when spread percentage is above this value */
+    spreadAbove?: number;
+    /** Trigger when spread percentage is below this value */
+    spreadBelow?: number;
+    /** Trigger when volume exceeds this value */
+    volumeAbove?: number;
+    [key: string]: any;
+}
+/**
+ * Event subscription configuration
+ * Defines what events a strategy wants to receive
+ */
+export interface EventSubscription {
+    /** Type of event to subscribe to */
+    type: EventType;
+    /** Market/asset identifier (e.g., token ID, trading pair like "BTC-USD") */
+    market?: string;
+    /** Optional filter conditions */
+    conditions?: EventConditions;
+    /** Optional custom channel name for the event source */
+    channel?: string;
+}
+/**
+ * Data payload for strategy events
+ */
+export interface EventData {
+    /** Current price */
+    price?: number;
+    /** Previous price (before the change) */
+    previousPrice?: number;
+    /** Percentage change from previous price */
+    changePercent?: number;
+    /** Best bid price */
+    bestBid?: number;
+    /** Best ask price */
+    bestAsk?: number;
+    /** Spread percentage */
+    spread?: number;
+    /** Bid depth */
+    bidDepth?: number;
+    /** Ask depth */
+    askDepth?: number;
+    /** Trade side */
+    side?: 'buy' | 'sell';
+    /** Trade size */
+    size?: number;
+    /** Trade/order ID */
+    tradeId?: string;
+    /** Order ID (for fills) */
+    orderId?: string;
+    /** Trading volume */
+    volume?: number;
+    raw?: any;
+    [key: string]: any;
+}
+/**
+ * Strategy event passed to onEvent handler
+ */
+export interface StrategyEvent {
+    /** Event type */
+    type: EventType;
+    /** Timestamp when event occurred (Unix milliseconds) */
+    timestamp: number;
+    /** Market/asset this event relates to */
+    market?: string;
+    /** Event-specific data payload */
+    data: EventData;
+}
+/**
+ * WebSocket message types for event source protocol
+ */
+export interface EventSourceSubscribeMessage {
+    action: 'subscribe';
+    subscriptions: EventSubscription[];
+}
+export interface EventSourceUnsubscribeMessage {
+    action: 'unsubscribe';
+    subscriptions: EventSubscription[];
+}
+export type EventSourceMessage = EventSourceSubscribeMessage | EventSourceUnsubscribeMessage;
+//# sourceMappingURL=event-types.d.ts.map