defi-arbitrage/step-execution.service.ts

// Step Execution Service
// Implements each step of the arbitrage loop

import { Decimal } from '@prisma/client/runtime/library';
import { logger } from '@/infrastructure/monitoring/logger';
import { v4 as uuidv4 } from 'uuid';
import { DEFAULT_RISK_PARAMS, DEFAULT_CAPITAL_SPLIT } from './config';
import {
  Step0Result,
  Step1Result,
  Step2Result,
  Step3Result,
  Step4Result,
  CapitalBuckets,
  DealExecutionRequest,
} from './types';
import { riskControlService } from './risk-control.service';

export class StepExecutionService {
  async executeStep0(
    request: DealExecutionRequest
  ): Promise<Step0Result> {
    logger.info('Executing STEP 0: Capital Split', {
      totalEthValue: request.totalEthValue,
    });

    const totalEth = new Decimal(request.totalEthValue);
    const buckets: CapitalBuckets = {
      coreEth: totalEth.mul(DEFAULT_CAPITAL_SPLIT.coreEthPct),
      workingLiquidity: totalEth.mul(DEFAULT_CAPITAL_SPLIT.workingLiquidityPct),
      opportunisticUsdtz: totalEth.mul(DEFAULT_CAPITAL_SPLIT.opportunisticUsdtzPct),
    };

    logger.info('Capital Split Complete', {
      coreEth: buckets.coreEth.toString(),
      workingLiquidity: buckets.workingLiquidity.toString(),
      opportunisticUsdtz: buckets.opportunisticUsdtz.toString(),
    });

    if (buckets.coreEth.lt(0) || buckets.workingLiquidity.lt(0)) {
      throw new Error('Core ETH and Working Liquidity must be non-negative');
    }

    return {
      buckets,
    };
  }

  async executeStep1(
    buckets: CapitalBuckets,
    request: DealExecutionRequest
  ): Promise<Step1Result> {
    logger.info('Executing STEP 1: Generate Working Liquidity', {
      workingLiquidity: buckets.workingLiquidity.toString(),
    });

    const maxLtv = new Decimal(request.maxLtv ?? DEFAULT_RISK_PARAMS.MAX_LTV);
    const wethAmount = buckets.workingLiquidity;
    const collateralSupplied = wethAmount;
    const borrowedUsdt = collateralSupplied.mul(maxLtv);

    const ltvCheck = await riskControlService.checkLtvCompliance(
      collateralSupplied,
      borrowedUsdt,
      maxLtv
    );

    if (!ltvCheck.passed) {
      throw new Error(`LTV check failed: ${ltvCheck.errors.join(', ')}`);
    }

    const wrapTxHash = `WRAP-${uuidv4()}`;
    const supplyTxHash = `SUPPLY-${uuidv4()}`;
    const borrowTxHash = `BORROW-${uuidv4()}`;

    logger.info('Working Liquidity Generated', {
      wethAmount: wethAmount.toString(),
      collateralSupplied: collateralSupplied.toString(),
      borrowedUsdt: borrowedUsdt.toString(),
      ltv: ltvCheck.ltv?.mul(100).toFixed(2) + '%',
    });

    return {
      wethAmount,
      collateralSupplied,
      borrowedUsdt,
      ltv: ltvCheck.ltv!,
      borrowTxHash,
      supplyTxHash,
    };
  }

  async executeStep2(
    borrowedUsdt: Decimal,
    request: DealExecutionRequest
  ): Promise<Step2Result> {
    logger.info('Executing STEP 2: Execute Discount Arbitrage', {
      borrowedUsdt: borrowedUsdt.toString(),
    });

    const discountRate = new Decimal(
      request.usdtzDiscountRate ?? DEFAULT_RISK_PARAMS.DEFAULT_USDTZ_DISCOUNT
    );
    const usdtSpent = borrowedUsdt;
    const usdtzReceived = usdtSpent.div(new Decimal(1).minus(discountRate));

    logger.warn('USDTz Acquisition', {
      usdtSpent: usdtSpent.toString(),
      usdtzReceived: usdtzReceived.toString(),
      discountRate: discountRate.mul(100).toFixed(2) + '%',
      warning: 'USDTz must NOT be pledged or bridged without prior testing',
    });

    const swapTxHash = `SWAP-${uuidv4()}`;

    return {
      usdtSpent,
      usdtzReceived,
      discountRate,
      swapTxHash,
    };
  }

  async executeStep3(
    usdtzTotal: Decimal,
    request: DealExecutionRequest
  ): Promise<Step3Result> {
    logger.info('Executing STEP 3: Partial Monetization', {
      usdtzTotal: usdtzTotal.toString(),
    });

    const split = request.monetizationSplit ?? DEFAULT_RISK_PARAMS.DEFAULT_MONETIZATION_SPLIT;
    const usdtzForRedemption = usdtzTotal.mul(split.redemptionPortion);
    const usdtzForColdStorage = usdtzTotal.mul(split.coldStoragePortion);

    logger.info('USDTz Split', {
      total: usdtzTotal.toString(),
      forRedemption: usdtzForRedemption.toString(),
      forColdStorage: usdtzForColdStorage.toString(),
    });

    let redemptionSuccessful = false;
    let usdtReceived: Decimal | undefined;
    let redemptionTxHash: string | undefined;

    try {
      const redemptionAttempted = true;
      
      if (Math.random() > 0.3) {
        redemptionSuccessful = true;
        usdtReceived = usdtzForRedemption;
        redemptionTxHash = `REDEEM-${uuidv4()}`;
        logger.info('Redemption Successful', {
          usdtzRedeemed: usdtzForRedemption.toString(),
          usdtReceived: usdtReceived.toString(),
        });
      } else {
        logger.warn('Redemption Failed or Frozen', {
          usdtzForRedemption: usdtzForRedemption.toString(),
          note: 'USDTz will be held as optional upside. No upstream impact.',
        });
      }

      return {
        usdtzForRedemption,
        usdtzForColdStorage,
        redemptionAttempted,
        redemptionSuccessful,
        usdtReceived,
        redemptionTxHash,
      };
    } catch (error: any) {
      logger.error('Redemption Error', {
        error: error.message,
        note: 'Redemption failure does not affect upstream positions',
      });
      return {
        usdtzForRedemption,
        usdtzForColdStorage,
        redemptionAttempted: true,
        redemptionSuccessful: false,
      };
    }
  }

  async executeStep4(
    borrowedUsdt: Decimal,
    usdtReceived: Decimal,
    remainingUsdtz: Decimal,
    collateralSupplied: Decimal
  ): Promise<Step4Result> {
    logger.info('Executing STEP 4: Close the Loop', {
      borrowedUsdt: borrowedUsdt.toString(),
      usdtReceived: usdtReceived.toString(),
      remainingUsdtz: remainingUsdtz.toString(),
    });

    const borrowRepaid = usdtReceived.gte(borrowedUsdt);
    if (!borrowRepaid) {
      throw new Error(
        `Insufficient USDT to repay borrow: need ${borrowedUsdt.toString()}, have ${usdtReceived.toString()}`
      );
    }

    const ethUnlocked = true;
    const profitCaptured = usdtReceived.minus(borrowedUsdt);

    const repayTxHash = `REPAY-${uuidv4()}`;
    const unlockTxHash = `UNLOCK-${uuidv4()}`;

    logger.info('Loop Closed Successfully', {
      borrowRepaid,
      ethUnlocked,
      profitCaptured: profitCaptured.toString(),
      remainingUsdtz: remainingUsdtz.toString(),
      note: 'Remaining USDTz is pure upside',
    });

    return {
      borrowRepaid,
      ethUnlocked,
      remainingUsdtz,
      profitCaptured,
      repayTxHash,
      unlockTxHash,
    };
  }
}

export const stepExecutionService = new StepExecutionService();