hip-0008

HIP-8: HMM (Hanzo Market Maker) - Native DEX for AI Compute Resources. Status Draft. Hanzo's own standard — read this before implementing against it.

HIP-0008: HMM (Hanzo Market Maker) - Native DEX for AI Compute Resources

Abstract

This proposal specifies the HMM (Hanzo Market Maker), a native decentralized exchange built on Hanzo's sovereign L1 blockchain (launching as L2 on Lux) for trading AI compute resources. HMM enables a liquid marketplace for GPU time, model inference, training slots, and other AI resources with dynamic pricing, instant settlement, and cross-chain accessibility.

Specification

Core Architecture

class HMMExchange:
    """
    Hanzo Market Maker - DEX for AI compute resources
    """
    def __init__(self):
        self.resource_pools = {}  # Liquidity pools for compute types
        self.order_book = OrderBook()
        self.pricing_engine = DynamicPricingEngine()
        self.quality_oracle = QualityMetricsOracle()
        self.settlement_layer = InstantSettlement()

Resource Types

Tradeable Compute Resources

GPU Compute:
  - Inference: Real-time model inference (tokens/second)
  - Training: Batch training slots (GPU-hours)
  - Fine-tuning: Dedicated fine-tuning resources
  - Memory: VRAM allocation (GB-hours)

Model Access:
  - HLLM Inference: Access to Hamiltonian models
  - Custom Models: User-deployed model endpoints
  - Embeddings: Vector generation services
  - Agents: Autonomous agent runtime

Storage & Data:
  - Model Storage: Persistent model hosting
  - Dataset Storage: Training data repositories
  - Vector DBs: Embedding storage and retrieval
  - Checkpoints: Training state persistence

Market Mechanisms

Automated Market Making (AMM)

class ComputeAMM:
    """
    Constant product AMM for compute resources
    """
    def get_price(self, pool, amount_in, resource_type):
        """
        x * y = k pricing formula adapted for compute
        """
        reserve_compute = pool.compute_reserves[resource_type]
        reserve_hanzo = pool.hanzo_reserves
        
        # Apply constant product formula
        k = reserve_compute * reserve_hanzo
        new_compute = reserve_compute - amount_in
        new_hanzo = k / new_compute
        
        price = new_hanzo - reserve_hanzo
        
        # Apply quality multiplier
        quality_score = self.oracle.get_quality(resource_type)
        adjusted_price = price * quality_score
        
        return adjusted_price

Order Book Model

class OrderBook:
    """
    Traditional order book for limit orders
    """
    def __init__(self):
        self.bids = PriorityQueue()  # Buy orders
        self.asks = PriorityQueue()  # Sell orders
        
    def place_order(self, order_type, resource, amount, price):
        order = Order(
            type=order_type,
            resource=resource,
            amount=amount,
            price=price,
            timestamp=now()
        )
        
        if order_type == "BID":
            self.bids.add(order)
        else:
            self.asks.add(order)
            
        self.match_orders()

Liquidity Provision

Resource Pools

class ResourcePool:
    """
    Liquidity pool for specific compute resource
    """
    def __init__(self, resource_type):
        self.resource_type = resource_type
        self.compute_reserves = 0  # Available compute units
        self.hanzo_reserves = 0    # HANZO tokens in pool
        self.lp_tokens = {}        # Liquidity provider shares
        
    def add_liquidity(self, provider, compute_amount, hanzo_amount):
        # Calculate LP tokens based on pool share
        if self.total_lp_tokens == 0:
            lp_tokens = sqrt(compute_amount * hanzo_amount)
        else:
            lp_tokens = min(
                compute_amount * self.total_lp_tokens / self.compute_reserves,
                hanzo_amount * self.total_lp_tokens / self.hanzo_reserves
            )
        
        self.lp_tokens[provider] += lp_tokens
        self.compute_reserves += compute_amount
        self.hanzo_reserves += hanzo_amount
        
        return lp_tokens

Quality Metrics & Pricing

Performance Oracle

class QualityMetricsOracle:
    """
    Tracks and reports compute quality metrics
    """
    def __init__(self):
        self.metrics = {
            "latency": {},      # Response time
            "throughput": {},   # Tokens/second
            "availability": {}, # Uptime percentage
            "accuracy": {}      # Model performance
        }
        
    def update_metrics(self, provider, metrics):
        # Rolling average of performance metrics
        for metric, value in metrics.items():
            self.metrics[metric][provider] = (
                0.7 * self.metrics[metric].get(provider, value) +
                0.3 * value
            )
    
    def calculate_quality_score(self, provider):
        # Weighted quality score 0-1
        weights = {
            "latency": 0.3,
            "throughput": 0.3,
            "availability": 0.2,
            "accuracy": 0.2
        }
        
        score = sum(
            self.metrics[metric].get(provider, 0.5) * weight
            for metric, weight in weights.items()
        )
        
        return score

Settlement & Execution

Instant Settlement Layer

class InstantSettlement:
    """
    Sub-second settlement for compute trades
    """
    def settle_trade(self, buyer, seller, resource, amount, price):
        # Atomic swap
        with atomic_transaction():
            # Transfer HANZO from buyer to seller
            self.transfer_hanzo(buyer, seller, price)
            
            # Allocate compute resource
            allocation = self.allocate_compute(
                provider=seller,
                consumer=buyer,
                resource=resource,
                amount=amount
            )
            
            # Create access token
            access_token = self.create_access_token(
                allocation=allocation,
                expires=now() + duration(amount)
            )
            
            return access_token

Cross-Chain Bridge

contract HMMBridge {
    mapping(address => uint256) public pendingCompute;
    
    function bridgeFromEthereum(
        uint256 amount,
        bytes32 resourceType
    ) external payable {
        // Lock ETH/tokens
        require(msg.value >= getPrice(amount, resourceType));
        
        // Emit event for Hanzo L2
        emit ComputeRequested(
            msg.sender,
            amount,
            resourceType,
            block.timestamp
        );
        
        // Hanzo L2 monitors and allocates compute
        pendingCompute[msg.sender] = amount;
    }
}

Economic Model

Fee Structure

Trading Fees:
  - Taker: 0.3% of trade value
  - Maker: 0.1% of trade value
  - LP Rewards: 0.2% to liquidity providers

Quality Incentives:
  - Performance Bonus: +50% fees for top 10% quality
  - Penalty: -50% fees for bottom 10% quality
  - Slashing: Remove from pools for consistent poor performance

Volume Discounts:
  - Tier 1 (>1000 HANZO/month): 10% discount
  - Tier 2 (>10000 HANZO/month): 20% discount
  - Tier 3 (>100000 HANZO/month): 30% discount

Token Utility

HANZO token uses in HMM:

Trading: Buy/sell compute resources
Liquidity: Provide liquidity to pools
Governance: Vote on pool parameters
Staking: Stake for fee discounts
Quality: Stake as quality collateral