feat(automation): connect live oracle prices to automation price triggers

packages/core/automation/README.md

@@ -0,0 +1,41 @@
+# @galaxy-kj/core-automation
+
+Automation engine for scheduling and executing Stellar and DeFi workflows.
+
+## Price-triggered automations
+
+`AutomationService` now supports live oracle-backed price evaluation for
+automations that use `type: 'price'` conditions.
+
+### Configure the service
+
+```ts
+import { AutomationService, TriggerType } from '@galaxy-kj/core-automation';
+import { OracleAggregator } from '@galaxy-kj/core-oracles';
+
+const oracle = new OracleAggregator();
+const automationService = new AutomationService({
+  oracle,
+});
+```
+
+### Start polling for price rules
+
+```ts
+await automationService.startPriceMonitoring(30_000);
+```
+
+This polling loop:
+
+- fetches live prices for the assets referenced by active `TriggerType.PRICE`
+  rules
+- populates `ExecutionContext.priceContext`
+- evaluates `PRICE_ABOVE` / `PRICE_BELOW` style conditions against the live
+  price map
+- executes matching rules through the normal automation pipeline
+
+### Fallback behavior
+
+If no oracle is configured, non-price automations continue to work normally.
+Price conditions simply evaluate to `false` unless a caller provides
+`ExecutionContext.priceContext` explicitly.

packages/core/automation/jest.config.cjs

@@ -0,0 +1,40 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src/test'],
+  testMatch: ['**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/test/**',
+    '!src/utils/cron-manager.ts',
+    '!src/utils/execution-engine.ts',
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 85,
+      functions: 90,
+      lines: 90,
+      statements: 90,
+    },
+  },
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'json', 'json-summary'],
+  transform: {
+    '^.+\\.ts$': [
+      'ts-jest',
+      {
+        useESM: false,
+        tsconfig: {
+          module: 'commonjs',
+          moduleResolution: 'node',
+        },
+      },
+    ],
+  },
+  moduleNameMapper: {
+    '^@galaxy-kj/core-oracles$': '<rootDir>/../oracles/src/index.ts',
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  moduleFileExtensions: ['ts', 'js', 'json'],
+};

packages/core/automation/package.json

@@ -9,6 +9,7 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "test": "jest",
+    "test:coverage": "jest --coverage",
     "lint": "eslint src/**/*.ts",
     "lint:fix": "eslint src/**/*.ts --fix",
     "type-check": "tsc --noEmit",

packages/core/automation/src/services/automation.service.ts

@@ -9,14 +9,16 @@ import {
   ExecutionContext,
   ExecutionResult,
   AutomationMetrics,
+  PriceConditionContext,
+  PriceTriggerCondition,
   TriggerType,
   StellarNetwork,
 } from '../types/automation-types.js';
 import { CronManager } from '../utils/cron-manager.js';
 import { ConditionEvaluator } from '../utils/condition-evaluator.js';
 import { ExecutionEngine } from '../utils/execution-engine.js';
 import { OracleAggregator } from '@galaxy-kj/core-oracles';
-import { supabaseClient } from '../../stellar-sdk/src/utils/supabase-client.js';
+import { supabaseClient } from '../../../stellar-sdk/src/utils/supabase-client.js';
 
 export interface AutomationServiceConfig {
   network?: StellarNetwork;
@@ -31,12 +33,20 @@ export class AutomationService extends EventEmitter {
   private cronManager: CronManager;
   private conditionEvaluator: ConditionEvaluator;
   private executionEngine: ExecutionEngine;
+  private oracle?: OracleAggregator;
   private rules: Map<string, AutomationRule> = new Map();
   private metrics: Map<string, AutomationMetrics> = new Map();
   private activeExecutions: Set<string> = new Set();
-  private config: Required<AutomationServiceConfig>;
+  private config: {
+    network: StellarNetwork;
+    sourceSecret: string;
+    maxConcurrentExecutions: number;
+    executionTimeout: number;
+    enableMetrics: boolean;
+  };
   private network: StellarNetwork;
   private activeTimeouts: Map<string, NodeJS.Timeout> = new Map();
+  private priceMonitorInterval?: NodeJS.Timeout;
   private supabase = supabaseClient;
 
   constructor(config: AutomationServiceConfig = {}) {
@@ -56,8 +66,9 @@ export class AutomationService extends EventEmitter {
       enableMetrics: config.enableMetrics !== false,
     };
 
+    this.oracle = config.oracle;
     this.cronManager = new CronManager();
-    this.conditionEvaluator = new ConditionEvaluator(config.oracle);
+    this.conditionEvaluator = new ConditionEvaluator();
     this.executionEngine = new ExecutionEngine(
       this.network,
       this.config.sourceSecret
@@ -171,7 +182,7 @@ export class AutomationService extends EventEmitter {
 
     try {
       // Build execution context
-      const context: ExecutionContext = {
+      const baseContext: ExecutionContext = {
         ruleId,
         userId: rule.userId,
         timestamp: new Date(),
@@ -180,6 +191,7 @@ export class AutomationService extends EventEmitter {
         },
         ...contextData,
       };
+      const context = await this.attachLivePrices(rule, baseContext);
 
       // Evaluate conditions
       const conditionsMet = await this.conditionEvaluator.evaluateConditionGroup(
@@ -296,6 +308,68 @@ export class AutomationService extends EventEmitter {
     }
   }
 
+  async startPriceMonitoring(intervalMs: number = 30_000): Promise<void> {
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+      throw new Error('Price monitoring interval must be greater than 0');
+    }
+
+    if (!this.oracle) {
+      throw new Error('Oracle not configured for price monitoring');
+    }
+
+    this.stopPriceMonitoring();
+    await this.runPriceMonitoringCycle();
+
+    this.priceMonitorInterval = setInterval(() => {
+      void this.runPriceMonitoringCycle();
+    }, intervalMs);
+  }
+
+  stopPriceMonitoring(): void {
+    if (!this.priceMonitorInterval) {
+      return;
+    }
+
+    clearInterval(this.priceMonitorInterval);
+    this.priceMonitorInterval = undefined;
+  }
+
+  async checkAndExecute(
+    contextData?: Partial<ExecutionContext>
+  ): Promise<ExecutionResult[]> {
+    const activePriceRules = this.getAllRules().filter(
+      rule =>
+        rule.status === AutomationStatus.ACTIVE &&
+        rule.triggerType === TriggerType.PRICE
+    );
+
+    if (activePriceRules.length === 0) {
+      return [];
+    }
+
+    const priceContext = await this.buildPriceContext(
+      activePriceRules,
+      contextData?.priceContext
+    );
+
+    return Promise.all(
+      activePriceRules.map(rule =>
+        this.executeRule(rule.id, {
+          ...contextData,
+          priceContext,
+        })
+      )
+    );
+  }
+
+  private async runPriceMonitoringCycle(): Promise<void> {
+    try {
+      await this.checkAndExecute();
+    } catch (error) {
+      this.emit('rule:error', { ruleId: 'price-monitor', error });
+    }
+  }
+
   /**
    * Update rule status
    */
@@ -513,6 +587,71 @@ export class AutomationService extends EventEmitter {
     this.metrics.set(ruleId, metrics);
   }
 
+  private async attachLivePrices(
+    rule: AutomationRule,
+    context: ExecutionContext
+  ): Promise<ExecutionContext> {
+    const priceContext = await this.buildPriceContext([rule], context.priceContext);
+    if (!priceContext) {
+      return context;
+    }
+
+    return {
+      ...context,
+      priceContext,
+    };
+  }
+
+  private async buildPriceContext(
+    rules: AutomationRule[],
+    existingPriceContext?: PriceConditionContext
+  ): Promise<PriceConditionContext | undefined> {
+    if (existingPriceContext) {
+      return existingPriceContext;
+    }
+
+    if (!this.oracle) {
+      return undefined;
+    }
+
+    const assets = Array.from(
+      new Set(rules.flatMap(rule => this.collectPriceAssets(rule.conditionGroup)))
+    );
+
+    if (assets.length === 0) {
+      return undefined;
+    }
+
+    const aggregatedPrices = await this.oracle.getAggregatedPrices(assets);
+
+    return {
+      prices: Object.fromEntries(
+        aggregatedPrices.map((price: { symbol: string; price: number }) => [
+          price.symbol,
+          price.price,
+        ])
+      ),
+      timestamp: Date.now(),
+    };
+  }
+
+  private collectPriceAssets(
+    group: AutomationRule['conditionGroup']
+  ): string[] {
+    const directAssets = group.conditions
+      .filter(
+        (condition): condition is PriceTriggerCondition =>
+          'type' in condition && condition.type === 'price'
+      )
+      .map(condition => condition.asset);
+
+    const nestedAssets = (group.groups || []).flatMap(nestedGroup =>
+      this.collectPriceAssets(nestedGroup)
+    );
+
+    return [...directAssets, ...nestedAssets];
+  }
+
   private sanitizeAuditMetadata(
     metadata?: Record<string, unknown>
   ): Record<string, unknown> | undefined {
@@ -601,6 +740,7 @@ export class AutomationService extends EventEmitter {
    * Shutdown service
    */
   async shutdown(): Promise<void> {
+    this.stopPriceMonitoring();
     this.cronManager.destroy();
     this.removeAllListeners();
   }