NAC_Blockchain/charter-std/defi/marketplace.ch

///! # 去中心化交易市场
///!
///! Decentralized Marketplace
///! 提供订单簿、撮合引擎和交易功能
///!
///! **版本**: v1.0
///! **模块**: charter-std/defi/marketplace.ch

use utils::math::{safe_mul, safe_div, safe_add, safe_sub};
use utils::crypto::sha3_384_hash;

// ============================================================================
// 订单类型枚举
// ============================================================================

/// 订单类型
pub enum OrderType {
    /// 限价单
    Limit,
    
    /// 市价单
    Market
}

/// 订单方向
pub enum OrderSide {
    /// 买入
    Buy,
    
    /// 卖出
    Sell
}

/// 订单状态
pub enum OrderStatus {
    /// 待成交
    Open,
    
    /// 部分成交
    PartiallyFilled,
    
    /// 完全成交
    Filled,
    
    /// 已取消
    Cancelled,
    
    /// 已过期
    Expired
}

// ============================================================================
// 订单结构
// ============================================================================

/// 订单
struct Order {
    /// 订单ID
    order_id: Hash,
    
    /// 交易对ID
    pair_id: Hash,
    
    /// 订单类型
    order_type: OrderType,
    
    /// 订单方向
    side: OrderSide,
    
    /// 下单者
    maker: Address,
    
    /// 基础资产（要卖出的）
    base_asset: Address,
    
    /// 报价资产（要买入的）
    quote_asset: Address,
    
    /// 价格（报价资产/基础资产）
    price: u256,
    
    /// 数量（基础资产数量）
    amount: u256,
    
    /// 已成交数量
    filled_amount: u256,
    
    /// 订单状态
    status: OrderStatus,
    
    /// 创建时间
    created_at: Timestamp,
    
    /// 过期时间（可选）
    expires_at: Option<Timestamp>,
    
    /// 手续费率（基点）
    fee_rate: u16
}

/// 交易记录
struct Trade {
    /// 交易ID
    trade_id: Hash,
    
    /// 交易对ID
    pair_id: Hash,
    
    /// 买单ID
    buy_order_id: Hash,
    
    /// 卖单ID
    sell_order_id: Hash,
    
    /// 买方
    buyer: Address,
    
    /// 卖方
    seller: Address,
    
    /// 成交价格
    price: u256,
    
    /// 成交数量
    amount: u256,
    
    /// 成交时间
    timestamp: Timestamp,
    
    /// 买方手续费
    buyer_fee: u256,
    
    /// 卖方手续费
    seller_fee: u256
}

/// 交易对
struct TradingPair {
    /// 交易对ID
    pair_id: Hash,
    
    /// 基础资产
    base_asset: Address,
    
    /// 报价资产
    quote_asset: Address,
    
    /// 最新价格
    last_price: u256,
    
    /// 24小时最高价
    high_24h: u256,
    
    /// 24小时最低价
    low_24h: u256,
    
    /// 24小时成交量
    volume_24h: u256,
    
    /// 是否激活
    is_active: bool
}

// ============================================================================
// 市场事件
// ============================================================================

/// 订单创建事件
event OrderCreated {
    order_id: Hash,
    pair_id: Hash,
    maker: Address,
    side: OrderSide,
    price: u256,
    amount: u256,
    timestamp: Timestamp
}

/// 订单取消事件
event OrderCancelled {
    order_id: Hash,
    maker: Address,
    timestamp: Timestamp
}

/// 交易成交事件
event TradeExecuted {
    trade_id: Hash,
    pair_id: Hash,
    buyer: Address,
    seller: Address,
    price: u256,
    amount: u256,
    timestamp: Timestamp
}

/// 订单成交事件
event OrderFilled {
    order_id: Hash,
    filled_amount: u256,
    remaining_amount: u256,
    timestamp: Timestamp
}

// ============================================================================
// 去中心化交易市场
// ============================================================================

/// 去中心化交易市场
certificate DecentralizedMarketplace {
    /// 订单存储 (order_id => order)
    let _orders: Map<Hash, Order>;
    
    /// 交易记录 (trade_id => trade)
    let _trades: Map<Hash, Trade>;
    
    /// 交易对 (pair_id => trading_pair)
    let _pairs: Map<Hash, TradingPair>;
    
    /// 用户订单索引 (user => order_ids)
    let _user_orders: Map<Address, Vec<Hash>>;
    
    /// 交易对订单簿 - 买单 (pair_id => orders sorted by price desc)
    let _buy_orders: Map<Hash, Vec<Hash>>;
    
    /// 交易对订单簿 - 卖单 (pair_id => orders sorted by price asc)
    let _sell_orders: Map<Hash, Vec<Hash>>;
    
    /// 用户资产余额 (user => asset => amount)
    let _balances: Map<Address, Map<Address, u256>>;
    
    /// 管理员地址
    let _admin: Address;
    
    /// 默认手续费率（基点，例如30表示0.3%）
    let _default_fee_rate: u16;
    
    /// 手续费收取地址
    let _fee_recipient: Address;
    
    // ========== 构造函数 ==========
    
    constructor(fee_rate: u16, fee_recipient: Address) {
        require(fee_rate <= 1000, "Fee rate too high"); // 最高10%
        require(!fee_recipient.is_zero(), "Invalid fee recipient");
        
        self._admin = msg.sender;
        self._default_fee_rate = fee_rate;
        self._fee_recipient = fee_recipient;
    }
    
    // ========== 交易对管理 ==========
    
    /// 创建交易对
    ///
    /// # 参数
    /// - `base_asset`: 基础资产地址
    /// - `quote_asset`: 报价资产地址
    ///
    /// # 返回
    /// - `Hash`: 交易对ID
    pub fn create_pair(
        base_asset: Address,
        quote_asset: Address
    ) -> Hash {
        require(msg.sender == self._admin, "Only admin");
        require(!base_asset.is_zero(), "Invalid base asset");
        require(!quote_asset.is_zero(), "Invalid quote asset");
        require(base_asset != quote_asset, "Assets must be different");
        
        // 生成交易对ID
        let pair_id = self._generate_pair_id(base_asset, quote_asset);
        require(!self._pairs.contains_key(pair_id), "Pair already exists");
        
        let pair = TradingPair {
            pair_id: pair_id,
            base_asset: base_asset,
            quote_asset: quote_asset,
            last_price: 0,
            high_24h: 0,
            low_24h: 0,
            volume_24h: 0,
            is_active: true
        };
        
        self._pairs[pair_id] = pair;
        self._buy_orders[pair_id] = Vec::new();
        self._sell_orders[pair_id] = Vec::new();
        
        return pair_id;
    }
    
    /// 获取交易对信息
    ///
    /// # 参数
    /// - `pair_id`: 交易对ID
    ///
    /// # 返回
    /// - `TradingPair`: 交易对信息
    pub fn get_pair(pair_id: Hash) -> TradingPair {
        require(self._pairs.contains_key(pair_id), "Pair not found");
        return self._pairs[pair_id];
    }
    
    // ========== 资产存取 ==========
    
    /// 存入资产
    ///
    /// # 参数
    /// - `asset`: 资产地址
    /// - `amount`: 数量
    ///
    /// # 返回
    /// - `bool`: 是否成功
    pub fn deposit(asset: Address, amount: u256) -> bool {
        require(!asset.is_zero(), "Invalid asset");
        require(amount > 0, "Amount must be positive");
        
        // 实际实现需要调用资产合约的transferFrom
        // 这里简化处理
        
        if !self._balances.contains_key(msg.sender) {
            self._balances[msg.sender] = Map::new();
        }
        
        let current_balance = self._balances[msg.sender].get(asset).unwrap_or(0);
        self._balances[msg.sender][asset] = safe_add(current_balance, amount);
        
        return true;
    }
    
    /// 提取资产
    ///
    /// # 参数
    /// - `asset`: 资产地址
    /// - `amount`: 数量
    ///
    /// # 返回
    /// - `bool`: 是否成功
    pub fn withdraw(asset: Address, amount: u256) -> bool {
        require(!asset.is_zero(), "Invalid asset");
        require(amount > 0, "Amount must be positive");
        
        let balance = self.get_balance(msg.sender, asset);
        require(balance >= amount, "Insufficient balance");
        
        self._balances[msg.sender][asset] = safe_sub(balance, amount);
        
        // 实际实现需要调用资产合约的transfer
        
        return true;
    }
    
    /// 获取余额
    ///
    /// # 参数
    /// - `user`: 用户地址
    /// - `asset`: 资产地址
    ///
    /// # 返回
    /// - `u256`: 余额
    pub fn get_balance(user: Address, asset: Address) -> u256 {
        return self._balances.get(user)
            .and_then(|m| m.get(asset))
            .unwrap_or(0);
    }
    
    // ========== 订单管理 ==========
    
    /// 创建限价单
    ///
    /// # 参数
    /// - `pair_id`: 交易对ID
    /// - `side`: 订单方向
    /// - `price`: 价格
    /// - `amount`: 数量
    /// - `expires_at`: 过期时间（可选）
    ///
    /// # 返回
    /// - `Hash`: 订单ID
    pub fn create_limit_order(
        pair_id: Hash,
        side: OrderSide,
        price: u256,
        amount: u256,
        expires_at: Option<Timestamp>
    ) -> Hash {
        require(self._pairs.contains_key(pair_id), "Pair not found");
        require(price > 0, "Price must be positive");
        require(amount > 0, "Amount must be positive");
        
        let pair = self._pairs[pair_id];
        require(pair.is_active, "Pair not active");
        
        if let Some(expiry) = expires_at {
            require(expiry > block.timestamp, "Invalid expiry time");
        }
        
        // 检查余额
        let required_asset = match side {
            OrderSide::Buy => pair.quote_asset,
            OrderSide::Sell => pair.base_asset
        };
        
        let required_amount = match side {
            OrderSide::Buy => safe_mul(price, amount) / 1e18, // 价格 * 数量
            OrderSide::Sell => amount
        };
        
        let balance = self.get_balance(msg.sender, required_asset);
        require(balance >= required_amount, "Insufficient balance");
        
        // 生成订单ID
        let order_id = self._generate_order_id(msg.sender, pair_id);
        
        let order = Order {
            order_id: order_id,
            pair_id: pair_id,
            order_type: OrderType::Limit,
            side: side,
            maker: msg.sender,
            base_asset: pair.base_asset,
            quote_asset: pair.quote_asset,
            price: price,
            amount: amount,
            filled_amount: 0,
            status: OrderStatus::Open,
            created_at: block.timestamp,
            expires_at: expires_at,
            fee_rate: self._default_fee_rate
        };
        
        self._orders[order_id] = order;
        
        // 添加到用户订单索引
        if !self._user_orders.contains_key(msg.sender) {
            self._user_orders[msg.sender] = Vec::new();
        }
        self._user_orders[msg.sender].push(order_id);
        
        // 添加到订单簿
        match side {
            OrderSide::Buy => self._add_buy_order(pair_id, order_id, price),
            OrderSide::Sell => self._add_sell_order(pair_id, order_id, price)
        }
        
        emit OrderCreated {
            order_id: order_id,
            pair_id: pair_id,
            maker: msg.sender,
            side: side,
            price: price,
            amount: amount,
            timestamp: block.timestamp
        };
        
        // 尝试撮合
        self._match_orders(pair_id);
        
        return order_id;
    }
    
    /// 创建市价单
    ///
    /// # 参数
    /// - `pair_id`: 交易对ID
    /// - `side`: 订单方向
    /// - `amount`: 数量
    ///
    /// # 返回
    /// - `Hash`: 订单ID
    pub fn create_market_order(
        pair_id: Hash,
        side: OrderSide,
        amount: u256
    ) -> Hash {
        require(self._pairs.contains_key(pair_id), "Pair not found");
        require(amount > 0, "Amount must be positive");
        
        let pair = self._pairs[pair_id];
        require(pair.is_active, "Pair not active");
        
        // 市价单使用最新价格
        let price = pair.last_price;
        require(price > 0, "No market price available");
        
        // 生成订单ID
        let order_id = self._generate_order_id(msg.sender, pair_id);
        
        let order = Order {
            order_id: order_id,
            pair_id: pair_id,
            order_type: OrderType::Market,
            side: side,
            maker: msg.sender,
            base_asset: pair.base_asset,
            quote_asset: pair.quote_asset,
            price: price,
            amount: amount,
            filled_amount: 0,
            status: OrderStatus::Open,
            created_at: block.timestamp,
            expires_at: None,
            fee_rate: self._default_fee_rate
        };
        
        self._orders[order_id] = order;
        
        emit OrderCreated {
            order_id: order_id,
            pair_id: pair_id,
            maker: msg.sender,
            side: side,
            price: price,
            amount: amount,
            timestamp: block.timestamp
        };
        
        // 立即撮合
        self._match_market_order(order_id);
        
        return order_id;
    }
    
    /// 取消订单
    ///
    /// # 参数
    /// - `order_id`: 订单ID
    ///
    /// # 返回
    /// - `bool`: 是否成功
    pub fn cancel_order(order_id: Hash) -> bool {
        require(self._orders.contains_key(order_id), "Order not found");
        
        let mut order = self._orders[order_id];
        require(order.maker == msg.sender, "Not the maker");
        require(
            order.status == OrderStatus::Open || 
            order.status == OrderStatus::PartiallyFilled,
            "Cannot cancel"
        );
        
        order.status = OrderStatus::Cancelled;
        self._orders[order_id] = order;
        
        // 从订单簿移除
        self._remove_from_orderbook(order_id);
        
        emit OrderCancelled {
            order_id: order_id,
            maker: msg.sender,
            timestamp: block.timestamp
        };
        
        return true;
    }
    
    /// 获取订单
    ///
    /// # 参数
    /// - `order_id`: 订单ID
    ///
    /// # 返回
    /// - `Order`: 订单信息
    pub fn get_order(order_id: Hash) -> Order {
        require(self._orders.contains_key(order_id), "Order not found");
        return self._orders[order_id];
    }
    
    /// 获取用户订单
    ///
    /// # 参数
    /// - `user`: 用户地址
    ///
    /// # 返回
    /// - `Vec<Hash>`: 订单ID列表
    pub fn get_user_orders(user: Address) -> Vec<Hash> {
        return self._user_orders.get(user).unwrap_or(Vec::new());
    }
    
    // ========== 订单簿查询 ==========
    
    /// 获取买单列表
    ///
    /// # 参数
    /// - `pair_id`: 交易对ID
    /// - `limit`: 数量限制
    ///
    /// # 返回
    /// - `Vec<Order>`: 买单列表
    pub fn get_buy_orders(pair_id: Hash, limit: u256) -> Vec<Order> {
        let order_ids = self._buy_orders.get(pair_id).unwrap_or(Vec::new());
        let mut orders = Vec::new();
        
        let count = if limit > 0 && limit < order_ids.len() as u256 {
            limit as usize
        } else {
            order_ids.len()
        };
        
        for i in 0..count {
            if let Some(order) = self._orders.get(order_ids[i]) {
                orders.push(order);
            }
        }
        
        return orders;
    }
    
    /// 获取卖单列表
    ///
    /// # 参数
    /// - `pair_id`: 交易对ID
    /// - `limit`: 数量限制
    ///
    /// # 返回
    /// - `Vec<Order>`: 卖单列表
    pub fn get_sell_orders(pair_id: Hash, limit: u256) -> Vec<Order> {
        let order_ids = self._sell_orders.get(pair_id).unwrap_or(Vec::new());
        let mut orders = Vec::new();
        
        let count = if limit > 0 && limit < order_ids.len() as u256 {
            limit as usize
        } else {
            order_ids.len()
        };
        
        for i in 0..count {
            if let Some(order) = self._orders.get(order_ids[i]) {
                orders.push(order);
            }
        }
        
        return orders;
    }
    
    // ========== 内部函数 ==========
    
    /// 生成交易对ID
    fn _generate_pair_id(base_asset: Address, quote_asset: Address) -> Hash {
        let mut data = Bytes::new();
        data.extend(base_asset.as_bytes());
        data.extend(quote_asset.as_bytes());
        return sha3_384_hash(data);
    }
    
    /// 生成订单ID
    fn _generate_order_id(maker: Address, pair_id: Hash) -> Hash {
        let mut data = Bytes::new();
        data.extend(maker.as_bytes());
        data.extend(pair_id.as_bytes());
        data.extend(block.timestamp.to_bytes());
        data.extend(tx.hash.as_bytes());
        return sha3_384_hash(data);
    }
    
    /// 添加买单到订单簿（按价格降序）
    fn _add_buy_order(pair_id: Hash, order_id: Hash, price: u256) {
        let mut orders = self._buy_orders[pair_id];
        
        // 找到插入位置（价格降序）
        let mut insert_pos = orders.len();
        for i in 0..orders.len() {
            if let Some(existing_order) = self._orders.get(orders[i]) {
                if price > existing_order.price {
                    insert_pos = i;
                    break;
                }
            }
        }
        
        orders.insert(insert_pos, order_id);
        self._buy_orders[pair_id] = orders;
    }
    
    /// 添加卖单到订单簿（按价格升序）
    fn _add_sell_order(pair_id: Hash, order_id: Hash, price: u256) {
        let mut orders = self._sell_orders[pair_id];
        
        // 找到插入位置（价格升序）
        let mut insert_pos = orders.len();
        for i in 0..orders.len() {
            if let Some(existing_order) = self._orders.get(orders[i]) {
                if price < existing_order.price {
                    insert_pos = i;
                    break;
                }
            }
        }
        
        orders.insert(insert_pos, order_id);
        self._sell_orders[pair_id] = orders;
    }
    
    /// 从订单簿移除订单
    fn _remove_from_orderbook(order_id: Hash) {
        let order = self._orders[order_id];
        
        match order.side {
            OrderSide::Buy => {
                let mut orders = self._buy_orders[order.pair_id];
                orders.retain(|&id| id != order_id);
                self._buy_orders[order.pair_id] = orders;
            },
            OrderSide::Sell => {
                let mut orders = self._sell_orders[order.pair_id];
                orders.retain(|&id| id != order_id);
                self._sell_orders[order.pair_id] = orders;
            }
        }
    }
    
    /// 撮合订单
    fn _match_orders(pair_id: Hash) {
        let buy_orders = self._buy_orders.get(pair_id).unwrap_or(Vec::new());
        let sell_orders = self._sell_orders.get(pair_id).unwrap_or(Vec::new());
        
        if buy_orders.len() == 0 || sell_orders.len() == 0 {
            return;
        }
        
        // 获取最高买价和最低卖价
        let best_buy_id = buy_orders[0];
        let best_sell_id = sell_orders[0];
        
        let buy_order = self._orders[best_buy_id];
        let sell_order = self._orders[best_sell_id];
        
        // 检查是否可以成交（买价 >= 卖价）
        if buy_order.price >= sell_order.price {
            self._execute_trade(best_buy_id, best_sell_id);
            
            // 递归撮合
            self._match_orders(pair_id);
        }
    }
    
    /// 撮合市价单
    fn _match_market_order(order_id: Hash) {
        let order = self._orders[order_id];
        
        let opposite_orders = match order.side {
            OrderSide::Buy => self._sell_orders.get(order.pair_id).unwrap_or(Vec::new()),
            OrderSide::Sell => self._buy_orders.get(order.pair_id).unwrap_or(Vec::new())
        };
        
        if opposite_orders.len() == 0 {
            return;
        }
        
        // 与最优价格成交
        let opposite_id = opposite_orders[0];
        
        match order.side {
            OrderSide::Buy => self._execute_trade(order_id, opposite_id),
            OrderSide::Sell => self._execute_trade(opposite_id, order_id)
        }
    }
    
    /// 执行交易
    fn _execute_trade(buy_order_id: Hash, sell_order_id: Hash) {
        let mut buy_order = self._orders[buy_order_id];
        let mut sell_order = self._orders[sell_order_id];
        
        // 计算成交数量（取较小值）
        let buy_remaining = safe_sub(buy_order.amount, buy_order.filled_amount);
        let sell_remaining = safe_sub(sell_order.amount, sell_order.filled_amount);
        let trade_amount = if buy_remaining < sell_remaining {
            buy_remaining
        } else {
            sell_remaining
        };
        
        // 成交价格（使用卖单价格）
        let trade_price = sell_order.price;
        
        // 计算手续费
        let buyer_fee = safe_mul(trade_amount, buy_order.fee_rate as u256) / 10000;
        let seller_fee = safe_mul(trade_amount, sell_order.fee_rate as u256) / 10000;
        
        // 生成交易ID
        let trade_id = self._generate_trade_id(buy_order_id, sell_order_id);
        
        // 创建交易记录
        let trade = Trade {
            trade_id: trade_id,
            pair_id: buy_order.pair_id,
            buy_order_id: buy_order_id,
            sell_order_id: sell_order_id,
            buyer: buy_order.maker,
            seller: sell_order.maker,
            price: trade_price,
            amount: trade_amount,
            timestamp: block.timestamp,
            buyer_fee: buyer_fee,
            seller_fee: seller_fee
        };
        
        self._trades[trade_id] = trade;
        
        // 更新订单状态
        buy_order.filled_amount = safe_add(buy_order.filled_amount, trade_amount);
        sell_order.filled_amount = safe_add(sell_order.filled_amount, trade_amount);
        
        if buy_order.filled_amount == buy_order.amount {
            buy_order.status = OrderStatus::Filled;
            self._remove_from_orderbook(buy_order_id);
        } else {
            buy_order.status = OrderStatus::PartiallyFilled;
        }
        
        if sell_order.filled_amount == sell_order.amount {
            sell_order.status = OrderStatus::Filled;
            self._remove_from_orderbook(sell_order_id);
        } else {
            sell_order.status = OrderStatus::PartiallyFilled;
        }
        
        self._orders[buy_order_id] = buy_order;
        self._orders[sell_order_id] = sell_order;
        
        // 更新余额
        self._settle_trade(trade);
        
        // 更新交易对统计
        self._update_pair_stats(buy_order.pair_id, trade_price, trade_amount);
        
        emit TradeExecuted {
            trade_id: trade_id,
            pair_id: buy_order.pair_id,
            buyer: buy_order.maker,
            seller: sell_order.maker,
            price: trade_price,
            amount: trade_amount,
            timestamp: block.timestamp
        };
    }
    
    /// 生成交易ID
    fn _generate_trade_id(buy_order_id: Hash, sell_order_id: Hash) -> Hash {
        let mut data = Bytes::new();
        data.extend(buy_order_id.as_bytes());
        data.extend(sell_order_id.as_bytes());
        data.extend(block.timestamp.to_bytes());
        return sha3_384_hash(data);
    }
    
    /// 结算交易
    fn _settle_trade(trade: Trade) {
        // 买方支付报价资产，获得基础资产
        // 卖方支付基础资产，获得报价资产
        
        // 实际实现需要更新余额映射
        // 这里简化处理
    }
    
    /// 更新交易对统计
    fn _update_pair_stats(pair_id: Hash, price: u256, volume: u256) {
        let mut pair = self._pairs[pair_id];
        
        pair.last_price = price;
        
        if price > pair.high_24h {
            pair.high_24h = price;
        }
        
        if pair.low_24h == 0 || price < pair.low_24h {
            pair.low_24h = price;
        }
        
        pair.volume_24h = safe_add(pair.volume_24h, volume);
        
        self._pairs[pair_id] = pair;
    }
}