Interacting with GX Core

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
 
interface IGxOracle {
    /// @notice Get the oracle price for a perpetual asset
    /// @param assetIndex The perpetual asset index (0 = BTC, 1 = ETH, etc.)
    /// @return price The oracle price scaled to 8 decimal places
    /// @return timestamp The timestamp of the price update
    function getPrice(uint256 assetIndex) external view returns (uint256 price, uint256 timestamp);
 
    /// @notice Get oracle prices for multiple assets in one call
    /// @param assetIndices Array of asset indices
    /// @return prices Array of prices
    /// @return timestamps Array of timestamps
    function getPrices(uint256[] calldata assetIndices)
        external view returns (uint256[] memory prices, uint256[] memory timestamps);
}
 
// Usage
contract MyStrategy {
    IGxOracle constant oracle = IGxOracle(address(0x100));
 
    function getBtcPrice() external view returns (uint256) {
        (uint256 price, ) = oracle.getPrice(0); // BTC = index 0
        return price; // e.g., 6743250000000 = $67,432.50 (8 decimals)
    }
}

interface IGxMarkets {
    struct MarketInfo {
        string name;
        uint8 szDecimals;
        uint32 maxLeverage;
        bool onlyIsolated;
        bool isActive;
    }
 
    function getMarket(uint256 assetIndex) external view returns (MarketInfo memory);
    function getMarketCount() external view returns (uint256);
}

interface IGxPositions {
    struct Position {
        int256 size;       // Positive = long, negative = short (scaled by szDecimals)
        uint256 entryPx;   // Entry price (8 decimals)
        uint256 margin;     // Margin allocated (8 decimals)
        int256 unrealizedPnl; // Current unrealized PnL (8 decimals)
    }
 
    function getPosition(address user, uint256 assetIndex)
        external view returns (Position memory);
 
    function getAccountValue(address user) external view returns (uint256);
    function getWithdrawable(address user) external view returns (uint256);
}

interface IGxBridge {
    /// @notice Deposit USDC from EVM to GX Core trading account
    /// @param amount Amount in USDC (6 decimals)
    function depositToCore(uint256 amount) external;
 
    /// @notice Withdraw USDC from GX Core to EVM
    /// @param amount Amount in USDC (6 decimals)
    function withdrawFromCore(uint256 amount) external;
 
    /// @notice Get the USDC balance on GX Core for an address
    function coreBalance(address user) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
 
interface IGxOracle {
    function getPrice(uint256 assetIndex) external view returns (uint256 price, uint256 timestamp);
}
 
interface IGxPositions {
    struct Position {
        int256 size;
        uint256 entryPx;
        uint256 margin;
        int256 unrealizedPnl;
    }
    function getPosition(address user, uint256 assetIndex) external view returns (Position memory);
    function getAccountValue(address user) external view returns (uint256);
}
 
contract LiquidationMonitor {
    IGxOracle constant oracle = IGxOracle(address(0x100));
    IGxPositions constant positions = IGxPositions(address(0x102));
 
    event LiquidationCandidate(address indexed user, uint256 assetIndex, uint256 accountValue);
 
    function checkLiquidation(address user, uint256 assetIndex) external view returns (bool) {
        uint256 accountValue = positions.getAccountValue(user);
        IGxPositions.Position memory pos = positions.getPosition(user, assetIndex);
 
        if (pos.size == 0) return false;
 
        // Check if account value is below maintenance margin
        uint256 absSize = pos.size > 0 ? uint256(pos.size) : uint256(-pos.size);
        (uint256 price, ) = oracle.getPrice(assetIndex);
        uint256 notional = (absSize * price) / 1e8;
        uint256 maintenanceMargin = notional / 20; // 5% maintenance
 
        return accountValue < maintenanceMargin;
    }
}