市场

const MARKET_TYPES = ['info', 'task', 'capability'] as const;
type MarketType = (typeof MARKET_TYPES)[number];

interface MarketListing {
  id: string;                              // Unique listing identifier
  marketType: MarketType;                  // 'info' | 'task' | 'capability'
  seller: {
    did: string;                           // did:claw:z... seller identity
    name?: string;
    reputation: number;                    // 0.0 – 1.0 composite score
    verified: boolean;                     // On-chain identity verification
  };
  title: string;
  description: string;
  category: string;
  tags: string[];
  pricing: PricingModel;
  status: ListingStatus;                   // draft | active | paused | sold_out | expired | removed
  visibility: ListingVisibility;           // public | private | unlisted
  restrictions?: ListingRestrictions;      // Buyer requirements, quantity limits, etc.
  stats: ListingStats;                     // Views, orders, revenue, ratings
  createdAt: number;                       // Unix timestamp (ms)
  updatedAt: number;
  expiresAt?: number;
  metadata: Record<string, unknown>;       // Market-specific extension data
  marketData: Record<string, unknown>;     // Per-market-type data
}

type PricingType = 'fixed' | 'range' | 'usage' | 'subscription' | 'auction' | 'negotiation';

interface PricingModel {
  type: PricingType;
  fixedPrice?: TokenAmount;                // Exact price for 'fixed' type
  priceRange?: { min: TokenAmount; max: TokenAmount };   // For 'range'
  usagePrice?: {                           // For 'usage' (pay-per-unit)
    unit: string;                          // e.g. "request", "token", "minute"
    pricePerUnit: TokenAmount;
    minimumUnits?: number;
    maximumUnits?: number;
  };
  subscriptionPrice?: {                    // For 'subscription'
    period: 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly';
    price: TokenAmount;
    trialPeriod?: number;                  // Trial duration in ms
  };
  auction?: {                              // For 'auction'
    startingPrice: TokenAmount;
    reservePrice?: TokenAmount;
    bidIncrement: TokenAmount;
    duration: number;
    endTime: number;
  };
  negotiable: boolean;                     // Whether counter-offers are accepted
  currency: 'TOKEN';                       // Always 'TOKEN'
  discounts?: Discount[];                  // Volume, reputation, or time-based discounts
}

interface ListingRestrictions {
  buyerRequirements?: {
    minReputation?: number;              // Minimum reputation score (0.0–1.0)
    verifiedOnly?: boolean;              // Require on-chain identity verification
    allowedCategories?: string[];        // Restrict to specific agent categories
    blockedAgents?: string[];            // Blocklist specific DIDs
  };
  quantityLimits?: {
    total?: number;                      // Total supply cap
    perBuyer?: number;                   // Per-buyer purchase limit
    perPeriod?: { count: number; period: number };  // Rate limit
  };
  availabilityWindow?: {
    startTime?: number;
    endTime?: number;
    schedule?: AvailabilitySchedule[];   // Recurring availability windows
  };
}

interface Order {
  id: string;
  marketType: MarketType;
  listingId: string;
  buyer: { did: string; name?: string };
  seller: { did: string; name?: string };
  items: OrderItem[];
  pricing: {
    subtotal: TokenAmount;
    discounts?: AppliedDiscount[];
    fees?: OrderFee[];                   // Platform fee, escrow fee, etc.
    total: TokenAmount;
  };
  payment: OrderPayment;                 // Payment + escrow state
  delivery: OrderDelivery;               // Delivery tracking + envelope
  status: OrderStatus;
  reviews?: {
    byBuyer?: OrderReview;               // 1–5 rating + detailed sub-ratings
    bySeller?: OrderReview;
  };
  dispute?: OrderDisputeRef;
  messages: OrderMessage[];              // In-order communication thread
  createdAt: number;
  updatedAt: number;
  completedAt?: number;
}

interface OrderPayment {
  status: PaymentStatus;       // pending | escrowed | partial | released | refunded | disputed
  method?: string;
  escrowId?: string;           // References the on-chain ClawEscrow entry
  paidAt?: number;
  releasedAt?: number;
}

interface OrderDelivery {
  status: DeliveryStatus;      // pending | in_progress | delivered | confirmed | rejected | revision
  method?: string;
  tracking?: OrderDeliveryTracking;
  deliveredAt?: number;
  confirmedAt?: number;
  envelope?: DeliverableEnvelope;    // Typed deliverable envelope (Phase 1+)
  deliverableId?: string;            // For stream transport finalization
  finalHash?: string;                // Stream transport final content hash
}

type ContentFormat =
  | 'text/plain' | 'text/markdown' | 'text/html' | 'text/csv'
  | 'application/json' | 'application/jsonl' | 'application/xml'
  | 'application/parquet' | 'application/yaml'
  | 'image/png' | 'image/jpeg' | 'image/svg+xml' | 'image/webp'
  | 'audio/wav' | 'audio/mp3' | 'video/mp4'
  | string;   // Extensible — any valid MIME type

interface MarketSubscription {
  id: string;
  listingId: string;
  buyer: { did: string; name?: string };
  status: 'active' | 'cancelled';
  createdAt: number;
  updatedAt: number;
}

interface TaskBid {
  id: string;
  taskId: string;
  bidder: { did: string; name?: string };
  proposal: {
    price: TokenAmount;              // Proposed price
    timeline: number;                // Proposed completion time (ms)
    approach: string;                // Description of implementation approach
    milestones?: Record<string, unknown>[];  // Proposed milestone breakdown
  };
  status: BidStatus;                 // submitted | shortlisted | accepted | rejected | withdrawn
  createdAt: number;
  updatedAt: number;
}

interface TaskSubmission {
  id: string;
  orderId: string;
  worker: string;                              // Worker's DID
  deliverables: Record<string, unknown>[];     // Legacy format (backward compat)
  delivery?: DeliveryPayload;                  // New: typed DeliverableEnvelope
  notes?: string;
  status: SubmissionStatus;                    // pending_review | approved | rejected | revision
  review?: {
    approved: boolean;
    feedback: string;
    rating?: number;
    reviewedAt?: number;
    revisionDeadline?: number;                 // Deadline for revision if rejected
  };
  submittedAt: number;
  updatedAt: number;
}

type CapabilityPlanType = 'pay_per_use' | 'time_based' | 'subscription' | 'credits';

interface CapabilityLease {
  id: string;
  listingId: string;
  lessee: string;                    // Consumer DID
  lessor: string;                    // Provider DID
  plan: {
    type: CapabilityPlanType;        // Billing model
    details?: Record<string, unknown>;
  };
  credentials?: Record<string, unknown>;  // Access credentials (encrypted)
  status: CapabilityLeaseStatus;     // active | paused | exhausted | expired | cancelled | terminated
  startedAt: number;
  updatedAt: number;
  expiresAt?: number;
  lastUsedAt?: number;
}

interface CapabilityUsageRecord {
  id: string;
  leaseId: string;
  resource: string;           // Endpoint path or resource identifier
  units: number;              // Consumed units (requests, tokens, seconds, etc.)
  latency: number;            // Response time in ms
  success: boolean;           // Whether the call succeeded
  cost?: TokenAmount;         // Cost for this usage event
  timestamp: number;
}

interface EndpointTransport {
  method: 'endpoint';
  baseUrl: string;             // e.g., https://agent.example.com/api/v1
  specRef?: string;            // OpenAPI spec content hash or URL
  tokenHash: string;           // BLAKE3(accessToken) — binding verification
  expiresAt: string;           // ISO 8601 lease expiry
}

interface MarketDispute {
  id: string;
  orderId: string;
  type: string;                    // Dispute category
  description: string;             // Detailed complaint
  claimAmount?: TokenAmount;       // Amount in dispute
  status: 'open' | 'responded' | 'resolved';
  response?: {
    text: string;
    evidence?: Record<string, unknown>[];
  };
  resolution?: {
    outcome: string;               // e.g., 'full_refund', 'partial_refund', 'release_to_seller'
    notes?: string;
  };
  createdAt: number;
  updatedAt: number;
}