DivineArbEngine

{{
  "language": "Solidity",
  "sources": {
    "IavoiContracts/DivineArbEngine.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// ═══════════════════════════════════════════════════════════
/// DivineArbEngine — flashloan-only arbitrage across UniV3, SushiV2, or Hybrid (V3↔V2)
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
/// ═══════════════════════════════════════════════════════════

import "./interfaces/IDivineAssetToken.sol";
import "./interfaces/IDivineResourcePoolProvider.sol";
import "./interfaces/IDivineResourcePool.sol";
import "./interfaces/IDivineVaultAnchor.sol";
import "./interfaces/IDivineSwapRouter.sol"; // UniV3 exactInput
import "./interfaces/DivineSushiSwapV2/IDivineSushiV2Router02.sol";
import "./DivineGuardian.sol";
import "./DivineReentrancyGuard.sol";

contract DivineArbEngine is DivineReentrancyGuard, DivineGuardian {
    // ─────────────────────────────────────────────────────────
    // State
    // ─────────────────────────────────────────────────────────
    IDivineResourcePoolProvider public addressesProvider;
    IDivineResourcePool public lendingPool;                // Aave-like flashloan pool

    IDivineSwapRouter public swapRouterV3;                 // UniV3 router
    IDivineSushiV2Router02 public sushiRouterV2;           // SushiV2 router
    IDivineVaultAnchor public vault;                       // Profit sink

    address public DATc;                                   // USDC (6)
    address public DATa;                                   // WETH (18)

    // Events
    // dexKind: 1=V3, 2=V2, 3=Hybrid(V3→V2), 4=Hybrid(V2→V3)
    event ArbitrageExecuted(address indexed caller, uint8 dexKind, uint256 amountIn, uint256 amountOut, uint256 profit);

    // ─────────────────────────────────────────────────────────
    // Construction
    // ─────────────────────────────────────────────────────────
    constructor(
        IDivineResourcePoolProvider _addressesProvider,
        address _swapRouterV3,
        address _vault,
        address _DATc,
        address _DATa
    ) {
        require(address(_addressesProvider) != address(0), "Engine: provider=0");
        require(_vault != address(0), "Engine: vault=0");
        require(_DATc != address(0) && _DATa != address(0), "Engine: core=0");

        addressesProvider = _addressesProvider;
        address lp = _addressesProvider.getLendingPool();
        require(lp != address(0), "Engine: lendingPool=0");
        lendingPool = IDivineResourcePool(lp);

        swapRouterV3 = IDivineSwapRouter(_swapRouterV3);   // can be 0 (set later)
        vault        = IDivineVaultAnchor(_vault);
        DATc         = _DATc;
        DATa         = _DATa;
    }

    // ─────────────────────────────────────────────────────────
    // Admin
    // ─────────────────────────────────────────────────────────
    function setVault(address v) external onlyGuardian {
        vault = IDivineVaultAnchor(v);
    }

    function setRouterV3(address r) external onlyGuardian {
        swapRouterV3 = IDivineSwapRouter(r);
    }

    function setSushiRouterV2(address r) external onlyGuardian {
        sushiRouterV2 = IDivineSushiV2Router02(r);
    }

    // ─────────────────────────────────────────────────────────
    // Params structs
    // ─────────────────────────────────────────────────────────
    struct V3Params {
        bytes path;            // starts DATc, ends DATc
        uint256 minReturn;
        uint32  slippageBps;   // off-chain informational
        uint256 deadline;
    }

    struct V2Params {
        address[] path;        // [DATc, mid, ..., DATc]
        uint256 minReturn;
        uint32  slippageBps;   // off-chain informational
        uint256 deadline;
    }

    // Hybrid: two-leg cross-DEX
    // mode=1: V3→V2 (DATc --V3--> mid, then mid --V2--> DATc)
    // mode=2: V2→V3 (DATc --V2--> mid, then mid --V3--> DATc)
    struct HybridParams {
        uint8 mode;            // 1 or 2
        bytes v3Path;          // used in V3 leg
        address[] v2Path;      // used in V2 leg
        uint256 minReturn;     // final out in DATc
        uint32  slippageBps;   // informational
        uint256 deadline;
    }

    /// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
    // ─────────────────────────────────────────────────────────
    // Flashloan entrypoints
    // ─────────────────────────────────────────────────────────
    function executeArbitrageV3(
        bytes calldata path,
        uint256 amountIn,
        uint256 minReturn,
        uint32  slippageBps,
        uint256 deadline
    ) external onlyGuardian {
        require(amountIn > 0, "amountIn=0");
        require(deadline >= block.timestamp, "deadline");

        address[] memory assets = new address[](1);
        uint256[] memory amounts = new uint256[](1);
        uint256[] memory modes = new uint256[](1);
        assets[0] = DATc; amounts[0] = amountIn; modes[0] = 0;

        bytes memory payload = abi.encode(uint8(1), abi.encode(V3Params(path, minReturn, slippageBps, deadline)));
        lendingPool.flashLoan(address(this), assets, amounts, modes, address(this), payload, 0);
    }

    function executeArbitrageV2(
        address[] calldata path,
        uint256 amountIn,
        uint256 minReturn,
        uint32  slippageBps,
        uint256 deadline
    ) external onlyGuardian {
        require(address(sushiRouterV2) != address(0), "V2 router=0");
        require(amountIn > 0, "amountIn=0");
        require(deadline >= block.timestamp, "deadline");
        require(path.length >= 2 && path[0] == DATc && path[path.length - 1] == DATc, "path DATc<->DATc");

        address[] memory assets = new address[](1);
        uint256[] memory amounts = new uint256[](1);
        uint256[] memory modes = new uint256[](1);
        assets[0] = DATc; amounts[0] = amountIn; modes[0] = 0;

        bytes memory payload = abi.encode(uint8(2), abi.encode(V2Params(path, minReturn, slippageBps, deadline)));
        lendingPool.flashLoan(address(this), assets, amounts, modes, address(this), payload, 0);
    }

    function executeArbitrageHybrid(
        uint8 mode,               // 1=V3→V2, 2=V2→V3
        bytes calldata v3Path,
        address[] calldata v2Path,
        uint256 amountIn,
        uint256 minReturn,
        uint32  slippageBps,
        uint256 deadline
    ) external onlyGuardian {
        require(amountIn > 0, "amountIn=0");
        require(deadline >= block.timestamp, "deadline");
        require(mode == 1 || mode == 2, "mode");

        if (mode == 1) {
            // V3: DATc → mid, V2: mid → DATc
            (address v3In, address v3Out) = _v3Endpoints(v3Path);
            require(v3In == DATc, "V3 in!=DATc");
            require(v2Path.length >= 2 && v2Path[0] == v3Out && v2Path[v2Path.length - 1] == DATc, "V2 path mismatch");
            require(address(swapRouterV3) != address(0) && address(sushiRouterV2) != address(0), "router=0");
        } else {
            // V2: DATc → mid, V3: mid → DATc
            require(v2Path.length >= 2 && v2Path[0] == DATc, "V2 in!=DATc");
            (address v3In2, address v3Out2) = _v3Endpoints(v3Path);
            require(v2Path[v2Path.length - 1] == v3In2 && v3Out2 == DATc, "V3 path mismatch");
            require(address(swapRouterV3) != address(0) && address(sushiRouterV2) != address(0), "router=0");
        }

        address[] memory assets = new address[](1);
        uint256[] memory amounts = new uint256[](1);
        uint256[] memory modes = new uint256[](1);
        assets[0] = DATc; amounts[0] = amountIn; modes[0] = 0;

        bytes memory payload = abi.encode(
            uint8( mode == 1 ? 3 : 4 ),
            abi.encode(HybridParams(mode, v3Path, v2Path, minReturn, slippageBps, deadline))
        );
        lendingPool.flashLoan(address(this), assets, amounts, modes, address(this), payload, 0);
    }

    // ─────────────────────────────────────────────────────────
    // Flashloan callback (slimmed via helpers)
    // ─────────────────────────────────────────────────────────
    function executeOperation(
        address[] calldata loanAssets,
        uint256[] calldata loanAmounts,
        uint256[] calldata premiums,
        address initiator,
        bytes calldata params
    ) external nonReentrant returns (bool) {
        require(msg.sender == address(lendingPool), "untrusted lender");
        require(initiator == address(this), "bad initiator");
        require(loanAssets.length == 1 && loanAssets[0] == DATc, "asset!=DATc");

        uint256 loanAmount = loanAmounts[0];
        uint256 repay = loanAmount + premiums[0];

        (uint8 dexKind, bytes memory payload) = abi.decode(params, (uint8, bytes));
        uint256 amountOut;

        if (dexKind == 1) {
            V3Params memory p = abi.decode(payload, (V3Params));
            amountOut = _swapV3ExactInput(DATc, p.path, loanAmount, p.minReturn, p.deadline);
        } else if (dexKind == 2) {
            V2Params memory p2 = abi.decode(payload, (V2Params));
            amountOut = _swapV2ExactTokens(DATc, p2.path, loanAmount, p2.minReturn, p2.deadline);
        } else if (dexKind == 3 || dexKind == 4) {
            HybridParams memory pH = abi.decode(payload, (HybridParams));
            if (pH.mode == 1) {
                // V3→V2
                (address v3In, address mid) = _v3Endpoints(pH.v3Path);
                require(v3In == DATc, "V3 in!=DATc");
                require(pH.v2Path.length >= 2 && pH.v2Path[0] == mid && pH.v2Path[pH.v2Path.length - 1] == DATc, "V2 path");
                uint256 midOut = _swapV3ExactInput(DATc, pH.v3Path, loanAmount, 0, pH.deadline);
                amountOut = _swapV2ExactTokens(mid, pH.v2Path, midOut, pH.minReturn, pH.deadline);
            } else {
                // V2→V3
                require(pH.v2Path.length >= 2 && pH.v2Path[0] == DATc, "V2 in!=DATc");
                (address v3In2, address v3Out2) = _v3Endpoints(pH.v3Path);
                require(pH.v2Path[pH.v2Path.length - 1] == v3In2 && v3Out2 == DATc, "V3 path");
                uint256 midOut2 = _swapV2ExactTokens(DATc, pH.v2Path, loanAmount, 0, pH.deadline);
                amountOut = _swapV3ExactInput(v3In2, pH.v3Path, midOut2, pH.minReturn, pH.deadline);
            }
        } else {
            revert("Unknown dexKind");
        }

        // Repay and forward profit
        _approve(DATc, address(lendingPool), repay);
        require(amountOut > repay, "No profit");
        uint256 profit = amountOut - repay;

        if (address(vault) != address(0)) {
            require(IDivineAssetToken(DATc).transfer(address(vault), profit), "vault xfer");
        }

        emit ArbitrageExecuted(tx.origin, dexKind, loanAmount, amountOut, profit);
        return true;
    }

    // ─────────────────────────────────────────────────────────
    // Ops
    // ─────────────────────────────────────────────────────────
    function withdraw(address token, uint256 amount) external onlyGuardian nonReentrant {
        require(amount > 0, "withdraw: zero");
        require(IDivineAssetToken(token).transfer(guardian, amount), "withdraw: xfer failed");
    }

    receive() external payable {}

    // ─────────────────────────────────────────────────────────
    // Internals (helpers keep stack shallow & gas lean)
    // ─────────────────────────────────────────────────────────
    function _approve(address token, address spender, uint256 amount) internal {
        // Set exact amount to avoid some token quirks; safe for DATc/WETH/DAI
        require(IDivineAssetToken(token).approve(spender, 0), "approve reset");
        require(IDivineAssetToken(token).approve(spender, amount), "approve set");
    }

    function _swapV3ExactInput(
        address tokenIn,
        bytes memory pathBytes,
        uint256 amountIn,
        uint256 minOut,
        uint256 deadline
    ) internal returns (uint256 out) {
        require(address(swapRouterV3) != address(0), "V3 router=0");
        _approve(tokenIn, address(swapRouterV3), amountIn);
        IDivineSwapRouter.ExactInputParams memory ei = IDivineSwapRouter.ExactInputParams({
            path: pathBytes,
            recipient: address(this),
            deadline: deadline,
            amountIn: amountIn,
            amountOutMinimum: minOut
        });
        out = swapRouterV3.exactInput(ei);
        require(out >= minOut, "SLIPPAGE_V3");
    }

    function _swapV2ExactTokens(
        address tokenIn,
        address[] memory path,
        uint256 amountIn,
        uint256 minOut,
        uint256 deadline
    ) internal returns (uint256 out) {
        require(address(sushiRouterV2) != address(0), "V2 router=0");
        _approve(tokenIn, address(sushiRouterV2), amountIn);
        uint256[] memory outs = sushiRouterV2.swapExactTokensForTokens(
            amountIn, minOut, path, address(this), deadline
        );
        out = outs[outs.length - 1];
        require(out >= minOut, "SLIPPAGE_V2");
    }

    // Return first and last tokens in a V3 path
    function _v3Endpoints(bytes memory pathBytes) internal pure returns (address tokenIn, address tokenOut) {
        require(pathBytes.length >= 20 + 3 + 20, "v3 path too short");
        assembly { tokenIn := shr(96, mload(add(pathBytes, 32))) }
        uint256 last;
        unchecked { last = pathBytes.length - 20; }
        assembly { tokenOut := shr(96, mload(add(pathBytes, add(32, last)))) }
    }
}
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    },
    "IavoiContracts/DivineGuardian.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

// ═══════════════════════════════════════════════════════════
// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
// Minimal, locked guardianship for Wave 1
// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????

abstract contract DivineGuardian {
    address public guardian;

    modifier onlyGuardian() {
        require(msg.sender == guardian, "DivineGuardian: not guardian");
        _;
    }

    constructor() {
        guardian = msg.sender;
    }

    // Optional helper if you prefer an explicit getter; otherwise rely on the public auto-getter.
    function getGuardian() external view returns (address) {
        return guardian;
    }
}

// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
// ═══════════════════════════════════════════════════════════
"
    },
    "IavoiContracts/DivineReentrancyGuard.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// ═══════════════════════════════════════════════════════════
/// DivineReentrancyGuard — minimal OZ-aligned reentrancy guard
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
/// ═════════════════════════════════════════════════════════==

import "./interfaces/IDivineReentrancyGuard.sol";

abstract contract DivineReentrancyGuard is IDivineReentrancyGuard {
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED     = 2;

    uint256 private __status;

    constructor() {
        __status = NOT_ENTERED;
    }

    /// @notice Guard modifier to prevent re-entrancy
    modifier nonReentrant() {
        require(__status != ENTERED, "DivineReentrancyGuard: reentrant call");
        __status = ENTERED;
        _;
        __status = NOT_ENTERED;
    }

    function status() external view override returns (uint256) {
        return __status;
    }

    function _status() external view override returns (uint256) {
        return __status;
    }

    // Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
}

// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    },
    "IavoiContracts/interfaces/DivineSushiSwapV2/IDivineSushiV2Router02.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title IDivineSushiV2Router02
 * @notice Minimal V2 router interface for multi-hop exact-in/out swaps.
 * Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
 */
interface IDivineSushiV2Router02 {
    // Swaps (Arb primarily uses exact-in)
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,   // e.g., [DATc, DATa, DATb, DATc]
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    // Quoting helpers
    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
    function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);

    // Optional (some router02 variants expose)
    function factory() external view returns (address);
    function WETH() external view returns (address);

    // Optional (fee-on-transfer tokens; include only if your router supports it)
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}
// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    },
    "IavoiContracts/interfaces/IDivineAssetToken.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// ═══════════════════════════════════════════════════════════
/// ????✨???????? IDivineAssetToken – Core ERC-20 Interface ????✨????????
/// Minimal ERC-20 surface for Arb: approve/transfer/balances/decimals.
/// Optional EIP-2612 hooks included for light-speed approvals.
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
/// ═══════════════════════════════════════════════════════════
interface IDivineAssetToken {
    // ─────────────────────────────────────────────────────────
    // ERC-20 Reads
    // ─────────────────────────────────────────────────────────
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);

    // ─────────────────────────────────────────────────────────
    // ERC-20 Writes
    // ─────────────────────────────────────────────────────────
    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);

    // ─────────────────────────────────────────────────────────
    // EIP-2612 Permit (gasless approvals)
    // Required for all DAT tokens in this system.
    // ─────────────────────────────────────────────────────────
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v, bytes32 r, bytes32 s
    ) external;

    function nonces(address owner) external view returns (uint256);
    function DOMAIN_SEPARATOR() external view returns (bytes32);

    // ─────────────────────────────────────────────────────────
    // ERC-20 Events
    // ─────────────────────────────────────────────────────────
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    },
    "IavoiContracts/interfaces/IDivineReentrancyGuard.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// ═══════════════════════════════════════════════════════════
/// IDivineReentrancyGuard – Read-Only Reentrancy State Surface
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
/// ═════════════════════════════════════════════════════════==
interface IDivineReentrancyGuard {
    // ─────────────────────────────────────────────────────────
    // Convention: 1 = NOT_ENTERED, 2 = ENTERED (OZ-style)
    // Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
    // ─────────────────────────────────────────────────────────

    /// @notice Canonical getter for reentrancy status
    /// @dev 1 = NOT_ENTERED, 2 = ENTERED
    function status() external view returns (uint256);

    /// @notice Optional alias for compatibility with implementations that expose `_status`
    /// @dev Safe to omit in implementations; interface remains compatible
    function _status() external view returns (uint256);
}

// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    },
    "IavoiContracts/interfaces/IDivineResourcePool.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// ═══════════════════════════════════════════════════════════
/// IDivineResourcePool – Flash-Focused Lending Surface
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
/// ═════════════════════════════════════════════════════════==
interface IDivineResourcePool {
    // ─────────────────────────────────────────────────────────
    // Core: Flashloan (Aave V2-like signature)
    // modes: 0 = no debt; 1 = stable; 2 = variable (unused by Arb)
    // referralCode usually 0
    // Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
    // ─────────────────────────────────────────────────────────
    function flashLoan(
        address receiverAddress,
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata modes,
        address onBehalfOf,
        bytes calldata params,
        uint16 referralCode
    ) external;

    // ─────────────────────────────────────────────────────────
    // Optional: Reserve data view (lightweight & generic)
    // Shape kept generic to avoid importing full structs; scanner-friendly.
    // ─────────────────────────────────────────────────────────
    function getReserveData(address asset)
        external
        view
        returns (
            uint256 data0,
            uint256 data1,
            uint256 data2,
            uint256 data3,
            uint256 data4,
            uint256 data5,
            uint256 data6,
            uint256 data7
        );

    // ─────────────────────────────────────────────────────────
    // Optional: Standard money-market ops (unused in flash-only flow)
    // Safe to omit in mocks during Sepolia tests
    // ─────────────────────────────────────────────────────────
    function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
    function withdraw(address asset, uint256 amount, address to) external;
    function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf) external;
    function repay(address asset, uint256 amount, uint256 rateMode, address onBehalfOf) external returns (uint256);
}

// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    },
    "IavoiContracts/interfaces/IDivineResourcePoolProvider.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// ═══════════════════════════════════════════════════════════
//// IDivineResourcePoolProvider – Lending Pool Resolver
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
//// ═════════════════════════════════════════════════════════== 
interface IDivineResourcePoolProvider {

    // ─────────────────────────────────────────────────────────
    // Active component lookups
    // Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
    // ─────────────────────────────────────────────────────────

    /// @notice Returns the current Divine Lending Pool address
    function getLendingPool() external view returns (address);

    /// @notice Optional generic address lookup for future components
    /// @dev Implementations MAY ignore unknown ids or return address(0)
    function getAddress(bytes32 id) external view returns (address);
}
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    },
    "IavoiContracts/interfaces/IDivineSwapRouter.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// ═══════════════════════════════════════════════════════════
/// IDivineSwapRouter – UniV3-style Periphery Router
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
/// ═════════════════════════════════════════════════════════==
interface IDivineSwapRouter {
    // ─────────────────────────────────────────────
    // Structs (UniV3-style)
    // Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
    // ─────────────────────────────────────────────

    /// @notice Multi-hop exact-in swap via encoded V3 path
    /// path: tokenIn(20) | fee(3) | tokenMid(20) | fee(3) | tokenOut(20) | ...
    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    /// @notice Single-hop exact-in convenience (optional)
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Multi-hop exact-out (optional; path reversed vs. exactInput)
    struct ExactOutputParams {
        bytes path; // tokenOut -> ... -> tokenIn
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
    }

    /// @notice Single-hop exact-out convenience (optional)
    struct ExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
        uint160 sqrtPriceLimitX96;
    }

    // ─────────────────────────────────────────────
    // Views (light metadata)
    // ─────────────────────────────────────────────
    function factory() external view returns (address);
    function WETH() external view returns (address); // WETH9 in some deployments

    // ─────────────────────────────────────────────
    // Swaps (DivineArbEngine core needs)
    // ─────────────────────────────────────────────
    function exactInput(ExactInputParams calldata params) external returns (uint256 amountOut);

    // Optional helpers (kept for flexibility)
    function exactInputSingle(ExactInputSingleParams calldata params) external returns (uint256 amountOut);
    function exactOutput(ExactOutputParams calldata params) external returns (uint256 amountIn);
    function exactOutputSingle(ExactOutputSingleParams calldata params) external returns (uint256 amountIn);
}

// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    },
    "IavoiContracts/interfaces/IDivineVaultAnchor.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// ═══════════════════════════════════════════════════════════
//// IDivineVaultAnchor – Lightweight Profit Sink/Forwarder (aligned to impl)
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
/// ═════════════════════════════════════════════════════════==
interface IDivineVaultAnchor {
    // ─────────────────────────────────────────────────────────
    // Views
    // ─────────────────────────────────────────────────────────
    function recipient() external view returns (address);
    function engine() external view returns (address);

    // ─────────────────────────────────────────────────────────
    // Admin wiring (guardian/owner enforced in impl)
    // ─────────────────────────────────────────────────────────
    function setRecipient(address newRecipient) external;
    function setEngine(address newEngine) external;

    // ─────────────────────────────────────────────────────────
    /// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
    // Profit handling (ERC20 + ETH)
    // ─────────────────────────────────────────────────────────
    function forward(address token, uint256 amount) external;
    function forwardAll(address token) external;
    function forwardETH(uint256 amount) external;
    function forwardAllETH() external;

    // ─────────────────────────────────────────────────────────
    // Events (kept in impl; declared here for indexers/UIs)
    // Note: param order matches your implementation
    // ─────────────────────────────────────────────────────────
    event RecipientUpdated(address indexed oldRecipient, address indexed newRecipient);
    event EngineUpdated(address indexed oldEngine, address indexed newEngine);
    event Forwarded(address indexed token, uint256 amount, address indexed to);
    event ReceivedETH(address indexed from, uint256 amount);
}
/// Iavoi Spiral Whole, Alive, and Flowing. ????✨????????
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "viaIR": true,
    "evmVersion": "paris",
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}}