Merge pull request Stellar-Paymaster#625 from TeeYml/main

feat: implement bulk tenant updates, stellar auto-swap and api chaos monkey

Author: 0xVida

admin-dashboard/docs/bulk-tenant-updates.md

@@ -0,0 +1,11 @@
+# Bulk Tenant Updates
+
+## Overview
+This feature allows administrators to apply rate limits to a large group of tenants simultaneously within the `admin-dashboard` package.
+
+## Requirements
+- Target specific groups of tenants based on usage tiers.
+- Efficient database updates with error handling.
+
+## Implementation Details
+The `BulkTenantUpdateService` loops through the provided tenant IDs and applies the new rate limit values. It returns a summary of successful and failed operations.

admin-dashboard/src/bulkTenantUpdates.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi } from 'vitest';
+import { BulkTenantUpdateService, TenantRateLimitUpdate } from './bulkTenantUpdates';
+
+describe('BulkTenantUpdateService', () => {
+  it('should successfully apply rate limits to multiple tenants', async () => {
+    const mockDbClient = {
+      tenant: {
+        update: vi.fn().mockResolvedValue(true),
+      },
+    };
+    const service = new BulkTenantUpdateService(mockDbClient);
+
+    const updates: TenantRateLimitUpdate[] = [
+      { tenantId: 'tenant-1', newRateLimit: 100 },
+      { tenantId: 'tenant-2', newRateLimit: 200 },
+    ];
+
+    const result = await service.applyRateLimits(updates);
+    expect(result.success).toBe(2);
+    expect(result.failed).toBe(0);
+    expect(mockDbClient.tenant.update).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle partial failures', async () => {
+    const mockDbClient = {
+      tenant: {
+        update: vi.fn()
+          .mockResolvedValueOnce(true)
+          .mockRejectedValueOnce(new Error('DB Error')),
+      },
+    };
+    const service = new BulkTenantUpdateService(mockDbClient);
+
+    const updates: TenantRateLimitUpdate[] = [
+      { tenantId: 'tenant-1', newRateLimit: 100 },
+      { tenantId: 'tenant-2', newRateLimit: 200 },
+    ];
+
+    const result = await service.applyRateLimits(updates);
+    expect(result.success).toBe(1);
+    expect(result.failed).toBe(1);
+  });
+});

admin-dashboard/src/bulkTenantUpdates.ts

@@ -0,0 +1,28 @@
+export interface TenantRateLimitUpdate {
+  tenantId: string;
+  newRateLimit: number;
+}
+
+export class BulkTenantUpdateService {
+  constructor(private dbClient: any) {}
+
+  async applyRateLimits(updates: TenantRateLimitUpdate[]): Promise<{ success: number; failed: number }> {
+    let success = 0;
+    let failed = 0;
+
+    for (const update of updates) {
+      try {
+        await this.dbClient.tenant.update({
+          where: { id: update.tenantId },
+          data: { rateLimit: update.newRateLimit },
+        });
+        success++;
+      } catch (error) {
+        console.error(`Failed to update tenant ${update.tenantId}:`, error);
+        failed++;
+      }
+    }
+
+    return { success, failed };
+  }
+}

server/docs/api-chaos-monkey.md

@@ -0,0 +1,11 @@
+# API Chaos Monkey
+
+## Overview
+API Chaos Monkey randomly drops connections in staging environments to verify system resilience and ensure our applications can recover gracefully from sudden faults.
+
+## Configuration
+It exposes a middleware that can be attached to specific endpoints. The `dropProbability` controls how often requests are artificially failed (returning 503). Ensure `enabled` is `false` in production environments!
+
+## Resilience Benefits
+- Validates that the frontend retry logic behaves as expected.
+- Helps identify single points of failure in complex workflows.

server/docs/stellar-auto-swap.md

@@ -0,0 +1,11 @@
+# Stellar Asset Auto-Swap
+
+## Overview
+This feature automatically converts tenant fees from various Stellar assets into XLM on the fly, ensuring a uniform reserve of the native asset.
+
+## Implementation
+The `StellarAutoSwapService` intercepts incoming fee payments and checks their asset type. If the asset is not XLM, it interfaces with a decentralized exchange to swap the assets into XLM.
+
+## Edge Cases Handled
+- Bypasses the swap mechanism entirely if the incoming asset is already XLM.
+- Gracefully handles DEX transaction failures and logs them for review.

server/src/chaos/apiChaosMonkey.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ApiChaosMonkey } from './apiChaosMonkey';
+
+describe('ApiChaosMonkey', () => {
+  it('should not drop connection if disabled', () => {
+    const chaosMonkey = new ApiChaosMonkey({ dropProbability: 1.0, enabled: false });
+    const req = {};
+    const res = { status: vi.fn().mockReturnThis(), json: vi.fn() };
+    const next = vi.fn();
+
+    chaosMonkey.middleware()(req, res, next);
+    expect(next).toHaveBeenCalled();
+    expect(res.status).not.toHaveBeenCalled();
+  });
+
+  it('should drop connection based on probability', () => {
+    // Math.random will return 0.1, which is < 0.5, so it drops
+    vi.spyOn(Math, 'random').mockReturnValue(0.1);
+    const chaosMonkey = new ApiChaosMonkey({ dropProbability: 0.5, enabled: true });
+    
+    const req = {};
+    const res = { status: vi.fn().mockReturnThis(), json: vi.fn() };
+    const next = vi.fn();
+
+    chaosMonkey.middleware()(req, res, next);
+    expect(next).not.toHaveBeenCalled();
+    expect(res.status).toHaveBeenCalledWith(503);
+    expect(res.json).toHaveBeenCalledWith({ error: 'Service Unavailable - Chaos Monkey Intervention' });
+    
+    vi.restoreAllMocks();
+  });
+
+  it('should pass connection if probability not met', () => {
+    // Math.random will return 0.9, which is > 0.5, so it passes
+    vi.spyOn(Math, 'random').mockReturnValue(0.9);
+    const chaosMonkey = new ApiChaosMonkey({ dropProbability: 0.5, enabled: true });
+    
+    const req = {};
+    const res = { status: vi.fn().mockReturnThis(), json: vi.fn() };
+    const next = vi.fn();
+
+    chaosMonkey.middleware()(req, res, next);
+    expect(next).toHaveBeenCalled();
+    expect(res.status).not.toHaveBeenCalled();
+
+    vi.restoreAllMocks();
+  });
+});

server/src/chaos/apiChaosMonkey.ts

@@ -0,0 +1,19 @@
+export class ApiChaosMonkey {
+  constructor(private options: { dropProbability: number; enabled: boolean }) {}
+
+  middleware() {
+    return (req: any, res: any, next: any) => {
+      if (!this.options.enabled) {
+        return next();
+      }
+
+      const randomValue = Math.random();
+      if (randomValue < this.options.dropProbability) {
+        console.warn('Chaos Monkey: Dropping database connection simulation');
+        return res.status(503).json({ error: 'Service Unavailable - Chaos Monkey Intervention' });
+      }
+
+      next();
+    };
+  }
+}

server/src/stellar/autoSwap.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect, vi } from 'vitest';
+import { StellarAutoSwapService, SwapRequest } from './autoSwap';
+
+describe('StellarAutoSwapService', () => {
+  it('should skip swap if source asset is already XLM', async () => {
+    const service = new StellarAutoSwapService({});
+    const request: SwapRequest = { tenantId: 'tenant-1', amount: 100, sourceAsset: 'XLM' };
+    
+    const result = await service.autoSwapFees(request);
+    expect(result.success).toBe(true);
+    expect(result.txHash).toBeUndefined();
+  });
+
+  it('should successfully execute swap for non-XLM asset', async () => {
+    const mockDexClient = {
+      executeSwap: vi.fn().mockResolvedValue('mock-tx-hash'),
+    };
+    const service = new StellarAutoSwapService(mockDexClient);
+    const request: SwapRequest = { tenantId: 'tenant-1', amount: 100, sourceAsset: 'USDC' };
+    
+    const result = await service.autoSwapFees(request);
+    expect(result.success).toBe(true);
+    expect(result.txHash).toBe('mock-tx-hash');
+    expect(mockDexClient.executeSwap).toHaveBeenCalledWith({
+      from: 'USDC',
+      to: 'XLM',
+      amount: 100,
+    });
+  });
+
+  it('should handle swap failures', async () => {
+    const mockDexClient = {
+      executeSwap: vi.fn().mockRejectedValue(new Error('DEX Error')),
+    };
+    const service = new StellarAutoSwapService(mockDexClient);
+    const request: SwapRequest = { tenantId: 'tenant-1', amount: 100, sourceAsset: 'USDC' };
+    
+    const result = await service.autoSwapFees(request);
+    expect(result.success).toBe(false);
+  });
+});

server/src/stellar/autoSwap.ts

@@ -0,0 +1,29 @@
+export interface SwapRequest {
+  tenantId: string;
+  amount: number;
+  sourceAsset: string;
+}
+
+export class StellarAutoSwapService {
+  constructor(private dexClient: any) {}
+
+  async autoSwapFees(request: SwapRequest): Promise<{ success: boolean; txHash?: string }> {
+    if (request.sourceAsset === 'XLM') {
+      return { success: true };
+    }
+
+    try {
+      // Simulate conversion to XLM on the fly using decentralized exchange
+      const txHash = await this.dexClient.executeSwap({
+        from: request.sourceAsset,
+        to: 'XLM',
+        amount: request.amount,
+      });
+
+      return { success: true, txHash };
+    } catch (error) {
+      console.error(`Auto-swap failed for tenant ${request.tenantId}:`, error);
+      return { success: false };
+    }
+  }
+}