vendor-implementation

Implement Yuan framework exchange integrations with TypeScript service modules.

351|53|Updated Jul 20, 2023
One-click install
npx skills add https://github.com/No-Trade-No-Life/Yuan --skill vendor-implementation
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: vendor-implementation
Source: https://github.com/No-Trade-No-Life/Yuan/tree/main/.claude/skills/vendor-implementation
Command: npx skills add https://github.com/No-Trade-No-Life/Yuan --skill vendor-implementation

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires @yuants/cache, @yuants/data-order.

What problem does it solve?

This Skill provides a structured, battle-tested framework for integrating new cryptocurrency exchanges into the Yuan platform. It eliminates the guesswork and reduces the complexity of building robust financial system integrations, ensuring consistency, adherence to best practices, and faster time-to-market for new exchange support.

Core Features & Use Cases

  • Standardized Integration: Guides the creation of new exchange vendor implementations following a proven directory structure and core patterns, based on successful integrations like Hyperliquid and OKX.
  • Core Financial Services: Covers essential features such as account information (spot, perpetual), comprehensive order management (submit, cancel, modify, list), and critical market data (quotes, OHLC, product info).
  • Quality & Performance: Emphasizes TypeScript strictness, comprehensive error handling, efficient caching (createCache), API rate limiting, and robust testing to ensure reliable and performant integrations.
  • Use Case: Rapidly onboard a new exchange (e.g., "Binance Futures") to the Yuan trading platform, ensuring all critical trading functionalities are correctly implemented and documented according to established standards, allowing your system to access new markets quickly.

Quick Start

I need to integrate a new exchange called 'TradeX'. Guide me through setting up the directory structure and implementing the core account and order management services.

Frequently Asked Questions about vendor-implementation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I integrate a new cryptocurrency exchange into the Yuan platform?

Integrate a new exchange by following Yuan's standardized framework: set up the vendor directory structure, implement TypeScript-based service modules for accounts and orders, create API clients for market data, apply caching via @yuants/cache, and expose RPC endpoints. This ensures consistency with proven patterns from exchanges like Hyperliquid and OKX.

What core financial services must I implement for exchange vendor integration?

Core services include account management (spot and perpetual balances), comprehensive order operations (submit, cancel, modify, list), and market data feeds (quotes, OHLC, product info). Each service integrates with Yuan's microservice architecture and must handle errors robustly and cache efficiently.

Can I use TypeScript with microservices for building exchange integrations?

Yes. The vendor-implementation Skill uses TypeScript strictness as a foundation for microservice architectures, API integration layers, and trading functionalities. This approach ensures type safety, reliable error handling, and compliance with Yuan framework standards across distributed services.

What dependencies do I need to set up exchange vendor services?

You need @yuants/cache for efficient data caching and @yuants/data-order for order management operations. These dependencies provide the foundational components for building compliant exchange vendor implementations within the Yuan ecosystem.

How does caching and rate limiting improve exchange API integration?

Exchange integrations apply caching via createCache to reduce redundant API calls and implement rate limiting to respect vendor quotas. Together, these optimizations ensure performant, reliable integrations that avoid throttling and reduce latency for market data and order operations.

What happens after I complete the core exchange vendor implementation?

After implementation, expose RPC endpoints for service consumption, run comprehensive testing to validate all trading functionalities, and deploy the vendor module to enable platform access to the new exchange's markets and liquidity.