contract DcaDotFun is DotFun, IDcaDotFun, ReentrancyGuard {
    // Order Management
    function createOrder(OrderArgs calldata args, bytes[] calldata reports) external;
    function cancelOrders(uint256[] calldata orderIds) external;
    function fillOrder(bytes calldata data, address recipient) external;

    // Queries
    function getOrders(uint256[] calldata ids) external view returns (Order[] memory);
    function quote(uint256 id, bytes[] calldata reports) external returns (bytes memory, OrderValidation memory);
    function getOrderTokens(uint256[] calldata ids) external view returns (OrderTokens[] memory);
}

function createOrder(
    OrderArgs calldata args,
    bytes[] calldata reports
) external returns (uint256 orderId)

function fillOrder(
    bytes calldata data,
    address recipient
) external

contract DcaVault is Initializable, Ownable, IDcaVault {
    // State variables
    uint256 public orderId;
    uint256 public yieldSplit;
    uint256 public escrow;
    uint256 public totalFills;
    uint256 public spendAmount;
    address public funContract;
    address public feeCollector;
    address public recipient;
    address public tokenIn;
    address public aTokenIn;
    address public tokenOut;
    address public aTokenOut;
    address public pool;
    bool public isCancelled;

    // Protocol Functions
    function fillOrder(address recipient, uint256 amount, uint256 escrow) external;
    function cancelOrder(uint256 repeats) external;

    // Owner Functions
    function withdrawErc20(address token) external;
    function withdrawNative() external;
}

contract DcaVaultFactory {
    address public implementation;
    address public aavePool;
    mapping(uint256 => address) public vaults;

    function createVault(
        uint256 id,
        address orderCreator,
        address recipient,
        address tokenIn,
        address tokenOut,
        uint256 spendAmount,
        uint256 yieldSplit,
        address feeCollector,
        bool stakeAssetIn,
        bool stakeAssetOut
    ) external returns (address vault);
}

struct OrderArgs {
    address recipient;      // Who receives output tokens
    address tokenIn;        // Input token address
    address tokenOut;       // Output token address
    uint256 spendAmount;    // Amount per execution
    uint256 repeats;        // Number of executions
    uint256 freqInterval;   // Time between executions
    uint256 scalingInterval; // Dutch auction duration
    uint256 slippage;       // Max price deviation (basis points)
    uint256 firstExecution; // Delay before first execution
    bool stakeAssetIn;      // Stake input in Aave
    bool stakeAssetOut;     // Stake output in Aave
}

struct Order {
    address creator;      // Order creator
    uint16 slippage;      // Slippage tolerance
    bool stakeAssetIn;    // Stake input flag
    bool stakeAssetOut;   // Stake output flag
    address recipient;    // Output recipient
    address tokenIn;      // Input token
    address tokenOut;     // Output token
    uint256 spendAmount;  // Amount per fill
    uint256 repeats;      // Remaining executions
    uint256 freqInterval; // Execution frequency
    uint256 scalingInterval; // Auction duration
    uint256 lastRun;      // Last execution time
    uint256 protocolFee;  // Fee at creation
    address vault;        // Vault address
}

struct OrderValidation {
    uint256 scalingFactor;
    uint256 effectiveSlippage;
    uint256 fillableAmount;
    uint256 amountOfTokenOut;
    uint256 inAmount;
    uint256 minOutAmount;
    bool valid;
}

interface IFillOrderCallback {
    function fillOrderCallback(
        address tokenOut,
        uint256 amountOfTokenOut,
        address initiator
    ) external returns (bool);
}

interface IDcaDotFun {
    // Order creation
    function createOrder(OrderArgs calldata args, bytes[] calldata reports) external;
    function createOrderNative(OrderArgs calldata args, bytes[] calldata reports) external payable;

    // Order management
    function cancelOrders(uint256[] calldata orderIds) external;

    // Order execution
    function fillOrder(bytes calldata data, address recipient) external;
    function fillOrder(bytes calldata data, address callback, address initiator, address recipient) external;

    // Queries
    function getOrders(uint256[] calldata ids) external view returns (Order[] memory);
    function quote(uint256 id, bytes[] calldata reports) external returns (bytes memory, OrderValidation memory);
    function getOrderTokens(uint256[] calldata ids) external view returns (OrderTokens[] memory);

    // Token management
    function getTokenProps(address token) external view returns (TokenProps memory);
    function setTokenProps(address token, bytes32 priceFeed, bool isStakable) external;
}

event CreateOrder(
    uint256 indexed orderId,
    address indexed creator,
    address recipient,
    address tokenIn,
    address tokenOut,
    uint256 spendAmount,
    uint256 repeats,
    uint256 freqInterval,
    uint256 scalingInterval,
    uint256 slippage,
    uint256 firstExecution,
    bool stakeAssetIn,
    bool stakeAssetOut
);

event FillOrder(
    uint256 indexed orderId,
    address caller,
    address recipient,
    uint256 fillAmount,
    uint256 amountOfTokenOut,
    uint256 protocolFee,
    uint256 tokenInPrice,
    uint256 tokenOutPrice
);

event CancelOrder(
    uint256 orderId,
    address vault
);

event SetTokenProps(
    address indexed token,
    bytes32 feed,
    uint8 tokenDecimals,
    bool isActive,
    bool isStakable
);

// Order Errors
error OrderDoesNotExist();          // Invalid order ID
error OrderNotActive();             // Order completed or cancelled
error NotOrderCreator();            // Only creator can cancel
error PriorToOrderExecution();      // Too early to fill

// Token Errors
error TokenNotActive();             // Token not supported
error TokenNotStakable();           // Token can't be staked
error No FeedID on Order();         // Missing price feed

// Parameter Errors
error InvalidSlippage();            // Slippage out of bounds
error InvalidFrequencyInterval();   // Frequency too low
error InvalidScalingInterval();     // Scaling interval too high
error InvalidFirstExecution();      // First execution in past

// Execution Errors
error InvalidPriceReports();        // Bad oracle data
error FeedTooStale();              // Price data too old
error TimestampTolerance();        // Feed timestamp mismatch
error MinimumExecutionValue();     // Order too small

// Permission Errors
error CreateOrderPaused();         // Creation paused
error FillOrderPaused();          // Filling paused
error Paused();                   // Protocol paused

modifier nonReentrant() {
    _guardCounter += 1;
    uint256 localCounter = _guardCounter;
    _;
    require(localCounter == _guardCounter);
}

modifier whenOrderCreateNotPaused() {
    if (isCreateOrderPaused) revert CreateOrderPaused();
    _;
}

modifier whenOrderFillNotPaused() {
    if (isFillOrderPaused) revert FillOrderPaused();
    _;
}

// 1. Approve tokens
IERC20(tokenIn).approve(dcaDotFun, totalAmount);

// 2. Prepare order arguments
OrderArgs memory args = OrderArgs({
    recipient: msg.sender,
    tokenIn: USDC,
    tokenOut: WETH,
    spendAmount: 100e6, // 100 USDC
    repeats: 52, // Weekly for a year
    freqInterval: 7 days,
    scalingInterval: 1 days,
    slippage: 100, // 1%
    firstExecution: 0,
    stakeAssetIn: true,
    stakeAssetOut: false
});

// 3. Create order
uint256 orderId = dcaDotFun.createOrder(args, priceReports);

// 1. Get quote from API
bytes memory encodedData = getQuoteFromAPI(orderId);

// 2. Fill order
dcaDotFun.fillOrder(encodedData, msg.sender);

contract MyFiller is IFillOrderCallback {
    function fillWithCallback(bytes calldata encodedData) external {
        dcaDotFun.fillOrder(
            encodedData,
            address(this), // callback
            msg.sender,     // initiator
            msg.sender      // recipient
        );
    }

    function fillOrderCallback(
        address tokenOut,
        uint256 amountOfTokenOut,
        address initiator
    ) external returns (bool) {
        // Custom logic here
        // 1. Receive tokenIn from protocol
        // 2. Execute swap on DEX
        // 3. Approve tokenOut to protocol
        return true;
    }
}