@vesper85/strategy-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2195 @@
+import { PolymarketGammaClient } from 'polymarket-gamma';
+import { ClobClient, Side } from '@polymarket/clob-client';
+import { MaxUint256, ethers } from 'ethers';
+import axios from 'axios';
+import { serializeSignature, createWalletClient, http } from 'viem';
+import { connectMCPServer, removeConnection } from '@osiris-ai/agent-sdk';
+import { Hyperliquid } from 'hyperliquid';
+import { createClient } from 'redis';
+import superjson from 'superjson';
+import { TechnicalAnalysisService } from '@vesper85/technical-indicators';
+import WebSocket from 'ws';
+import { privateKeyToAccount } from 'viem/accounts';
+import { sepolia, base, optimism, arbitrum, polygon, mainnet } from 'viem/chains';
+
+// @osiris-ai/strategy-sdk - Strategy SDK for Trading
+
+var OsirisSigner = class {
+  hubBaseUrl;
+  accessToken;
+  connectionId;
+  constructor(config) {
+    this.hubBaseUrl = config.hubBaseUrl.replace(/\/$/, "");
+    this.accessToken = config.accessToken;
+    this.connectionId = config.connectionId;
+  }
+  /**
+   * Sign a transaction via Osiris Hub API
+   * @param walletAddress - Required wallet address for signing
+   */
+  async signTransaction(transaction, chain, walletAddress) {
+    try {
+      const serializedTx = typeof transaction === "string" ? transaction : JSON.stringify(transaction);
+      const response = await axios.post(
+        `${this.hubBaseUrl}/hub/wallet/sign`,
+        {
+          id: this.connectionId,
+          method: "signTransaction",
+          walletAddress,
+          chain,
+          payload: {
+            serializedTransaction: serializedTx
+          }
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.accessToken}`
+          },
+          timeout: 3e4
+        }
+      );
+      if (response.data.status !== "SUCCESS" && response.data.status !== "success") {
+        throw new Error(response.data.error || "Failed to sign transaction");
+      }
+      const signedTx = response.data.data?.signedTransaction || response.data.data?.data?.signedTransaction;
+      if (!signedTx) {
+        throw new Error("No signed transaction in response");
+      }
+      return signedTx.startsWith("0x") ? signedTx : `0x${signedTx}`;
+    } catch (error) {
+      throw new Error(`Osiris signTransaction failed: ${error.message || error}`);
+    }
+  }
+  /**
+   * Sign typed data (EIP-712) via Osiris Hub API
+   * @param walletAddress - Required wallet address for signing
+   */
+  async signTypedData(typedData, chain, walletAddress) {
+    try {
+      const response = await axios.post(
+        `${this.hubBaseUrl}/hub/wallet/sign`,
+        {
+          id: this.connectionId,
+          method: "signTypedData",
+          walletAddress,
+          chain,
+          payload: [typedData]
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.accessToken}`
+          },
+          timeout: 3e4
+        }
+      );
+      if (response.data.status !== "SUCCESS" && response.data.status !== "success") {
+        throw new Error(response.data.error || "Failed to sign typed data");
+      }
+      const signatures = response.data.data?.signatures || response.data.data?.data?.signatures;
+      if (!signatures || signatures.length === 0) {
+        throw new Error("No signature in response");
+      }
+      const signature = signatures[0];
+      if (typeof signature === "string") {
+        return signature.startsWith("0x") ? signature : `0x${signature}`;
+      }
+      if (signature.r && signature.s && signature.v !== void 0) {
+        return serializeSignature({
+          r: signature.r.startsWith("0x") ? signature.r : `0x${signature.r}`,
+          s: signature.s.startsWith("0x") ? signature.s : `0x${signature.s}`,
+          yParity: Number(signature.v)
+        });
+      }
+      throw new Error("Invalid signature format in response");
+    } catch (error) {
+      throw new Error(`Osiris signTypedData failed: ${error.message || error}`);
+    }
+  }
+  /**
+   * Sign a message via Osiris Hub API
+   * @param walletAddress - Required wallet address for signing
+   */
+  async signMessage(message, chain, walletAddress) {
+    try {
+      const messageStr = typeof message === "string" ? message : Buffer.from(message).toString("hex");
+      const response = await axios.post(
+        `${this.hubBaseUrl}/hub/wallet/sign`,
+        {
+          id: this.connectionId,
+          method: "signMessage",
+          walletAddress,
+          chain,
+          payload: [messageStr]
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.accessToken}`
+          },
+          timeout: 3e4
+        }
+      );
+      if (response.data.status !== "SUCCESS" && response.data.status !== "success") {
+        throw new Error(response.data.error || "Failed to sign message");
+      }
+      const signatures = response.data.data?.signatures || response.data.data?.data?.signatures;
+      if (!signatures || signatures.length === 0) {
+        throw new Error("No signature in response");
+      }
+      const signature = signatures[0];
+      return typeof signature === "string" ? signature.startsWith("0x") ? signature : `0x${signature}` : signature;
+    } catch (error) {
+      throw new Error(`Osiris signMessage failed: ${error.message || error}`);
+    }
+  }
+  getPrivateKey() {
+    return void 0;
+  }
+};
+var MaxUint256BigInt = BigInt(MaxUint256.toString());
+var POLYGON_CHAIN_ID = 137;
+var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+var CTF_ADDRESS = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045";
+var CTF_EXCHANGE_ADDRESS = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E";
+var DEFAULT_CLOB_HOST = "https://clob.polymarket.com";
+var POLYGON_RPC_URL = "https://polygon-rpc.com";
+var ERC20_ABI = [
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function allowance(address owner, address spender) external view returns (uint256)",
+  "function balanceOf(address account) external view returns (uint256)"
+];
+var ERC1155_ABI = [
+  "function setApprovalForAll(address operator, bool approved) external",
+  "function isApprovedForAll(address account, address operator) external view returns (bool)"
+];
+var PolymarketClient = class {
+  constructor(logger, signer, userAddress, options) {
+    this.logger = logger;
+    this.signer = signer;
+    this.userAddress = userAddress;
+    this.gammaClient = new PolymarketGammaClient();
+    this.provider = new ethers.JsonRpcProvider(POLYGON_RPC_URL);
+    this.isOsirisSigner = signer instanceof OsirisSigner || signer.impl instanceof OsirisSigner || signer.getPrivateKey() === void 0;
+    this.options = {
+      chainId: options?.chainId ?? POLYGON_CHAIN_ID,
+      autoApprove: options?.autoApprove ?? false,
+      clobHost: options?.clobHost ?? DEFAULT_CLOB_HOST,
+      ...options?.mcpUrl && { mcpUrl: options.mcpUrl },
+      ...options?.mcpAccessToken && { mcpAccessToken: options.mcpAccessToken },
+      ...options?.useMcpForOrders !== void 0 && { useMcpForOrders: options.useMcpForOrders }
+    };
+  }
+  gammaClient;
+  clobClient = null;
+  wallet = null;
+  provider;
+  options;
+  tradingInitialized = false;
+  mcpInstance = null;
+  isOsirisSigner = false;
+  userAddress;
+  // ============================================
+  // CLOB Client Initialization
+  // ============================================
+  async initializeTradingClient() {
+    if (this.tradingInitialized) {
+      this.logger.info("Trading client already initialized");
+      return;
+    }
+    if (!this.signer) {
+      throw new Error("Signer is required to initialize trading client");
+    }
+    const address = this.userAddress;
+    if (!address) {
+      throw new Error("userAddress is required to initialize trading client");
+    }
+    const shouldUseMcp = this.options.useMcpForOrders ?? (this.isOsirisSigner && (this.options.mcpUrl || this.options.mcpAccessToken));
+    if (shouldUseMcp) {
+      try {
+        this.logger.info("Initializing MCP connection for Osiris signer...");
+        const mcpUrl = this.options.mcpUrl;
+        const mcpAccessToken = this.options.mcpAccessToken;
+        if (!mcpAccessToken) {
+          throw new Error("MCP access token is required for MCP mode. Please provide mcpAccessToken in options.");
+        }
+        this.mcpInstance = await connectMCPServer(mcpUrl, mcpAccessToken);
+        this.tradingInitialized = true;
+        this.logger.info(`MCP connection initialized for address: ${address}`);
+        return;
+      } catch (error) {
+        this.logger.error("Failed to initialize MCP connection", error);
+        throw new Error(`Failed to initialize MCP connection: ${error.message}`);
+      }
+    }
+    try {
+      this.logger.info("Initializing CLOB trading client...");
+      const privateKey = await this.signer.getPrivateKey();
+      if (!privateKey) {
+        throw new Error("Could not obtain private key for CLOB client initialization. Private key signer is required for trading.");
+      }
+      this.wallet = new ethers.Wallet(privateKey, this.provider);
+      const tempClient = new ClobClient(
+        this.options.clobHost,
+        this.options.chainId,
+        this.wallet
+        // Cast to any for CLOB client v5 compatibility
+      );
+      this.logger.info("Deriving API credentials...");
+      const apiCreds = await tempClient.createOrDeriveApiKey();
+      const signatureType = 0;
+      this.clobClient = new ClobClient(
+        this.options.clobHost,
+        this.options.chainId,
+        this.wallet,
+        // Cast to any for CLOB client v5 compatibility
+        apiCreds,
+        signatureType
+      );
+      this.tradingInitialized = true;
+      this.logger.info(`Trading client initialized for address: ${address}`);
+    } catch (error) {
+      this.logger.error("Failed to initialize trading client", error);
+      throw new Error(`Failed to initialize trading client: ${error.message}`);
+    }
+  }
+  isTradingClientInitialized() {
+    return this.tradingInitialized;
+  }
+  async getPrivateKeyFromSigner() {
+    if (this.signer && "getPrivateKey" in this.signer) {
+      return this.signer.getPrivateKey();
+    }
+    if (this.signer && this.signer.account?.privateKey) {
+      return this.signer.account.privateKey;
+    }
+    return null;
+  }
+  ensureTradingClient() {
+    if (!this.clobClient || !this.tradingInitialized) {
+      throw new Error("Trading client not initialized. Call initializeTradingClient() first.");
+    }
+    return this.clobClient;
+  }
+  ensureMcpInstance() {
+    if (!this.mcpInstance || !this.tradingInitialized) {
+      throw new Error("MCP connection not initialized. Call initializeTradingClient() first.");
+    }
+    return this.mcpInstance;
+  }
+  /**
+   * Call an MCP tool with retry logic
+   */
+  async callMCPTool(toolName, args) {
+    const instance = this.ensureMcpInstance();
+    const mcpUrl = instance.url;
+    const accessToken = instance.accessToken;
+    try {
+      return await this.executeMCPTool(instance, toolName, args);
+    } catch (error) {
+      this.logger.warning(`Tool execution failed for ${toolName}, reconnecting...`, error instanceof Error ? error.message : error);
+      removeConnection(mcpUrl, accessToken);
+      this.mcpInstance = await connectMCPServer(mcpUrl, accessToken);
+      return await this.executeMCPTool(this.mcpInstance, toolName, args);
+    }
+  }
+  /**
+   * Execute a tool on an MCP client instance
+   */
+  async executeMCPTool(instance, toolName, args) {
+    const client = instance.client;
+    if (client._transport && client._transport._client) {
+      const mcpClient = client._transport._client;
+      const result = await mcpClient.callTool({
+        name: toolName,
+        arguments: args || {}
+      });
+      return result;
+    }
+    const tools = await client.tools();
+    const tool = tools[toolName];
+    if (!tool) {
+      throw new Error(`Tool ${toolName} not found on MCP server ${instance.url}`);
+    }
+    if (typeof tool.execute === "function") {
+      const result = await tool.execute(args || {});
+      return result;
+    }
+    if (typeof tool === "function") {
+      return await tool(args || {});
+    }
+    throw new Error(`Tool ${toolName} is not callable`);
+  }
+  /**
+   * Extract content from MCP tool response (ported from sozu-tg-bot)
+   */
+  extractMCPContent(result) {
+    if (typeof result === "string") {
+      return result;
+    }
+    if (Array.isArray(result.content)) {
+      return result.content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+    }
+    if (typeof result.text === "string") {
+      return result.text;
+    }
+    if (typeof result.result === "string") {
+      return result.result;
+    }
+    if (result.data) {
+      if (typeof result.data === "string") {
+        return result.data;
+      }
+      return JSON.stringify(result.data, null, 2);
+    }
+    return JSON.stringify(result, null, 2);
+  }
+  /**
+   * Extract order details from MCP response (ported from sozu-tg-bot)
+   */
+  extractOrderDetails(resultResponse) {
+    const result = this.extractMCPContent(resultResponse);
+    let orderResponse = null;
+    try {
+      orderResponse = JSON.parse(result);
+    } catch {
+      const codeBlockMatch = result.match(/```(?:json)?\s*(\{[\s\S]*\})\s*```/);
+      if (codeBlockMatch && codeBlockMatch[1]) {
+        try {
+          orderResponse = JSON.parse(codeBlockMatch[1]);
+        } catch {
+        }
+      }
+      if (!orderResponse) {
+        const responseSectionMatch = result.match(/\*\*Response:\*\*\s*\n?\s*(\{[\s\S]*\})/);
+        if (responseSectionMatch && responseSectionMatch[1]) {
+          try {
+            orderResponse = JSON.parse(responseSectionMatch[1]);
+          } catch {
+          }
+        }
+      }
+      if (!orderResponse) {
+        const anyJsonMatch = result.match(/\{[\s\S]*"success"[\s\S]*\}/);
+        if (anyJsonMatch && anyJsonMatch[0]) {
+          try {
+            orderResponse = JSON.parse(anyJsonMatch[0]);
+          } catch {
+          }
+        }
+      }
+    }
+    if (!orderResponse || typeof orderResponse !== "object") {
+      return null;
+    }
+    if (!orderResponse.orderID) {
+      return null;
+    }
+    const transactionHash = orderResponse.transactionsHashes?.[0] || orderResponse.transactionHash || orderResponse.txHash || orderResponse.hash || "";
+    return {
+      orderID: orderResponse.orderID,
+      transactionHash
+    };
+  }
+  /**
+   * Detect errors in MCP tool response (ported from sozu-tg-bot)
+   */
+  detectMCPError(result) {
+    if (result && result.isError === true) {
+      const errorText = this.extractMCPContent(result);
+      return errorText || "Unknown error occurred";
+    }
+    const content = this.extractMCPContent(result);
+    if (!content) {
+      return null;
+    }
+    if (/Error Creating and Posting Order/i.test(content)) {
+      const errorMatch = content.match(/\*\*Error Creating and Posting Order\*\*\s*\n\s*(.+?)(?:\n\n|\n*$)/is);
+      if (errorMatch && errorMatch[1]) {
+        return errorMatch[1].trim();
+      }
+      const fallbackMatch = content.match(/\*\*Error Creating and Posting Order\*\*[\s\n]+(.+)/is);
+      if (fallbackMatch && fallbackMatch[1]) {
+        const firstLine = fallbackMatch[1].trim().split("\n")[0];
+        return firstLine || "Error creating and posting order";
+      }
+      return "Error creating and posting order";
+    }
+    const errorPatterns = [
+      {
+        pattern: /not enough balance/i,
+        extractMessage: () => "Insufficient balance"
+      },
+      {
+        pattern: /not enough allowance/i,
+        extractMessage: () => "Insufficient token allowance"
+      },
+      {
+        pattern: /not enough balance.*allowance|not enough allowance.*balance/i,
+        extractMessage: () => "Insufficient balance or token allowance"
+      },
+      {
+        pattern: /lower than the minimum/i,
+        extractMessage: (content2) => {
+          const lines = content2.split("\n");
+          const errorLine = lines.find((line) => /lower than the minimum/i.test(line));
+          return errorLine ? errorLine.trim() : "Size lower than the minimum";
+        }
+      },
+      {
+        pattern: /higher than the maximum/i,
+        extractMessage: (content2) => {
+          const lines = content2.split("\n");
+          const errorLine = lines.find((line) => /higher than the maximum/i.test(line));
+          return errorLine ? errorLine.trim() : "Size higher than the maximum";
+        }
+      },
+      {
+        pattern: /invalid/i,
+        extractMessage: (content2) => {
+          const lines = content2.split("\n");
+          const errorLine = lines.find((line) => /invalid/i.test(line));
+          return errorLine ? errorLine.trim() : "Invalid order";
+        }
+      },
+      {
+        pattern: /failed/i,
+        extractMessage: (content2) => {
+          const lines = content2.split("\n");
+          const errorLine = lines.find((line) => /failed/i.test(line));
+          return errorLine ? errorLine.trim() : "Order failed";
+        }
+      }
+    ];
+    for (const { pattern, extractMessage } of errorPatterns) {
+      if (pattern.test(content)) {
+        return extractMessage(content);
+      }
+    }
+    return null;
+  }
+  ensureWallet() {
+    if (!this.wallet) {
+      throw new Error("Wallet not initialized. Call initializeTradingClient() first.");
+    }
+    return this.wallet;
+  }
+  // ============================================
+  // Token Approval Methods
+  // ============================================
+  async getUsdcAllowance() {
+    const wallet = this.ensureWallet();
+    const usdcContract = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, this.provider);
+    try {
+      const allowance = await usdcContract.allowance(wallet.address, CTF_EXCHANGE_ADDRESS);
+      return BigInt(allowance.toString());
+    } catch (error) {
+      this.logger.error("Error getting USDC allowance", error);
+      throw error;
+    }
+  }
+  async approveUsdc(amount) {
+    const wallet = this.ensureWallet();
+    const usdcContract = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, wallet);
+    const approvalAmount = amount ?? MaxUint256BigInt;
+    try {
+      this.logger.info(`Approving USDC for CTF Exchange...`);
+      const tx = await usdcContract.approve(CTF_EXCHANGE_ADDRESS, approvalAmount);
+      const receipt = await tx.wait();
+      this.logger.info(`USDC approval confirmed: ${receipt.hash}`);
+      return receipt.hash;
+    } catch (error) {
+      this.logger.error("Error approving USDC", error);
+      throw error;
+    }
+  }
+  async isCtfApprovedForAll() {
+    const wallet = this.ensureWallet();
+    const ctfContract = new ethers.Contract(CTF_ADDRESS, ERC1155_ABI, this.provider);
+    try {
+      const isApproved = await ctfContract.isApprovedForAll(wallet.address, CTF_EXCHANGE_ADDRESS);
+      return isApproved;
+    } catch (error) {
+      this.logger.error("Error checking CTF approval", error);
+      throw error;
+    }
+  }
+  async approveCtf() {
+    const wallet = this.ensureWallet();
+    const ctfContract = new ethers.Contract(CTF_ADDRESS, ERC1155_ABI, wallet);
+    try {
+      this.logger.info(`Approving CTF for CTF Exchange...`);
+      const tx = await ctfContract.setApprovalForAll(CTF_EXCHANGE_ADDRESS, true);
+      const receipt = await tx.wait();
+      this.logger.info(`CTF approval confirmed: ${receipt.hash}`);
+      return receipt.hash;
+    } catch (error) {
+      this.logger.error("Error approving CTF", error);
+      throw error;
+    }
+  }
+  async setupApprovals(options) {
+    const shouldUseMcp = this.options.useMcpForOrders ?? (this.isOsirisSigner && this.mcpInstance !== null);
+    if (shouldUseMcp) {
+      return this.setupApprovalsViaMCP();
+    }
+    const result = {
+      usdcWasAlreadyApproved: false,
+      ctfWasAlreadyApproved: false
+    };
+    const currentAllowance = await this.getUsdcAllowance();
+    const requiredAllowance = options?.usdcAmount ?? MaxUint256BigInt;
+    if (currentAllowance >= requiredAllowance) {
+      result.usdcWasAlreadyApproved = true;
+      this.logger.info("USDC already approved");
+    } else {
+      result.usdcApprovalTx = await this.approveUsdc(options?.usdcAmount);
+    }
+    const ctfApproved = await this.isCtfApprovedForAll();
+    if (ctfApproved) {
+      result.ctfWasAlreadyApproved = true;
+      this.logger.info("CTF already approved");
+    } else {
+      result.ctfApprovalTx = await this.approveCtf();
+    }
+    return result;
+  }
+  // ============================================
+  // MCP-based Token Approval Methods (for OsirisSigner)
+  // ============================================
+  /**
+   * Check token allowance via MCP tools
+   * @param tokenType - "USDC" for buy orders, "CONDITIONAL_TOKEN" for sell orders
+   * @returns true if sufficient allowance exists
+   */
+  async checkAllowanceViaMCP(tokenType) {
+    try {
+      const allowanceResult = await this.callMCPTool("check_allowance", {
+        token: tokenType
+      });
+      this.logger.debug("[MCP] Allowance check result:", allowanceResult);
+      const allowanceContent = this.extractMCPContent(allowanceResult);
+      const contractMatches = allowanceContent?.match(/0x[a-fA-F0-9]{40}:\s*(true|false)/gi);
+      let hasFullAllowance = true;
+      if (contractMatches && contractMatches.length > 0) {
+        hasFullAllowance = contractMatches.every((match) => match.toLowerCase().includes(": true"));
+      } else if (allowanceContent) {
+        const currentAllowanceMatch = allowanceContent.match(/Current Allowance:\s*(\d+)/i);
+        if (currentAllowanceMatch && currentAllowanceMatch[1]) {
+          const allowanceValue = parseInt(currentAllowanceMatch[1], 10);
+          hasFullAllowance = allowanceValue > 0;
+        } else {
+          hasFullAllowance = !allowanceContent.toLowerCase().includes(": false") && !allowanceContent.toLowerCase().includes("no allowance") && !allowanceContent.toLowerCase().includes("insufficient") && !allowanceContent.toLowerCase().includes("current allowance: 0");
+        }
+      }
+      this.logger.info(`[MCP] ${tokenType} allowance check: ${hasFullAllowance ? "sufficient" : "insufficient"}`);
+      return hasFullAllowance;
+    } catch (error) {
+      this.logger.error(`[MCP] Error checking ${tokenType} allowance:`, error);
+      return false;
+    }
+  }
+  /**
+   * Approve tokens via MCP tools
+   * @param tokenType - "USDC" for buy orders, "CONDITIONAL_TOKEN" for sell orders
+   * @returns true if approval was successful
+   */
+  async approveTokensViaMCP(tokenType) {
+    try {
+      this.logger.info(`[MCP] Approving ${tokenType}...`);
+      const approveResult = await this.callMCPTool("approve_polymarket_tokens", {
+        token_type: tokenType === "USDC" ? "USDC" : "CONDITIONAL_TOKENS",
+        amount: "100",
+        // Amount doesn't matter for max_approval=true
+        max_approval: true,
+        approve_all_contracts: true,
+        chainId: 137
+        // Polygon
+      });
+      const approveContent = this.extractMCPContent(approveResult);
+      const mcpError = this.detectMCPError(approveResult);
+      if (mcpError) {
+        this.logger.error(`[MCP] Failed to approve ${tokenType}: ${mcpError}`);
+        return false;
+      }
+      const approvalMatch = approveContent?.match(/(\d+)\/(\d+)\s+approvals?\s+successful/i);
+      if (approvalMatch && approvalMatch[1] && approvalMatch[2]) {
+        const successful = parseInt(approvalMatch[1], 10);
+        const total = parseInt(approvalMatch[2], 10);
+        const allSuccessful = successful === total;
+        if (allSuccessful) {
+          this.logger.info(`[MCP] Successfully approved ${tokenType} (${successful}/${total})`);
+        } else {
+          this.logger.warning(`[MCP] Partial approval for ${tokenType}: ${successful}/${total}`);
+        }
+        return allSuccessful;
+      }
+      const hasError = approveContent && (approveContent.toLowerCase().includes("error") || approveContent.toLowerCase().includes("failed"));
+      if (hasError) {
+        this.logger.error(`[MCP] Failed to approve ${tokenType}:`, approveContent);
+        return false;
+      }
+      this.logger.info(`[MCP] ${tokenType} approval completed`);
+      return true;
+    } catch (error) {
+      this.logger.error(`[MCP] Error approving ${tokenType}:`, error);
+      return false;
+    }
+  }
+  /**
+   * Ensure token approval via MCP before placing orders
+   * @param side - Order side (BUY or SELL)
+   * @returns true if approval is ready
+   */
+  async ensureTokenApprovalViaMCP(side) {
+    const tokenType = side === "BUY" ? "USDC" : "CONDITIONAL_TOKEN";
+    const hasAllowance = await this.checkAllowanceViaMCP(tokenType);
+    if (hasAllowance) {
+      this.logger.info(`[MCP] ${tokenType} already has sufficient allowance`);
+      return true;
+    }
+    const approved = await this.approveTokensViaMCP(tokenType);
+    return approved;
+  }
+  /**
+   * Setup approvals via MCP tools (for OsirisSigner mode)
+   */
+  async setupApprovalsViaMCP() {
+    const result = {
+      usdcWasAlreadyApproved: false,
+      ctfWasAlreadyApproved: false
+    };
+    try {
+      const address = this.userAddress;
+      if (!address) {
+        throw new Error("userAddress is required for MCP approvals");
+      }
+      const chooseWalletResult = await this.callMCPTool("choose_wallet", {
+        address
+      });
+      const walletError = this.detectMCPError(chooseWalletResult);
+      if (walletError) {
+        this.logger.error(`[MCP] Choose wallet failed: ${walletError}`);
+        throw new Error(`Choose wallet failed: ${walletError}`);
+      }
+      const usdcHasAllowance = await this.checkAllowanceViaMCP("USDC");
+      if (usdcHasAllowance) {
+        result.usdcWasAlreadyApproved = true;
+        this.logger.info("[MCP] USDC already approved");
+      } else {
+        const usdcApproved = await this.approveTokensViaMCP("USDC");
+        if (usdcApproved) {
+          result.usdcApprovalTx = "mcp-approval-usdc";
+        }
+      }
+      const ctfHasAllowance = await this.checkAllowanceViaMCP("CONDITIONAL_TOKEN");
+      if (ctfHasAllowance) {
+        result.ctfWasAlreadyApproved = true;
+        this.logger.info("[MCP] CTF already approved");
+      } else {
+        const ctfApproved = await this.approveTokensViaMCP("CONDITIONAL_TOKEN");
+        if (ctfApproved) {
+          result.ctfApprovalTx = "mcp-approval-ctf";
+        }
+      }
+      return result;
+    } catch (error) {
+      this.logger.error("[MCP] Error setting up approvals:", error);
+      throw error;
+    }
+  }
+  // ============================================
+  // Order Methods
+  // ============================================
+  async createLimitOrder(params) {
+    const shouldUseMcp = this.options.useMcpForOrders ?? (this.isOsirisSigner && this.mcpInstance !== null);
+    if (shouldUseMcp) {
+      return this.createLimitOrderViaMCP(params);
+    }
+    const client = this.ensureTradingClient();
+    if (this.options.autoApprove) {
+      await this.ensureApprovals(params.side);
+    }
+    try {
+      this.logger.info(`Creating limit order: ${params.side} ${params.size} @ ${params.price}`);
+      const order = await client.createOrder({
+        tokenID: params.tokenId,
+        price: params.price,
+        side: params.side === "BUY" ? Side.BUY : Side.SELL,
+        size: params.size,
+        feeRateBps: parseInt(params.feeRateBps ?? "0", 10),
+        expiration: params.expiration
+      });
+      const response = await client.postOrder(order);
+      if (response.success) {
+        this.logger.info(`Limit order created: ${response.orderID}`);
+        return {
+          success: true,
+          orderId: response.orderID,
+          transactionHash: response.transactionsHashes?.[0]
+        };
+      } else {
+        this.logger.error(`Limit order failed: ${response.errorMsg}`);
+        return {
+          success: false,
+          errorMsg: response.errorMsg
+        };
+      }
+    } catch (error) {
+      this.logger.error("Error creating limit order", error);
+      return {
+        success: false,
+        errorMsg: error.message
+      };
+    }
+  }
+  /**
+   * Create limit order via MCP tools (for OsirisSigner)
+   */
+  async createLimitOrderViaMCP(params) {
+    try {
+      const address = this.userAddress;
+      if (!address) {
+        throw new Error("userAddress is required for MCP order placement");
+      }
+      this.logger.info(`[MCP] Creating limit order: ${params.side} ${params.size} @ ${params.price}`);
+      this.logger.debug(`[MCP] Using wallet address: ${address}`);
+      this.logger.debug(`[MCP] Calling choose_wallet for address: ${address}`);
+      const chooseWalletResult = await this.callMCPTool("choose_wallet", {
+        address
+      });
+      this.logger.debug(`[MCP] choose_wallet result: ${JSON.stringify(chooseWalletResult, null, 2)}`);
+      const walletError = this.detectMCPError(chooseWalletResult);
+      if (walletError) {
+        this.logger.error(`[MCP] Choose wallet failed: ${walletError}`);
+        return {
+          success: false,
+          errorMsg: walletError
+        };
+      }
+      const approvalSuccess = await this.ensureTokenApprovalViaMCP(params.side);
+      if (!approvalSuccess) {
+        return {
+          success: false,
+          errorMsg: `Failed to approve ${params.side === "BUY" ? "USDC" : "Conditional Token"}. Please try again.`
+        };
+      }
+      const orderParams = {
+        userOrder: {
+          tokenID: params.tokenId,
+          side: params.side,
+          size: params.size,
+          price: params.price
+        },
+        orderType: params.expiration ? "GTD" : "GTC",
+        deferExec: false
+      };
+      this.logger.debug(`[MCP] Limit order params:`, orderParams);
+      this.logger.info(`[MCP] Submitting limit order: ${params.side} ${params.size} @ ${params.price} for token ${params.tokenId.substring(0, 20)}...`);
+      const orderResult = await this.callMCPTool("create_and_post_order", orderParams);
+      this.logger.debug(`[MCP] Raw limit order result: ${JSON.stringify(orderResult, null, 2)}`);
+      const orderError = this.detectMCPError(orderResult);
+      if (orderError) {
+        this.logger.error(`Limit order via MCP failed: ${orderError}`);
+        return {
+          success: false,
+          errorMsg: orderError
+        };
+      }
+      const orderDetails = this.extractOrderDetails(orderResult);
+      if (!orderDetails) {
+        this.logger.error(`Failed to extract order details from MCP response`, orderResult);
+        return {
+          success: false,
+          errorMsg: "Failed to extract order details from MCP response"
+        };
+      }
+      this.logger.info(`[MCP] Limit order created: ${orderDetails.orderID}`);
+      return {
+        success: true,
+        orderId: orderDetails.orderID,
+        transactionHash: orderDetails.transactionHash
+      };
+    } catch (error) {
+      this.logger.error("Error creating limit order via MCP", error);
+      return {
+        success: false,
+        errorMsg: error.message || "Unknown error"
+      };
+    }
+  }
+  async createMarketOrder(params) {
+    const shouldUseMcp = this.options.useMcpForOrders ?? (this.isOsirisSigner && this.mcpInstance !== null);
+    if (shouldUseMcp) {
+      return this.createMarketOrderViaMCP(params);
+    }
+    const client = this.ensureTradingClient();
+    if (this.options.autoApprove) {
+      await this.ensureApprovals(params.side);
+    }
+    try {
+      this.logger.info(`Creating market order: ${params.side} ${params.amount}`);
+      const response = await client.createAndPostMarketOrder({
+        tokenID: params.tokenId,
+        amount: params.amount,
+        side: params.side === "BUY" ? Side.BUY : Side.SELL
+      });
+      if (response.success) {
+        this.logger.info(`Market order executed: ${response.orderID}`);
+        return {
+          success: true,
+          orderId: response.orderID,
+          transactionHash: response.transactionsHashes?.[0]
+        };
+      } else {
+        this.logger.error(`Market order failed: ${response.errorMsg}`);
+        return {
+          success: false,
+          errorMsg: response.errorMsg
+        };
+      }
+    } catch (error) {
+      this.logger.error("Error creating market order", error);
+      return {
+        success: false,
+        errorMsg: error.message
+      };
+    }
+  }
+  /**
+   * Create market order via MCP tools (for OsirisSigner)
+   */
+  async createMarketOrderViaMCP(params) {
+    try {
+      const address = this.userAddress;
+      if (!address) {
+        throw new Error("userAddress is required for MCP order placement");
+      }
+      this.logger.info(`[MCP] Creating market order: ${params.side} ${params.amount} USDC`);
+      this.logger.debug(`[MCP] Using wallet address: ${address}`);
+      this.logger.debug(`[MCP] Order details: tokenId=${params.tokenId}, side=${params.side}, amount=${params.amount}`);
+      this.logger.debug(`[MCP] Calling choose_wallet for address: ${address}`);
+      const chooseWalletResult = await this.callMCPTool("choose_wallet", {
+        address
+      });
+      this.logger.debug(`[MCP] choose_wallet result: ${JSON.stringify(chooseWalletResult, null, 2)}`);
+      const walletError = this.detectMCPError(chooseWalletResult);
+      if (walletError) {
+        this.logger.error(`Choose wallet failed: ${walletError}`);
+        return {
+          success: false,
+          errorMsg: walletError
+        };
+      }
+      const approvalSuccess = await this.ensureTokenApprovalViaMCP(params.side);
+      if (!approvalSuccess) {
+        return {
+          success: false,
+          errorMsg: `Failed to approve ${params.side === "BUY" ? "USDC" : "Conditional Token"}. Please try again.`
+        };
+      }
+      const orderParams = {
+        userMarketOrder: {
+          tokenID: params.tokenId,
+          side: params.side,
+          amount: params.amount
+        },
+        orderType: "FOK"
+        // Fill or Kill
+      };
+      this.logger.debug(`[MCP] Market order params:`, orderParams);
+      this.logger.info(`[MCP] Submitting market order: ${params.side} ${params.amount} USDC for token ${params.tokenId.substring(0, 20)}...`);
+      const orderResult = await this.callMCPTool("create_and_post_market_order", orderParams);
+      this.logger.debug(`[MCP] Raw order result: ${JSON.stringify(orderResult, null, 2)}`);
+      const orderError = this.detectMCPError(orderResult);
+      if (orderError) {
+        this.logger.error(`Market order via MCP failed: ${orderError}`);
+        return {
+          success: false,
+          errorMsg: orderError
+        };
+      }
+      const orderDetails = this.extractOrderDetails(orderResult);
+      if (!orderDetails) {
+        this.logger.error(`Failed to extract order details from MCP response`, orderResult);
+        return {
+          success: false,
+          errorMsg: "Failed to extract order details from MCP response"
+        };
+      }
+      this.logger.info(`Market order via MCP executed: ${orderDetails.orderID}`);
+      return {
+        success: true,
+        orderId: orderDetails.orderID,
+        transactionHash: orderDetails.transactionHash
+      };
+    } catch (error) {
+      this.logger.error("Error creating market order via MCP", error);
+      return {
+        success: false,
+        errorMsg: error.message || "Unknown error"
+      };
+    }
+  }
+  async getOpenOrders() {
+    const client = this.ensureTradingClient();
+    try {
+      const orders = await client.getOpenOrders();
+      return orders.map((order) => ({
+        id: order.id || order.order_id,
+        market: order.market,
+        asset_id: order.asset_id,
+        side: order.side,
+        original_size: order.original_size || order.size,
+        size_matched: order.size_matched || "0",
+        price: order.price,
+        outcome: order.outcome,
+        owner: order.owner,
+        timestamp: order.timestamp || Date.now(),
+        expiration: order.expiration || 0,
+        order_type: order.order_type || "LIMIT"
+      }));
+    } catch (error) {
+      this.logger.error("Error getting open orders", error);
+      throw error;
+    }
+  }
+  async cancelOrder(orderId) {
+    const client = this.ensureTradingClient();
+    try {
+      this.logger.info(`Canceling order: ${orderId}`);
+      const response = await client.cancelOrder({ orderID: orderId });
+      return {
+        canceled: response.canceled || [],
+        not_canceled: response.not_canceled || {}
+      };
+    } catch (error) {
+      this.logger.error("Error canceling order", error);
+      throw error;
+    }
+  }
+  async cancelOrders(orderIds) {
+    const client = this.ensureTradingClient();
+    try {
+      this.logger.info(`Canceling ${orderIds.length} orders`);
+      const response = await client.cancelOrders(orderIds);
+      return {
+        canceled: response.canceled || [],
+        not_canceled: response.not_canceled || {}
+      };
+    } catch (error) {
+      this.logger.error("Error canceling orders", error);
+      throw error;
+    }
+  }
+  async cancelAllOrders() {
+    const client = this.ensureTradingClient();
+    try {
+      this.logger.info("Canceling all orders");
+      const response = await client.cancelAll();
+      return {
+        canceled: response.canceled || [],
+        not_canceled: response.not_canceled || {}
+      };
+    } catch (error) {
+      this.logger.error("Error canceling all orders", error);
+      throw error;
+    }
+  }
+  async getOrderBook(tokenId) {
+    const client = this.ensureTradingClient();
+    try {
+      const book = await client.getOrderBook(tokenId);
+      return book;
+    } catch (error) {
+      this.logger.error("Error getting order book", error);
+      throw error;
+    }
+  }
+  async ensureApprovals(side) {
+    if (side === "BUY") {
+      const allowance = await this.getUsdcAllowance();
+      if (allowance === BigInt(0)) {
+        this.logger.info("Auto-approving USDC...");
+        await this.approveUsdc();
+      }
+    } else {
+      const approved = await this.isCtfApprovedForAll();
+      if (!approved) {
+        this.logger.info("Auto-approving CTF...");
+        await this.approveCtf();
+      }
+    }
+  }
+  // ============================================
+  // Legacy Execution Methods (backward compatible)
+  // ============================================
+  async buy(tokenId, size) {
+    if (!this.tradingInitialized) {
+      throw new Error(
+        `Trading client not initialized. Call initializeTradingClient() before placing orders. Attempted to buy ${size} USDC of token ${tokenId}.`
+      );
+    }
+    const response = await this.createMarketOrder({
+      tokenId,
+      amount: size,
+      side: "BUY"
+    });
+    if (!response.success) {
+      throw new Error(`Buy order failed: ${response.errorMsg}`);
+    }
+  }
+  async sell(tokenId, size) {
+    if (!this.tradingInitialized) {
+      throw new Error(
+        `Trading client not initialized. Call initializeTradingClient() before placing orders. Attempted to sell ${size} shares of token ${tokenId}.`
+      );
+    }
+    const response = await this.createMarketOrder({
+      tokenId,
+      amount: size,
+      side: "SELL"
+    });
+    if (!response.success) {
+      throw new Error(`Sell order failed: ${response.errorMsg}`);
+    }
+  }
+  // ============================================
+  // Convenience Trading Methods
+  // ============================================
+  /**
+   * Place a limit buy order
+   */
+  async buyLimit(tokenId, price, size) {
+    if (!this.tradingInitialized) {
+      throw new Error(
+        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
+      );
+    }
+    return this.createLimitOrder({
+      tokenId,
+      price,
+      size,
+      side: "BUY"
+    });
+  }
+  /**
+   * Place a limit sell order
+   */
+  async sellLimit(tokenId, price, size) {
+    if (!this.tradingInitialized) {
+      throw new Error(
+        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
+      );
+    }
+    return this.createLimitOrder({
+      tokenId,
+      price,
+      size,
+      side: "SELL"
+    });
+  }
+  /**
+   * Place a market buy order
+   */
+  async buyMarket(tokenId, amount, slippage = 0.05) {
+    if (!this.tradingInitialized) {
+      throw new Error(
+        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
+      );
+    }
+    return this.createMarketOrder({
+      tokenId,
+      amount,
+      side: "BUY",
+      slippageTolerance: slippage
+    });
+  }
+  /**
+   * Place a market sell order
+   */
+  async sellMarket(tokenId, size, slippage = 0.05) {
+    if (!this.tradingInitialized) {
+      throw new Error(
+        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
+      );
+    }
+    return this.createMarketOrder({
+      tokenId,
+      amount: size,
+      side: "SELL",
+      slippageTolerance: slippage
+    });
+  }
+  // ============================================
+  // Data Methods
+  // ============================================
+  async getPrice(ticker) {
+    try {
+      const market = await this.gammaClient.getMarket(ticker);
+      if (market.last_trade_price) {
+        return parseFloat(market.last_trade_price);
+      }
+      if (market.best_bid && market.best_ask) {
+        return (parseFloat(market.best_bid) + parseFloat(market.best_ask)) / 2;
+      }
+      return 0;
+    } catch (error) {
+      this.logger.error(`Error fetching price for ${ticker}`, error);
+      return 0;
+    }
+  }
+  async getIndicator(ticker, indicator, params) {
+    this.logger.warning(`getIndicator not implemented for Polymarket`);
+    return 0;
+  }
+  // ============================================
+  // Info Methods
+  // ============================================
+  async search(params) {
+    return this.gammaClient.search(params);
+  }
+  async getMarket(idOrSlug) {
+    return this.gammaClient.getMarket(idOrSlug);
+  }
+  /**
+   * Get markets from Polymarket Gamma API with full filter support
+   * https://docs.polymarket.com/api-reference/markets/list-markets
+   */
+  async getMarkets(filters) {
+    const GAMMA_API_BASE = "https://gamma-api.polymarket.com";
+    const url = new URL(`${GAMMA_API_BASE}/markets`);
+    if (filters) {
+      if (filters.active !== void 0) url.searchParams.append("active", String(filters.active));
+      if (filters.closed !== void 0) url.searchParams.append("closed", String(filters.closed));
+      if (filters.end_date_min) url.searchParams.append("end_date_min", filters.end_date_min);
+      if (filters.end_date_max) url.searchParams.append("end_date_max", filters.end_date_max);
+      if (filters.start_date_min) url.searchParams.append("start_date_min", filters.start_date_min);
+      if (filters.start_date_max) url.searchParams.append("start_date_max", filters.start_date_max);
+      if (filters.liquidity_num_min !== void 0) url.searchParams.append("liquidity_num_min", String(filters.liquidity_num_min));
+      if (filters.liquidity_num_max !== void 0) url.searchParams.append("liquidity_num_max", String(filters.liquidity_num_max));
+      if (filters.volume_num_min !== void 0) url.searchParams.append("volume_num_min", String(filters.volume_num_min));
+      if (filters.volume_num_max !== void 0) url.searchParams.append("volume_num_max", String(filters.volume_num_max));
+      if (filters.limit !== void 0) url.searchParams.append("limit", String(filters.limit));
+      if (filters.offset !== void 0) url.searchParams.append("offset", String(filters.offset));
+      if (filters.order) url.searchParams.append("order", filters.order);
+      if (filters.ascending !== void 0) url.searchParams.append("ascending", String(filters.ascending));
+    }
+    try {
+      const response = await fetch(url.toString());
+      if (!response.ok) {
+        throw new Error(`Gamma API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      this.logger.error("Error fetching markets from Gamma API", error);
+      throw error;
+    }
+  }
+  async getMarketTags(marketId) {
+    return this.gammaClient.getMarketTags(marketId);
+  }
+  async getEvent(idOrSlug) {
+    return this.gammaClient.getEvent(idOrSlug);
+  }
+  async getEvents(filters) {
+    return this.gammaClient.getEvents(filters);
+  }
+  async getEventTags(eventId) {
+    return this.gammaClient.getEventTags(eventId);
+  }
+  async getEventsPaginated(filters) {
+    return this.gammaClient.getEventsPaginated(filters);
+  }
+  async getTags(params) {
+    return this.gammaClient.getTags(params);
+  }
+  async getTag(idOrSlug) {
+    return this.gammaClient.getTag(idOrSlug);
+  }
+  async getRelatedTags(idOrSlug) {
+    return this.gammaClient.getRelatedTags(idOrSlug);
+  }
+  async getRelatedTagsTags(idOrSlug) {
+    return this.gammaClient.getRelatedTagsTags(idOrSlug);
+  }
+  async getTeams(params) {
+    return this.gammaClient.getTeams(params);
+  }
+  async getSports(params) {
+    return this.gammaClient.getSports(params);
+  }
+  async getSeries(params) {
+    return this.gammaClient.getSeries(params);
+  }
+  async getSeriesById(seriesId) {
+    return this.gammaClient.getSeriesById(seriesId);
+  }
+  async getComments(params) {
+    return this.gammaClient.getComments(params);
+  }
+  async getComment(commentId) {
+    return this.gammaClient.getComment(commentId);
+  }
+  async getCommentsByUser(userAddress, params) {
+    return this.gammaClient.getCommentsByUser(userAddress, params);
+  }
+  // ============================================
+  // Data/CLOB API Methods
+  // ============================================
+  DATA_API_BASE = "https://data-api.polymarket.com";
+  async fetchData(endpoint, params) {
+    const url = new URL(`${this.DATA_API_BASE}${endpoint}`);
+    if (params) {
+      Object.keys(params).forEach((key) => {
+        if (params[key] !== void 0) {
+          url.searchParams.append(key, String(params[key]));
+        }
+      });
+    }
+    try {
+      const response = await fetch(url.toString());
+      if (!response.ok) {
+        throw new Error(`Data API error: ${response.status} ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      this.logger.error(`Error fetching data from ${endpoint}`, error);
+      throw error;
+    }
+  }
+  async getPositions(user, params) {
+    return this.fetchData("/positions", { user, ...params });
+  }
+  async getTrades(user, params) {
+    return this.fetchData("/trades", { user, ...params });
+  }
+  async getActivity(user, params) {
+    return this.fetchData("/activity", { user, ...params });
+  }
+  async getTopHolders(marketId) {
+    try {
+      if (this.clobClient) {
+        try {
+          const market = await this.getMarket(marketId);
+          if (market && market.tokens) {
+            return market.tokens.map((token) => ({
+              tokenId: token.token_id,
+              outcome: token.outcome,
+              holders: token.holders || 0
+            }));
+          }
+        } catch (e) {
+        }
+      }
+      this.logger.debug("getTopHolders: No direct API available, returning market token info if available");
+      return [];
+    } catch (error) {
+      this.logger.error(`Error fetching top holders for ${marketId}`, error);
+      return [];
+    }
+  }
+  async getPortfolioValue(user) {
+    try {
+      const positions = await this.getPositions(user);
+      return positions.reduce((total, pos) => {
+        const value = pos.currentValue || pos.size * pos.price || 0;
+        return total + value;
+      }, 0);
+    } catch (error) {
+      this.logger.error("Error calculating portfolio value", error);
+      return 0;
+    }
+  }
+  async getClosedPositions(user, params) {
+    try {
+      const allPositions = await this.getPositions(user, params);
+      const closedPositions = allPositions.filter((pos) => {
+        const size = parseFloat(pos.size || pos.amount || "0");
+        const isClosed = size === 0 || pos.closed === true || pos.status === "closed";
+        return isClosed;
+      });
+      return closedPositions;
+    } catch (error) {
+      this.logger.error("Error fetching closed positions", error);
+      return [];
+    }
+  }
+  async getTradedMarketsCount(user) {
+    try {
+      const trades = await this.getTrades(user, { limit: 1e3 });
+      const marketIds = new Set(trades.map((t) => t.market));
+      return marketIds.size;
+    } catch (error) {
+      this.logger.error("Error counting traded markets", error);
+      return 0;
+    }
+  }
+  async getOpenInterest(marketId) {
+    try {
+      const market = await this.getMarket(marketId);
+      return market.open_interest ? parseFloat(market.open_interest) : 0;
+    } catch (error) {
+      this.logger.error(`Error fetching open interest for ${marketId}`, error);
+      return 0;
+    }
+  }
+  // Account methods
+  async getPosition(ticker) {
+    try {
+      if (!this.userAddress) {
+        this.logger.error("getPosition requires userAddress to be set");
+        return null;
+      }
+      const positions = await this.getPositions(this.userAddress);
+      const matchingPosition = positions.find((pos) => {
+        const marketMatch = pos.market === ticker || pos.slug === ticker || pos.condition_id === ticker || pos.asset_id === ticker || pos.token_id === ticker;
+        return marketMatch && parseFloat(pos.size || pos.amount || "0") > 0;
+      });
+      return matchingPosition || null;
+    } catch (error) {
+      this.logger.error(`Error fetching position for ${ticker}`, error);
+      return null;
+    }
+  }
+};
+var HyperliquidClient = class {
+  constructor(logger, userAddress) {
+    this.logger = logger;
+    this.userAddress = userAddress || null;
+    this.client = new Hyperliquid({
+      enableWs: false,
+      walletAddress: userAddress,
+      testnet: false,
+      disableAssetMapRefresh: true
+    });
+  }
+  client;
+  userAddress;
+  // Data methods
+  async getPrice(ticker) {
+    try {
+      const mids = await this.getAllMids();
+      const normalizedTicker = ticker.toUpperCase();
+      const price = mids[normalizedTicker];
+      if (price) {
+        return parseFloat(price);
+      }
+      this.logger.warning(`Price not found for ${ticker} on Hyperliquid`);
+      return 0;
+    } catch (error) {
+      this.logger.error(`Error fetching price for ${ticker}`, error);
+      return 0;
+    }
+  }
+  async getIndicator(ticker, indicator, params) {
+    this.logger.warning(`getIndicator not implemented for Hyperliquid`);
+    return 0;
+  }
+  // Spot Info
+  async getSpotMeta() {
+    return this.client.info.spot.getSpotMeta();
+  }
+  async getSpotClearinghouseState(user) {
+    return this.client.info.spot.getSpotClearinghouseState(user);
+  }
+  async getSpotMetaAndAssetCtxs() {
+    return this.client.info.spot.getSpotMetaAndAssetCtxs();
+  }
+  async getTokenDetails(tokenId) {
+    return this.client.info.spot.getTokenDetails(tokenId);
+  }
+  async getSpotDeployState(user) {
+    return this.client.info.spot.getSpotDeployState(user);
+  }
+  // Perpetuals Info
+  async getMeta() {
+    return this.client.info.perpetuals.getMeta();
+  }
+  async getMetaAndAssetCtxs() {
+    return this.client.info.perpetuals.getMetaAndAssetCtxs();
+  }
+  async getClearinghouseState(user) {
+    return this.client.info.perpetuals.getClearinghouseState(user);
+  }
+  async getUserFunding(user, startTime, endTime) {
+    return this.client.info.perpetuals.getUserFunding(user, startTime, endTime);
+  }
+  async getUserNonFundingLedgerUpdates(user, startTime, endTime) {
+    return this.client.info.perpetuals.getUserNonFundingLedgerUpdates(user, startTime, endTime);
+  }
+  async getFundingHistory(coin, startTime, endTime) {
+    return this.client.info.perpetuals.getFundingHistory(coin, startTime, endTime);
+  }
+  async getPredictedFundings() {
+    return this.client.info.perpetuals.getPredictedFundings();
+  }
+  async getPerpsAtOpenInterestCap() {
+    return this.client.info.perpetuals.getPerpsAtOpenInterestCap();
+  }
+  async getPerpDexLimits(dex) {
+    return this.client.info.perpetuals.getPerpDexLimits(dex);
+  }
+  // General Info
+  async getAssetIndex(assetName) {
+    return this.client.info.getAssetIndex(assetName);
+  }
+  async getInternalName(exchangeName) {
+    return this.client.info.getInternalName(exchangeName);
+  }
+  async getAllAssets() {
+    return this.client.info.getAllAssets();
+  }
+  async getAllMids() {
+    const mids = await this.client.info.getAllMids();
+    return Object.fromEntries(Object.entries(mids).map(([key, value]) => [key.replace("-PERP", "").replace("-SPOT", ""), value]));
+  }
+  async getUserOpenOrders(user) {
+    return this.client.info.getUserOpenOrders(user);
+  }
+  async getFrontendOpenOrders(user) {
+    return this.client.info.getFrontendOpenOrders(user);
+  }
+  async getUserFills(user) {
+    return this.client.info.getUserFills(user);
+  }
+  async getUserFillsByTime(user, startTime, endTime) {
+    return this.client.info.getUserFillsByTime(user, startTime, endTime);
+  }
+  async getUserRateLimit(user) {
+    return this.client.info.getUserRateLimit(user);
+  }
+  async getOrderStatus(user, oid) {
+    return this.client.info.getOrderStatus(user, oid);
+  }
+  async getL2Book(coin) {
+    return this.client.info.getL2Book(coin);
+  }
+  async getCandleSnapshot(coin, interval, startTime, endTime) {
+    return this.client.info.getCandleSnapshot(coin, interval, startTime, endTime);
+  }
+  async getMaxBuilderFee(user, builder) {
+    return this.client.info.getMaxBuilderFee(user, builder);
+  }
+  async getHistoricalOrders(user) {
+    return this.client.info.getHistoricalOrders(user);
+  }
+  async getUserTwapSliceFills(user) {
+    return this.client.info.getUserTwapSliceFills(user);
+  }
+  async getSubAccounts(user) {
+    return this.client.info.getSubAccounts(user);
+  }
+  async getVaultDetails(vaultAddress, user) {
+    return this.client.info.getVaultDetails(vaultAddress, user);
+  }
+  async getUserVaultEquities(user) {
+    return this.client.info.getUserVaultEquities(user);
+  }
+  async getUserRole(user) {
+    return this.client.info.getUserRole(user);
+  }
+  async getDelegations(user) {
+    return this.client.info.getDelegations(user);
+  }
+  async getDelegatorSummary(user) {
+    return this.client.info.getDelegatorSummary(user);
+  }
+  async getDelegatorHistory(user) {
+    return this.client.info.getDelegatorHistory(user);
+  }
+  async getDelegatorRewards(user) {
+    return this.client.info.getDelegatorRewards(user);
+  }
+  async validatorSummaries() {
+    return this.client.info.validatorSummaries();
+  }
+  async vaultSummaries() {
+    return this.client.info.vaultSummaries();
+  }
+  async userFees(user) {
+    return this.client.info.userFees(user);
+  }
+  async portfolio(user) {
+    return this.client.info.portfolio(user);
+  }
+  async preTransferCheck(user, source) {
+    return this.client.info.preTransferCheck(user, source);
+  }
+  async referral(user) {
+    return this.client.info.referral(user);
+  }
+  async extraAgents(user) {
+    return this.client.info.extraAgents(user);
+  }
+  async isVip(user) {
+    return this.client.info.isVip(user);
+  }
+  async legalCheck(user) {
+    return this.client.info.legalCheck(user);
+  }
+  async userTwapSliceFillsByTime(user, startTime, endTime) {
+    return this.client.info.userTwapSliceFillsByTime(user, startTime, endTime);
+  }
+  async twapHistory(user) {
+    return this.client.info.twapHistory(user);
+  }
+  async userToMultiSigSigners(user) {
+    return this.client.info.userToMultiSigSigners(user);
+  }
+  async getBuilderFeeApproval(user, builderAddress) {
+    return this.client.info.getBuilderFeeApproval(user, builderAddress);
+  }
+  async getUserOrderHistory(user, startTime, endTime) {
+    return this.client.info.getUserOrderHistory(user, startTime, endTime);
+  }
+  // Account methods
+  async getPosition(ticker) {
+    if (!this.userAddress) {
+      this.logger.warning(`Cannot get position: No user address provided`);
+      return null;
+    }
+    try {
+      const state = await this.client.info.perpetuals.getClearinghouseState(this.userAddress);
+      const positions = state.assetPositions;
+      const normalizedTicker = ticker.toUpperCase();
+      const position = positions.find((p) => p.position.coin === normalizedTicker);
+      return position || null;
+    } catch (error) {
+      this.logger.error(`Error fetching position for ${ticker}`, error);
+      return null;
+    }
+  }
+  async getPositions() {
+    if (!this.userAddress) {
+      this.logger.warning(`Cannot get positions: No user address provided`);
+      return [];
+    }
+    try {
+      const state = await this.client.info.perpetuals.getClearinghouseState(this.userAddress);
+      return state.assetPositions;
+    } catch (error) {
+      this.logger.error(`Error fetching positions`, error);
+      return [];
+    }
+  }
+};
+
+// src/state/memory-state.ts
+var MemoryStateManager = class {
+  storage = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.storage.get(key) ?? null;
+  }
+  async set(key, value) {
+    this.storage.set(key, value);
+  }
+  async delete(key) {
+    this.storage.delete(key);
+  }
+  async clear() {
+    this.storage.clear();
+  }
+  /**
+   * Get all keys (useful for debugging)
+   */
+  getAllKeys() {
+    return Array.from(this.storage.keys());
+  }
+};
+var RedisStateManager = class {
+  client;
+  strategyId;
+  logger;
+  constructor(redisUrl, strategyId, logger) {
+    this.strategyId = strategyId;
+    this.logger = logger;
+    this.client = createClient({ url: redisUrl });
+    this.client.on("error", (err) => {
+      this.logger.error("Redis client error", err);
+    });
+  }
+  async connect() {
+    await this.client.connect();
+    this.logger.info("Redis connected for state management");
+  }
+  async disconnect() {
+    await this.client.quit();
+  }
+  getKey(key) {
+    return `strategy:${this.strategyId}:state:${key}`;
+  }
+  async get(key) {
+    const redisKey = this.getKey(key);
+    const value = await this.client.get(redisKey);
+    if (value === null) {
+      return null;
+    }
+    try {
+      return superjson.parse(value);
+    } catch (error) {
+      this.logger.error(`Failed to parse Redis value for key ${redisKey}`, error);
+      return null;
+    }
+  }
+  async set(key, value) {
+    const redisKey = this.getKey(key);
+    const serialized = superjson.stringify(value);
+    await this.client.set(redisKey, serialized);
+  }
+  async delete(key) {
+    const redisKey = this.getKey(key);
+    await this.client.del(redisKey);
+  }
+  async clear() {
+    const pattern = `strategy:${this.strategyId}:state:*`;
+    const keys = await this.client.keys(pattern);
+    if (keys.length > 0) {
+      await this.client.del(keys);
+    }
+  }
+};
+
+// src/utils/logger.ts
+function createConsoleLogger() {
+  return {
+    info: (message, meta) => {
+      console.log(`[INFO] ${message}`, meta ? JSON.stringify(meta, null, 2) : "");
+    },
+    error: (message, error) => {
+      console.error(`[ERROR] ${message}`, error);
+    },
+    warning: (message, meta) => {
+      console.warn(`[WARN] ${message}`, meta ? JSON.stringify(meta, null, 2) : "");
+    },
+    debug: (message, meta) => {
+      console.debug(`[DEBUG] ${message}`, meta ? JSON.stringify(meta, null, 2) : "");
+    }
+  };
+}
+function createOsirisContext(config) {
+  const { strategyId, market, signer, polymarketOptions } = config;
+  const logger = createConsoleLogger();
+  const state = new MemoryStateManager();
+  const marketLower = market.toLowerCase();
+  const taService = new TechnicalAnalysisService({ logger });
+  const context = {
+    ta: createTAAPI(taService),
+    state,
+    log: createLogAPI(strategyId, logger),
+    signer
+  };
+  const userAddress = config.userAddress;
+  if (!userAddress) {
+    throw new Error("User address not found");
+  }
+  if (marketLower === "polymarket") {
+    context.polymarket = new PolymarketClient(logger, signer, userAddress, polymarketOptions);
+  } else if (marketLower === "hyperliquid") {
+    context.hyperliquid = new HyperliquidClient(logger, userAddress);
+  } else {
+    throw new Error(`Unsupported market: ${market}`);
+  }
+  return context;
+}
+function createTAAPI(taService) {
+  return {
+    calculate: (indicator, data, params) => {
+      return taService.calculate(indicator, data, params || {});
+    }
+  };
+}
+function createLogAPI(strategyId, logger) {
+  return (message, meta) => {
+    logger.info(`[Strategy ${strategyId}] ${message}`, meta);
+  };
+}
+
+// src/engine/strategy-runner.ts
+async function runStrategy(strategy, config, context) {
+  if (typeof strategy.shouldTrigger !== "function" || typeof strategy.onTrigger !== "function") {
+    throw new Error("runStrategy requires a tick-based strategy with shouldTrigger and onTrigger methods");
+  }
+  try {
+    const shouldTrigger = await strategy.shouldTrigger(context);
+    if (shouldTrigger) {
+      await strategy.onTrigger(context);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    config.logger.error(`Error executing strategy: ${error.message}`, error);
+    throw error;
+  }
+}
+function createStrategyEngine(strategy, config, context) {
+  return new StrategyEngine(strategy, config, context);
+}
+var StrategyEngine = class {
+  constructor(strategy, config, context) {
+    this.strategy = strategy;
+    this.config = config;
+    this.context = context;
+  }
+  intervalId = null;
+  isRunning = false;
+  /**
+   * Start the engine with the configured tick interval
+   */
+  start() {
+    if (this.isRunning) {
+      this.config.logger.warning("Strategy engine is already running");
+      return;
+    }
+    const tickIntervalMs = this.config.tickIntervalMs || 6e4;
+    this.isRunning = true;
+    this.config.logger.info(`Starting strategy engine with ${tickIntervalMs}ms tick interval`);
+    this.tick();
+    this.intervalId = setInterval(() => {
+      this.tick();
+    }, tickIntervalMs);
+  }
+  /**
+   * Stop the engine
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.config.logger.info("Strategy engine stopped");
+  }
+  /**
+   * Check if the engine is currently running
+   */
+  isActive() {
+    return this.isRunning;
+  }
+  async tick() {
+    const tickStart = Date.now();
+    this.config.logger.debug(`Tick start: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    try {
+      await runStrategy(this.strategy, this.config, this.context);
+    } catch (error) {
+      this.config.logger.error(`Error in strategy tick: ${error.message}`, error);
+    }
+    const tickDuration = Date.now() - tickStart;
+    this.config.logger.debug(`Tick completed in ${tickDuration}ms`);
+  }
+};
+function isEventBasedStrategy(strategy) {
+  return Array.isArray(strategy.subscriptions) && strategy.subscriptions.length > 0 && typeof strategy.onEvent === "function";
+}
+function isTickBasedStrategy(strategy) {
+  return typeof strategy.shouldTrigger === "function" && typeof strategy.onTrigger === "function";
+}
+function validateStrategy(strategy) {
+  const isEvent = isEventBasedStrategy(strategy);
+  const isTick = isTickBasedStrategy(strategy);
+  if (!isEvent && !isTick) {
+    throw new Error(
+      "Invalid strategy: must implement either tick-based methods (shouldTrigger + onTrigger) or event-based methods (subscriptions + onEvent)"
+    );
+  }
+  if (isEvent && isTick) {
+    throw new Error(
+      "Invalid strategy: strategies should not implement both tick-based and event-based methods. Choose one execution mode."
+    );
+  }
+}
+var EventRunner = class {
+  constructor(strategy, config, context) {
+    this.strategy = strategy;
+    this.config = config;
+    this.context = context;
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      throw new Error("Strategy must have subscriptions defined for event-based execution");
+    }
+    if (typeof this.strategy.onEvent !== "function") {
+      throw new Error("Strategy must implement onEvent method for event-based execution");
+    }
+    this.maxReconnectAttempts = config.reconnect?.maxAttempts ?? 10;
+    this.baseReconnectDelay = config.reconnect?.delayMs ?? 1e3;
+    this.maxReconnectDelay = config.reconnect?.maxDelayMs ?? 3e4;
+  }
+  ws = null;
+  isRunning = false;
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  isIntentionallyClosed = false;
+  // Default reconnection settings
+  maxReconnectAttempts;
+  baseReconnectDelay;
+  maxReconnectDelay;
+  /**
+   * Start listening to events
+   * Connects to the WebSocket and subscribes to events
+   */
+  start() {
+    if (this.isRunning) {
+      this.config.logger.warning("Event runner is already running");
+      return;
+    }
+    this.isRunning = true;
+    this.isIntentionallyClosed = false;
+    this.reconnectAttempts = 0;
+    const strategyName = this.config.strategyId || "unnamed-strategy";
+    this.config.logger.info(`Starting event runner for strategy ${strategyName}`);
+    this.config.logger.info(`Connecting to event source: ${this.config.eventSourceUrl}`);
+    this.connect();
+  }
+  /**
+   * Stop listening and disconnect from WebSocket
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this.isIntentionallyClosed = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws) {
+      try {
+        this.unsubscribeFromEvents();
+        this.ws.close(1e3, "Intentional close");
+      } catch (error) {
+      }
+      this.ws = null;
+    }
+    this.config.logger.info("Event runner stopped");
+  }
+  /**
+   * Check if the runner is currently active
+   */
+  isActive() {
+    return this.isRunning;
+  }
+  /**
+   * Get current connection status
+   */
+  getStatus() {
+    return {
+      running: this.isRunning,
+      connected: this.ws?.readyState === WebSocket.OPEN,
+      reconnectAttempts: this.reconnectAttempts,
+      subscriptionCount: this.strategy.subscriptions?.length ?? 0
+    };
+  }
+  /**
+   * Connect to the WebSocket event source
+   */
+  connect() {
+    if (this.isIntentionallyClosed) {
+      return;
+    }
+    try {
+      this.ws = new WebSocket(this.config.eventSourceUrl);
+      this.ws.on("open", () => {
+        this.config.logger.info("Connected to event source");
+        this.reconnectAttempts = 0;
+        this.subscribeToEvents();
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data);
+      });
+      this.ws.on("error", (error) => {
+        this.config.logger.error(`WebSocket error: ${error.message}`, error);
+      });
+      this.ws.on("close", (code, reason) => {
+        const reasonStr = reason.toString() || "none";
+        this.config.logger.info(`WebSocket closed (code: ${code}, reason: ${reasonStr})`);
+        if (!this.isIntentionallyClosed && this.isRunning) {
+          this.attemptReconnect();
+        }
+      });
+    } catch (error) {
+      this.config.logger.error(`Failed to connect to WebSocket: ${error.message}`, error);
+      if (this.isRunning && !this.isIntentionallyClosed) {
+        this.attemptReconnect();
+      }
+    }
+  }
+  /**
+   * Attempt to reconnect with exponential backoff
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.config.logger.error(`Max reconnection attempts (${this.maxReconnectAttempts}) reached`);
+      this.isRunning = false;
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1) + Math.random() * 1e3,
+      this.maxReconnectDelay
+    );
+    this.config.logger.info(
+      `Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+    );
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Subscribe to events based on strategy's subscriptions
+   */
+  subscribeToEvents() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.config.logger.warning("Cannot subscribe - WebSocket not connected");
+      return;
+    }
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      this.config.logger.warning("No subscriptions defined for strategy");
+      return;
+    }
+    const subscribeMessage = {
+      action: "subscribe",
+      subscriptions: this.strategy.subscriptions
+    };
+    try {
+      this.ws.send(JSON.stringify(subscribeMessage));
+      this.config.logger.info(
+        `Subscribed to ${this.strategy.subscriptions.length} event(s): ` + this.strategy.subscriptions.map((s) => `${s.type}${s.market ? `@${s.market}` : ""}`).join(", ")
+      );
+    } catch (error) {
+      this.config.logger.error(`Failed to send subscription: ${error.message}`, error);
+    }
+  }
+  /**
+   * Unsubscribe from events before disconnecting
+   */
+  unsubscribeFromEvents() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      return;
+    }
+    const unsubscribeMessage = {
+      action: "unsubscribe",
+      subscriptions: this.strategy.subscriptions
+    };
+    try {
+      this.ws.send(JSON.stringify(unsubscribeMessage));
+    } catch (error) {
+    }
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleMessage(data) {
+    try {
+      const rawData = typeof data === "string" ? data : data.toString();
+      if (rawData === "PING" || rawData === "PONG" || rawData.trim() === "") {
+        return;
+      }
+      let message;
+      try {
+        message = JSON.parse(rawData);
+      } catch (parseError) {
+        this.config.logger.warning(`Received non-JSON message: ${rawData.slice(0, 100)}`);
+        return;
+      }
+      if (!this.isValidEvent(message)) {
+        this.config.logger.debug(`Received non-event message: ${JSON.stringify(message).slice(0, 200)}`);
+        return;
+      }
+      this.dispatchEvent(message);
+    } catch (error) {
+      this.config.logger.error(`Error handling message: ${error.message}`, error);
+    }
+  }
+  /**
+   * Validate that a message is a valid StrategyEvent
+   */
+  isValidEvent(message) {
+    return message && typeof message === "object" && typeof message.type === "string" && typeof message.timestamp === "number" && typeof message.data === "object";
+  }
+  /**
+   * Dispatch an event to the strategy's onEvent handler
+   */
+  async dispatchEvent(event) {
+    const eventStart = Date.now();
+    this.config.logger.debug(
+      `Dispatching ${event.type} event${event.market ? ` for ${event.market}` : ""}`
+    );
+    try {
+      if (this.strategy.onEvent) {
+        await this.strategy.onEvent(event, this.context);
+      }
+    } catch (error) {
+      this.config.logger.error(
+        `Error in strategy onEvent handler: ${error.message}`,
+        error
+      );
+    }
+    const eventDuration = Date.now() - eventStart;
+    this.config.logger.debug(`Event handling completed in ${eventDuration}ms`);
+  }
+};
+function createEventRunner(strategy, config, context) {
+  return new EventRunner(strategy, config, context);
+}
+var CHAIN_MAP = {
+  "evm:eip155:1": mainnet,
+  "evm:eip155:137": polygon,
+  "evm:eip155:42161": arbitrum,
+  "evm:eip155:10": optimism,
+  "evm:eip155:8453": base,
+  "evm:eip155:11155111": sepolia
+};
+var PrivateKeySigner = class {
+  account;
+  defaultChain;
+  clientCache = /* @__PURE__ */ new Map();
+  privateKey;
+  constructor(config) {
+    this.privateKey = config.privateKey.startsWith("0x") ? config.privateKey : `0x${config.privateKey}`;
+    this.account = privateKeyToAccount(this.privateKey);
+    this.defaultChain = config.chain || "evm:eip155:1";
+  }
+  /**
+   * Get the wallet address derived from the private key
+   */
+  getAddress() {
+    return this.account.address;
+  }
+  /**
+   * Get the private key (needed for CLOB client initialization)
+   * @returns The private key with 0x prefix
+   */
+  getPrivateKey() {
+    return this.privateKey;
+  }
+  /**
+   * Get or create a wallet client for the specified chain
+   */
+  getClient(chain) {
+    const chainId = chain || this.defaultChain;
+    if (this.clientCache.has(chainId)) {
+      return this.clientCache.get(chainId);
+    }
+    const viemChain = CHAIN_MAP[chainId];
+    if (!viemChain) {
+      throw new Error(`Unsupported chain: ${chainId}. Supported chains: ${Object.keys(CHAIN_MAP).join(", ")}`);
+    }
+    const client = createWalletClient({
+      account: this.account,
+      chain: viemChain,
+      transport: http()
+    });
+    this.clientCache.set(chainId, client);
+    return client;
+  }
+  /**
+   * Sign a transaction with the private key
+   * @param walletAddress - Ignored for private key signer (uses derived address)
+   */
+  async signTransaction(transaction, chain, _walletAddress) {
+    try {
+      const client = this.getClient(chain);
+      const txData = typeof transaction === "string" ? JSON.parse(transaction) : transaction;
+      const signature = await client.signTransaction({
+        account: this.account,
+        ...txData
+      });
+      return signature;
+    } catch (error) {
+      throw new Error(`PrivateKey signTransaction failed: ${error.message || error}`);
+    }
+  }
+  /**
+   * Sign typed data (EIP-712) with the private key
+   * @param walletAddress - Ignored for private key signer (uses derived address)
+   */
+  async signTypedData(typedData, chain, _walletAddress) {
+    try {
+      const client = this.getClient(chain);
+      const signature = await client.signTypedData({
+        account: this.account,
+        domain: typedData.domain,
+        types: typedData.types,
+        primaryType: typedData.primaryType,
+        message: typedData.message
+      });
+      return signature;
+    } catch (error) {
+      throw new Error(`PrivateKey signTypedData failed: ${error.message || error}`);
+    }
+  }
+  /**
+   * Sign a message with the private key
+   * @param walletAddress - Ignored for private key signer (uses derived address)
+   */
+  async signMessage(message, chain, _walletAddress) {
+    try {
+      const client = this.getClient(chain);
+      const messageToSign = message instanceof Uint8Array ? { raw: message } : message;
+      const signature = await client.signMessage({
+        account: this.account,
+        message: messageToSign
+      });
+      return signature;
+    } catch (error) {
+      throw new Error(`PrivateKey signMessage failed: ${error.message || error}`);
+    }
+  }
+};
+
+// src/signer/index.ts
+var Signer = class {
+  impl;
+  constructor(config) {
+    if (config.mode === "osiris") {
+      this.impl = new OsirisSigner(config.config);
+    } else if (config.mode === "privateKey") {
+      this.impl = new PrivateKeySigner(config.config);
+    } else {
+      throw new Error(`Unsupported signer mode: ${config.mode}`);
+    }
+  }
+  /**
+   * Get the wallet address (only available for privateKey mode)
+   */
+  getAddress() {
+    if ("getAddress" in this.impl) {
+      return this.impl.getAddress();
+    }
+    return void 0;
+  }
+  /**
+   * Sign a transaction via Osiris Hub
+   */
+  async signTransaction(transaction, chain, walletAddress) {
+    return this.impl.signTransaction(transaction, chain, walletAddress);
+  }
+  /**
+   * Sign typed data (EIP-712 for EVM) via Osiris Hub
+   */
+  async signTypedData(typedData, chain, walletAddress) {
+    return this.impl.signTypedData(typedData, chain, walletAddress);
+  }
+  /**
+   * Sign a message via Osiris Hub
+   */
+  async signMessage(message, chain, walletAddress) {
+    return this.impl.signMessage(message, chain, walletAddress);
+  }
+  getPrivateKey() {
+    return this.impl.getPrivateKey();
+  }
+};
+
+export { EventRunner, HyperliquidClient, MemoryStateManager, OsirisSigner, PolymarketClient, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, createConsoleLogger, createEventRunner, createOsirisContext, createStrategyEngine, isEventBasedStrategy, isTickBasedStrategy, runStrategy, validateStrategy };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map