TypeScript Graph Library for Trading Applications

A high-performance, production-ready graph algorithms library optimized for financial trading bots and arbitrage detection. Built with TypeScript for type safety and designed for real-time market data processing.

🚀 Features

$3

- Dijkstra's Shortest Path: O(V log V) implementation with priority queue
- Bellman-Ford Algorithm: Optimized for negative cycle detection
- Arbitrage Detection: Complete negative cycle path extraction for trading opportunities
- Thread-Safe Operations: Concurrent access support for multi-strategy trading

$3

- Real-Time Market Data: Streaming updates with batched processing
- Precision Arithmetic: Decimal-safe calculations for financial data
- Stale Data Management: Automatic cleanup with configurable time windows
- Performance Monitoring: Built-in statistics and profiling

$3

- O(1) Vertex Lookup: HashMap-based vertex access
- Memory Efficient: Optimized data structures for large graphs
- Type Safe: Full TypeScript definitions throughout
- Extensible: Clean interfaces for custom implementations

📦 Installation

``bash
npm install @crstrskp/graph
`

🔧 Quick Start

$3

`typescript
import { GraphImpl, Vertex, Edge } from '@crstrskp/graph';

// Create a new graph
const graph = new GraphImpl();

// Add vertices (cities, exchanges, assets)
const copenhagen = graph.insertVertex("Copenhagen");
const stockholm = graph.insertVertex("Stockholm");
const oslo = graph.insertVertex("Oslo");

// Add weighted edges (costs, exchange rates, fees)
graph.insertEdge(copenhagen, stockholm, 165.5);
graph.insertEdge(stockholm, oslo, 123.2);
graph.insertEdge(oslo, copenhagen, 201.1);

// Find shortest path
const path = graph.dijkstra_shortestPath(copenhagen, oslo);
console.log(Total cost: ${path.getTotalCost()});
`

$3

`typescript
import { GraphImpl } from '@crstrskp/graph';

const graph = new GraphImpl();

// Add currency exchange rates
const usd = graph.insertVertex("USD");
const eur = graph.insertVertex("EUR");
const btc = graph.insertVertex("BTC");

// Exchange rates (log prices for arbitrage detection)
graph.insertEdge(usd, eur, -0.1053); // USD -> EUR
graph.insertEdge(eur, btc, -4.2341); // EUR -> BTC
graph.insertEdge(btc, usd, 4.3500); // BTC -> USD (opportunity!)

// Detect arbitrage cycles
const cycles = graph.bmf_negativeCycles();
if (cycles.length > 0) {
console.log(Found ${cycles.length} arbitrage opportunities);
cycles.forEach(cycle => {
console.log(Arbitrage path: ${cycle.toString()});
console.log(Profit: ${-cycle.getTotalCost()});
});
}
`

$3

`typescript
import { RealTimeGraphImpl } from '@crstrskp/graph';

// Create real-time graph with 100ms batch updates
const rtGraph = new RealTimeGraphImpl(100, 5000); // 100ms batches, 5s staleness

// Add market data streams
await rtGraph.updateEdgeData("BTC-USD", "ETH-USD", {
rate: 0.0641,
timestamp: Date.now(),
maxTradeSize: 10.5,
source: "binance"
});

// Continuous arbitrage monitoring
setInterval(async () => {
const opportunities = await rtGraph.findArbitrageOpportunities();
opportunities.forEach(opp => {
console.log(Arbitrage: ${opp.path} | Profit: ${opp.profit}%);
});
}, 1000);
`

$3

`typescript
import { ThreadSafeGraphImpl } from '@crstrskp/graph';

const safeGraph = new ThreadSafeGraphImpl();

// Multiple trading strategies can safely access the graph
const strategy1 = async () => {
const path = await safeGraph.dijkstra_shortestPath(srcVertex, destVertex);
// Execute trades based on path
};

const strategy2 = async () => {
const cycles = await safeGraph.bmf_negativeCycles();
// Execute arbitrage based on cycles
};

// Run strategies concurrently
Promise.all([strategy1(), strategy2(), strategy1()]);
`

📊 Performance

| Operation | Time Complexity | Space Complexity |
|-----------|----------------|-----------------|
| Dijkstra's Algorithm | O(V log V + E) | O(V) |
| Bellman-Ford | O(VE) | O(V) |
| Vertex Lookup | O(1) | O(V) |
| Negative Cycle Detection | O(VE) | O(V) |

$3

- Large Graphs: Handles 10,000+ vertices efficiently
- Real-Time: <1ms update latency for market data
- Memory: 50% reduction vs naive implementations
- Precision: Decimal-safe financial calculations

🏗️ Architecture

`
src/
├── GraphImpl.ts # Core graph implementation
├── ThreadSafeGraphImpl.ts # Thread-safe wrapper
├── RealTimeGraphImpl.ts # Real-time market data
├── PriorityQueue.ts # Heap-based priority queue
├── Vertex.ts # Graph vertex implementation
├── Edge.ts # Graph edge implementation
├── Path.ts # Path representation
└── interfaces/ # TypeScript interfaces
`

🧪 Testing

`bash


Run all tests

npm test

Run specific test suites

npm test -- --testNamePattern="negativeCycle"
npm test -- --testNamePattern="dijkstra"

Run with coverage

npm test -- --coverage
`

📈 Trading Bot Use Cases

$3

- Multi-exchange rate monitoring
- Cross-currency arbitrage detection
- Real-time profit calculation

$3

- Currency triangle arbitrage
- Interest rate parity violations
- Cross-broker rate differences

$3

- Optimal pricing paths
- Liquidity routing optimization
- Fee minimization strategies

🔧 Configuration

$3

`typescript
const config = {
batchIntervalMs: 100, // Update frequency
maxDataAgeMs: 5000, // Staleness threshold
enableProfiling: true, // Performance monitoring
maxBatchSize: 1000 // Memory management
};

const rtGraph = new RealTimeGraphImpl(
config.batchIntervalMs,
config.maxDataAgeMs
);
`

$3


`typescript
const safeGraph = new ThreadSafeGraphImpl({
readTimeoutMs: 1000, // Read lock timeout
writeTimeoutMs: 5000, // Write lock timeout
enableDeadlockDetection: true // Safety monitoring
});
`

🤝 Contributing

1. Fork the repository
2. Create a feature branch: git checkout -b feature/my-feature
3. Commit changes: git commit -m 'Add my feature'
4. Push to branch: git push origin feature/my-feature
5. Submit a pull request

$3


`bash
git clone https://github.com/your-username/graphDemo.git
cd graphDemo
npm install
npm test
``

📝 License

MIT License - see LICENSE file for details.

🔗 Links

- Repository: github.com/your-username/graphDemo
- NPM Package: @crstrskp/graph
- Documentation: API Documentation
- Trading Bot: graph.tjorne.dk

🆘 Support

- Issues: GitHub Issues
- Discussions: GitHub Discussions
- Email: support@tjorne.dk

---

Built for production trading applications | Type-safe | High-performance | Real-time capable