Initial commit: add .gitignore and README

tests/integration/full-execution.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect } from "vitest";
+import { StrategyCompiler } from "../../src/planner/compiler.js";
+import { executeStrategy } from "../../src/engine.js";
+import { loadStrategy, substituteBlinds } from "../../src/strategy.js";
+import { readFileSync } from "fs";
+import { join } from "path";
+
+describe("Full Strategy Execution", () => {
+  it("should compile and execute recursive leverage strategy", async () => {
+    const strategyPath = join(
+      process.cwd(),
+      "strategies",
+      "sample.recursive.json"
+    );
+    
+    if (!require("fs").existsSync(strategyPath)) {
+      // Skip if strategy file doesn't exist
+      return;
+    }
+
+    const strategy = loadStrategy(strategyPath);
+    
+    // Substitute blind values for testing
+    const blindValues = {
+      collateralAmount: "1000000", // 1 USDC (6 decimals)
+      leverageFactor: "500000", // 0.5 USDC
+    };
+    const resolvedStrategy = substituteBlinds(strategy, blindValues);
+    
+    const compiler = new StrategyCompiler(resolvedStrategy.chain);
+    
+    const plan = await compiler.compile(resolvedStrategy);
+    expect(plan.calls.length).toBeGreaterThan(0);
+  });
+
+  it("should compile liquidation helper strategy", async () => {
+    const strategyPath = join(
+      process.cwd(),
+      "strategies",
+      "sample.liquidation.json"
+    );
+    
+    if (!require("fs").existsSync(strategyPath)) {
+      return;
+    }
+
+    const strategy = loadStrategy(strategyPath);
+    const compiler = new StrategyCompiler(strategy.chain);
+    
+    const plan = await compiler.compile(strategy);
+    expect(plan.requiresFlashLoan).toBe(true);
+  });
+
+  it("should compile stablecoin hedge strategy", async () => {
+    const strategyPath = join(
+      process.cwd(),
+      "strategies",
+      "sample.stablecoin-hedge.json"
+    );
+    
+    if (!require("fs").existsSync(strategyPath)) {
+      return;
+    }
+
+    const strategy = loadStrategy(strategyPath);
+    const compiler = new StrategyCompiler(strategy.chain);
+    
+    const plan = await compiler.compile(strategy);
+    expect(plan.calls.length).toBeGreaterThan(0);
+  });
+
+  it("should compile multi-protocol strategy", async () => {
+    const strategy = {
+      name: "Multi-Protocol",
+      chain: "mainnet",
+      steps: [
+        {
+          id: "supply",
+          action: {
+            type: "aaveV3.supply",
+            asset: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+            amount: "1000000",
+          },
+        },
+        {
+          id: "swap",
+          action: {
+            type: "uniswapV3.swap",
+            tokenIn: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+            tokenOut: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+            fee: 3000,
+            amountIn: "500000",
+            exactInput: true,
+          },
+        },
+      ],
+    };
+
+    const compiler = new StrategyCompiler("mainnet");
+    const plan = await compiler.compile(strategy as any);
+    expect(plan.calls.length).toBe(2);
+  });
+
+  it("should compile strategy with all guard types", async () => {
+    const strategy = {
+      name: "All Guards",
+      chain: "mainnet",
+      guards: [
+        {
+          type: "maxGas",
+          params: { maxGasLimit: "5000000" },
+        },
+        {
+          type: "slippage",
+          params: { maxBps: 50 },
+        },
+      ],
+      steps: [
+        {
+          id: "step1",
+          guards: [
+            {
+              type: "oracleSanity",
+              params: {
+                token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+                maxDeviationBps: 500,
+              },
+            },
+          ],
+          action: {
+            type: "aaveV3.supply",
+            asset: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+            amount: "1000000",
+          },
+        },
+      ],
+    };
+
+    const compiler = new StrategyCompiler("mainnet");
+    const plan = await compiler.compile(strategy as any);
+    expect(plan.calls.length).toBeGreaterThan(0);
+  });
+});
+