amped-defi 1.0.0

package/src/__tests__/policyEngine.test.ts

@@ -0,0 +1,354 @@
+/**
+ * Policy Engine Tests
+ */
+
+import { PolicyEngine, PolicyCheckResult } from '../policy/policyEngine';
+
+// Mock environment variables
+const originalEnv = process.env;
+
+describe('PolicyEngine', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...originalEnv };
+    delete process.env.AMPED_OC_LIMITS_JSON;
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  describe('Configuration Loading', () => {
+    it('should load empty config when env not set', () => {
+      const engine = new PolicyEngine();
+      const config = engine.getConfig();
+      expect(config).toEqual({});
+    });
+
+    it('should load default policy config', () => {
+      process.env.AMPED_OC_LIMITS_JSON = JSON.stringify({
+        default: {
+          maxSlippageBps: 100,
+          allowedChains: ['ethereum', 'arbitrum'],
+        },
+      });
+
+      const engine = new PolicyEngine();
+      const config = engine.getConfig();
+      expect(config.maxSlippageBps).toBe(100);
+      expect(config.allowedChains).toEqual(['ethereum', 'arbitrum']);
+    });
+
+    it('should load specific policy by ID', () => {
+      process.env.AMPED_OC_LIMITS_JSON = JSON.stringify({
+        default: { maxSlippageBps: 100 },
+        aggressive: { maxSlippageBps: 300 },
+        conservative: { maxSlippageBps: 50 },
+      });
+
+      const engine = new PolicyEngine('aggressive');
+      const config = engine.getConfig();
+      expect(config.maxSlippageBps).toBe(300);
+    });
+
+    it('should fallback to default when policy ID not found', () => {
+      process.env.AMPED_OC_LIMITS_JSON = JSON.stringify({
+        default: { maxSlippageBps: 100 },
+      });
+
+      const engine = new PolicyEngine('nonexistent');
+      const config = engine.getConfig();
+      expect(config.maxSlippageBps).toBe(100);
+    });
+
+    it('should handle invalid JSON gracefully', () => {
+      process.env.AMPED_OC_LIMITS_JSON = 'invalid json';
+
+      const engine = new PolicyEngine();
+      const config = engine.getConfig();
+      expect(config).toEqual({});
+    });
+  });
+
+  describe('Bridge Policy Checks', () => {
+    beforeEach(() => {
+      process.env.AMPED_OC_LIMITS_JSON = JSON.stringify({
+        default: {
+          allowedChains: ['ethereum', 'arbitrum', 'sonic'],
+          allowedTokensByChain: {
+            ethereum: ['0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'],
+          },
+          maxBridgeAmountToken: {
+            '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': 10000,
+          },
+          blockedRecipients: ['0x0000000000000000000000000000000000000000'],
+        },
+      });
+    });
+
+    it('should allow valid bridge operation', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkBridge({
+        walletId: 'test',
+        srcChainId: 'ethereum',
+        dstChainId: 'arbitrum',
+        srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        dstToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        amount: '1000',
+      });
+
+      expect(result.allowed).toBe(true);
+    });
+
+    it('should reject disallowed source chain', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkBridge({
+        walletId: 'test',
+        srcChainId: 'polygon',
+        dstChainId: 'arbitrum',
+        srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        dstToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        amount: '1000',
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Chain not allowed');
+    });
+
+    it('should reject disallowed destination chain', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkBridge({
+        walletId: 'test',
+        srcChainId: 'ethereum',
+        dstChainId: 'polygon',
+        srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        dstToken: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+        amount: '1000',
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Chain not allowed');
+    });
+
+    it('should reject disallowed token', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkBridge({
+        walletId: 'test',
+        srcChainId: 'ethereum',
+        dstChainId: 'arbitrum',
+        srcToken: '0xInvalidToken',
+        dstToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        amount: '1000',
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Token not allowed');
+    });
+
+    it('should reject amount exceeding limit', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkBridge({
+        walletId: 'test',
+        srcChainId: 'ethereum',
+        dstChainId: 'arbitrum',
+        srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        dstToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        amount: '15000',
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('exceeds maximum');
+      expect(result.details).toEqual({ maxAllowed: 10000, requested: 15000 });
+    });
+
+    it('should reject blocked recipient', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkBridge({
+        walletId: 'test',
+        srcChainId: 'ethereum',
+        dstChainId: 'arbitrum',
+        srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        dstToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        amount: '1000',
+        recipient: '0x0000000000000000000000000000000000000000',
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Recipient is blocked');
+    });
+  });
+
+  describe('Swap Policy Checks', () => {
+    beforeEach(() => {
+      process.env.AMPED_OC_LIMITS_JSON = JSON.stringify({
+        default: {
+          allowedChains: ['ethereum', 'arbitrum'],
+          maxSlippageBps: 100,
+          maxSwapInputToken: {
+            '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': 50000,
+          },
+        },
+      });
+    });
+
+    it('should allow valid swap', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkSwap({
+        walletId: 'test',
+        srcChainId: 'ethereum',
+        dstChainId: 'arbitrum',
+        srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        dstToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        inputAmount: '1000',
+        slippageBps: 50,
+      });
+
+      expect(result.allowed).toBe(true);
+    });
+
+    it('should reject excessive slippage', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkSwap({
+        walletId: 'test',
+        srcChainId: 'ethereum',
+        dstChainId: 'arbitrum',
+        srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        dstToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        inputAmount: '1000',
+        slippageBps: 150,
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Slippage');
+      expect(result.details).toEqual({ maxAllowed: 100, requested: 150 });
+    });
+
+    it('should reject swap exceeding token limit', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkSwap({
+        walletId: 'test',
+        srcChainId: 'ethereum',
+        dstChainId: 'arbitrum',
+        srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        dstToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        inputAmount: '60000',
+        slippageBps: 50,
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('exceeds maximum');
+    });
+  });
+
+  describe('Money Market Policy Checks', () => {
+    beforeEach(() => {
+      process.env.AMPED_OC_LIMITS_JSON = JSON.stringify({
+        default: {
+          allowedChains: ['ethereum', 'sonic'],
+          allowedTokensByChain: {
+            ethereum: ['0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'],
+            sonic: ['0x29219dd400f2bf60e5a23d13be72b486d4038894'],
+          },
+          maxBorrowUsd: 50000,
+          maxBorrowToken: {
+            '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': 30000,
+          },
+        },
+      });
+    });
+
+    it('should allow valid supply', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkMoneyMarket({
+        walletId: 'test',
+        chainId: 'ethereum',
+        token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        amount: '10000',
+        operation: 'supply',
+      });
+
+      expect(result.allowed).toBe(true);
+    });
+
+    it('should allow valid borrow within limits', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkMoneyMarket({
+        walletId: 'test',
+        chainId: 'ethereum',
+        token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        amount: '20000',
+        amountUsd: 20000,
+        operation: 'borrow',
+      });
+
+      expect(result.allowed).toBe(true);
+    });
+
+    it('should reject borrow exceeding USD limit', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkMoneyMarket({
+        walletId: 'test',
+        chainId: 'ethereum',
+        token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // Use allowed token
+        amount: '60000',
+        amountUsd: 60000,
+        operation: 'borrow',
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('exceeds maximum');
+    });
+
+    it('should reject borrow exceeding token limit', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkMoneyMarket({
+        walletId: 'test',
+        chainId: 'ethereum',
+        token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        amount: '35000',
+        amountUsd: 35000,
+        operation: 'borrow',
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('exceeds maximum');
+    });
+
+    it('should check cross-chain destination', async () => {
+      const engine = new PolicyEngine();
+      const result = await engine.checkMoneyMarket({
+        walletId: 'test',
+        chainId: 'ethereum',
+        dstChainId: 'polygon',
+        token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        amount: '10000',
+        operation: 'supply',
+      });
+
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Chain not allowed');
+    });
+  });
+
+  describe('getAvailablePolicies', () => {
+    it('should return empty array when no config', () => {
+      const engine = new PolicyEngine();
+      expect(engine.getAvailablePolicies()).toEqual([]);
+    });
+
+    it('should return policy IDs', () => {
+      process.env.AMPED_OC_LIMITS_JSON = JSON.stringify({
+        default: {},
+        aggressive: {},
+        conservative: {},
+      });
+
+      const engine = new PolicyEngine();
+      const policies = engine.getAvailablePolicies();
+      expect(policies).toContain('default');
+      expect(policies).toContain('aggressive');
+      expect(policies).toContain('conservative');
+      expect(policies).toHaveLength(3);
+    });
+  });
+});

package/src/__tests__/positionAggregator.test.ts

@@ -0,0 +1,271 @@
+/**
+ * Position Aggregator Tests
+ */
+
+import {
+  formatHealthFactor,
+  getHealthFactorStatus,
+  getPositionRecommendation,
+  TokenPosition,
+  CrossChainPositionView,
+} from '../utils/positionAggregator';
+
+// Mock dependencies
+jest.mock('../sodax/client');
+jest.mock('../providers/spokeProviderFactory');
+jest.mock('../wallet/walletRegistry');
+
+describe('Position Aggregator Utilities', () => {
+  describe('formatHealthFactor', () => {
+    it('should format finite health factors', () => {
+      expect(formatHealthFactor(1.5)).toBe('1.50');
+      expect(formatHealthFactor(2.345)).toBe('2.35');
+      expect(formatHealthFactor(0.95)).toBe('0.95');
+    });
+
+    it('should format infinity', () => {
+      expect(formatHealthFactor(Infinity)).toBe('∞');
+    });
+
+    it('should handle null', () => {
+      expect(formatHealthFactor(null)).toBe('N/A');
+    });
+  });
+
+  describe('getHealthFactorStatus', () => {
+    it('should return critical for HF < 1.1', () => {
+      expect(getHealthFactorStatus(1.0)).toEqual({ status: 'critical', color: 'red' });
+      expect(getHealthFactorStatus(1.05)).toEqual({ status: 'critical', color: 'red' });
+    });
+
+    it('should return danger for HF 1.1-1.5', () => {
+      expect(getHealthFactorStatus(1.2)).toEqual({ status: 'danger', color: 'orange' });
+      expect(getHealthFactorStatus(1.49)).toEqual({ status: 'danger', color: 'orange' });
+    });
+
+    it('should return caution for HF 1.5-2', () => {
+      expect(getHealthFactorStatus(1.6)).toEqual({ status: 'caution', color: 'yellow' });
+      expect(getHealthFactorStatus(1.9)).toEqual({ status: 'caution', color: 'yellow' });
+    });
+
+    it('should return healthy for HF >= 2', () => {
+      expect(getHealthFactorStatus(2.0)).toEqual({ status: 'healthy', color: 'green' });
+      expect(getHealthFactorStatus(5.0)).toEqual({ status: 'healthy', color: 'green' });
+      expect(getHealthFactorStatus(Infinity)).toEqual({ status: 'healthy', color: 'green' });
+    });
+
+    it('should return healthy for null', () => {
+      expect(getHealthFactorStatus(null)).toEqual({ status: 'healthy', color: 'green' });
+    });
+  });
+
+  describe('getPositionRecommendation', () => {
+    it('should warn about low health factor', () => {
+      const view = createMockView({
+        healthFactor: 1.3,
+        availableBorrowUsd: 0,
+        utilizationRate: 60,
+        netApy: 0.02,
+      });
+
+      const recommendations = getPositionRecommendation(view);
+      expect(recommendations.some(r => r.includes('Health factor is low'))).toBe(true);
+    });
+
+    it('should suggest available borrowing power', () => {
+      const view = createMockView({
+        healthFactor: 2.5,
+        availableBorrowUsd: 5000,
+        utilizationRate: 40,
+        netApy: 0.02,
+      });
+
+      const recommendations = getPositionRecommendation(view);
+      expect(recommendations.some(r => r.includes('borrowing power'))).toBe(true);
+    });
+
+    it('should warn about high utilization', () => {
+      const view = createMockView({
+        healthFactor: 1.8,
+        availableBorrowUsd: 100,
+        utilizationRate: 85,
+        netApy: 0.02,
+      });
+
+      const recommendations = getPositionRecommendation(view);
+      expect(recommendations.some(r => r.includes('High collateral utilization'))).toBe(true);
+    });
+
+    it('should warn about negative net APY', () => {
+      const view = createMockView({
+        healthFactor: 2.0,
+        availableBorrowUsd: 100,
+        utilizationRate: 50,
+        netApy: -0.01,
+      });
+
+      const recommendations = getPositionRecommendation(view);
+      expect(recommendations.some(r => r.includes('borrowing costs exceed'))).toBe(true);
+    });
+
+    it('should mention cross-chain positions', () => {
+      const view = createMockView({
+        healthFactor: 2.0,
+        availableBorrowUsd: 100,
+        utilizationRate: 50,
+        netApy: 0.02,
+        chainCount: 3,
+      });
+
+      const recommendations = getPositionRecommendation(view);
+      expect(recommendations.some(r => r.includes('chains'))).toBe(true);
+    });
+
+    it('should return empty array for healthy position', () => {
+      const view = createMockView({
+        healthFactor: 2.5,
+        availableBorrowUsd: 100,
+        utilizationRate: 50,
+        netApy: 0.05,
+        chainCount: 1,
+      });
+
+      const recommendations = getPositionRecommendation(view);
+      expect(recommendations.length).toBe(0);
+    });
+  });
+});
+
+// Helper function to create mock views
+function createMockView(params: {
+  healthFactor: number;
+  availableBorrowUsd: number;
+  utilizationRate: number;
+  netApy: number;
+  chainCount?: number;
+}): CrossChainPositionView {
+  const chainSummaries = Array(params.chainCount || 1).fill(null).map((_, i) => ({
+    chainId: `chain${i}`,
+    supplyUsd: 10000,
+    borrowUsd: 5000,
+    netWorthUsd: 5000,
+    healthFactor: params.healthFactor,
+    positionCount: 2,
+  }));
+
+  return {
+    walletId: 'test',
+    address: '0x123',
+    timestamp: new Date().toISOString(),
+    summary: {
+      totalSupplyUsd: chainSummaries.reduce((s, c) => s + c.supplyUsd, 0),
+      totalBorrowUsd: chainSummaries.reduce((s, c) => s + c.borrowUsd, 0),
+      netWorthUsd: chainSummaries.reduce((s, c) => s + c.netWorthUsd, 0),
+      availableBorrowUsd: params.availableBorrowUsd,
+      healthFactor: params.healthFactor,
+      liquidationRisk: params.healthFactor < 1.5 ? 'medium' : 'none',
+      weightedSupplyApy: 0.05,
+      weightedBorrowApy: 0.03,
+      netApy: params.netApy,
+    },
+    chainSummaries,
+    positions: [],
+    collateralUtilization: {
+      totalCollateralUsd: 10000,
+      usedCollateralUsd: params.utilizationRate * 100,
+      availableCollateralUsd: 10000 - params.utilizationRate * 100,
+      utilizationRate: params.utilizationRate,
+    },
+    riskMetrics: {
+      maxLtv: 0.8,
+      currentLtv: 0.5,
+      bufferUntilLiquidation: 30,
+      safeMaxBorrowUsd: 8000,
+    },
+  };
+}
+
+describe('Position Calculations', () => {
+  const mockPositions: TokenPosition[] = [
+    {
+      chainId: 'ethereum',
+      token: {
+        address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        symbol: 'USDC',
+        name: 'USD Coin',
+        decimals: 6,
+      },
+      supply: {
+        balance: '10000',
+        balanceUsd: '10000',
+        balanceRaw: '10000000000',
+        apy: 0.05,
+        isCollateral: true,
+      },
+      borrow: {
+        balance: '0',
+        balanceUsd: '0',
+        balanceRaw: '0',
+        apy: 0,
+      },
+      loanToValue: 0.8,
+      liquidationThreshold: 0.85,
+    },
+    {
+      chainId: 'ethereum',
+      token: {
+        address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+        symbol: 'WETH',
+        name: 'Wrapped Ether',
+        decimals: 18,
+      },
+      supply: {
+        balance: '0',
+        balanceUsd: '0',
+        balanceRaw: '0',
+        apy: 0,
+        isCollateral: false,
+      },
+      borrow: {
+        balance: '2',
+        balanceUsd: '5000',
+        balanceRaw: '2000000000000000000',
+        apy: 0.03,
+      },
+      loanToValue: 0.75,
+      liquidationThreshold: 0.8,
+    },
+  ];
+
+  it('should calculate total supply correctly', () => {
+    const totalSupply = mockPositions.reduce(
+      (sum, p) => sum + parseFloat(p.supply.balanceUsd || '0'),
+      0
+    );
+    expect(totalSupply).toBe(10000);
+  });
+
+  it('should calculate total borrow correctly', () => {
+    const totalBorrow = mockPositions.reduce(
+      (sum, p) => sum + parseFloat(p.borrow.balanceUsd || '0'),
+      0
+    );
+    expect(totalBorrow).toBe(5000);
+  });
+
+  it('should identify collateral assets', () => {
+    const collateralPositions = mockPositions.filter(p => p.supply.isCollateral);
+    expect(collateralPositions).toHaveLength(1);
+    expect(collateralPositions[0].token.symbol).toBe('USDC');
+  });
+
+  it('should calculate weighted APY correctly', () => {
+    const totalSupply = 10000;
+    const weightedSupplyApy = mockPositions.reduce(
+      (sum, p) => sum + parseFloat(p.supply.balanceUsd || '0') * p.supply.apy,
+      0
+    ) / totalSupply;
+    
+    expect(weightedSupplyApy).toBe(0.05);
+  });
+});

package/src/__tests__/setup.ts

@@ -0,0 +1,35 @@
+/**
+ * Jest Test Setup
+ */
+
+// Mock console methods to reduce noise during tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+};
+
+// Set default test environment
+process.env.AMPED_OC_MODE = 'execute';
+process.env.AMPED_OC_WALLETS_JSON = JSON.stringify({
+  test: {
+    address: '0x1234567890123456789012345678901234567890',
+    privateKey: '0xabc123def456',
+  },
+});
+process.env.AMPED_OC_RPC_URLS_JSON = JSON.stringify({
+  ethereum: 'https://eth-mainnet.example.com',
+  arbitrum: 'https://arb-mainnet.example.com',
+  sonic: 'https://rpc.sonic.example.com',
+});
+
+// Global test timeout
+jest.setTimeout(10000);
+
+// Clean up after each test
+afterEach(() => {
+  jest.clearAllMocks();
+});