Smart Orchestration

The Backpac Engine does not rely on simple rotations. It enforces Institutional Guardrails through a suite of Orchestration Intelligence models.

This ensures your Institutional Entry Points maintain a high-fidelity signal path. Every request is an obligation. We fulfill it with deterministic precision.

---

Orchestration Matrix

Objective	Model	Engine Logic
Equilibrium	Standard Rotation	Sequential distribution across healthy pools.
Integrity	Method Capability Awareness	Auto-detection of -32601 to bypass unsupported RPC methods.
Throughput	Capacity Weighting	Steering based on pool-specific throughput limits.
Performance	Latency Optimization	Real-time routing to the lowest possible latency head.
Consistency	Stateful Pinning	Deterministic address-to-pool pinning for state sanctity.
Solana Fidelity	Solana Health Scoring	Freshness penalties and protocol-level error avoidance.
EVM Integrity	Block Freshness	Mandatory block height alignment for read accuracy.
Extreme Resilience	Probabilistic Failover	Markov-chain transition modeling for cluster degradation.
Geographic Speed	Region Aware	Worker-to-pool proximity enforcement.
Regulatory Compliance	Region Aware	Jurisdiction-locked routing for data residency and the GENIUS Act.

---

Intelligence Models

1. Standard Equilibrium (Baseline)

The foundential model. It distributes traffic evenly across all Reliability Pools marked as healthy by the Engine's circuit breakers.

• Value: Ensures uniform utilization. No single pool becomes a bottleneck.
• Automated Capability Discovery: The Engine automatically learns if a pool lacks support for specific RPC methods (via -32601 detection) and adjusts routing transparently.
• Best Use Case: General-purpose traffic where providers are homogeneous.

2. Capacity Weighting

Allows for authoritative steering toward specific infrastructure based on institutional capacity.

• Value: Resource Optimization. Direct 90% of traffic to your private node cluster for cost control, while maintaining a 10% spillover to premium DIN providers.
• Engine Logic: Enforces traffic ratios (e.g., 9:1) with clock-cycle precision.

3. Latency-First Routing

Optimizes for the speed of light. The Engine measures the round-trip time for every request across the mesh.

• Value: Elite UX. Essential for front-end execution where milliseconds are the difference between success and friction.
• Engine Logic: Maintains real-time latency moving averages. Periodically "sensors" nodes to anticipate performance shifts.

4. Stateful Pinning (State Sanctity)

Ensures that sequential operations from a specific address hit the same Reliability Pool.

• Value: Settlement Certainty. Eliminates "Transaction Not Found" errors. If you send a transaction to Pool A, you must read its state from Pool A.
• Engine Logic: Pins sessions via the x-backpac-sender header or payload address detection.
• Rule: See the Data Sanctity guide for the governing protocols.

5. Solana Health Scoring

A specialized model for the speed and volatility of Solana.

• Value: Trading Dominance. Ensures you never route to a node lagging behind the cluster tip.
• Engine Logic:
  • Slot Drift: Immediately penalizes nodes falling behind the network majority.
  • Error Penalization: Dynamically scores and avoids nodes with high internal failure rates.

6. Block Freshness (EVM)

Prevents stale data reads. If a node is behind, it is dead to the Engine.

• Value: Financial Truth. Critical for liquidators and indexers requiring absolute block alignment.
• Engine Logic: Continually polls eth_blockNumber. Nodes exceeding the "Freshness Threshold" are automatically purged from the routing list.

7. Probabilistic Failover (Markov Chain)

A self-learning model that predicts node success based on historical transition probabilities.

• Value: Ultimate Resilience. During total network degradation, the Engine finds the most likely path to success.
• Engine Logic: Builds a transition matrix of success paths. It learns how nodes fail in tandem and avoids "cascading degradation" chains.

8. Region Aware

Enforces jurisdiction-locked routing for regulatory compliance and geographic performance.

• Value: Regulatory Certainty. Guarantees that RPC traffic never leaves customer-authorized geographic boundaries. Essential for compliance with the GENIUS Act of 2025, EU data residency mandates, and institutional data sovereignty requirements.
• Engine Logic: The strategy maintains an explicit Allowed Regions list configured on the Reliability Pool. Every healthy node is filtered against this list before selection. Only nodes whose metadata.region matches an authorized region are eligible for traffic.
• Dynamic Provider Support: Works with both Sovereign (BYO) endpoints and dynamically resolved DIN providers. The Engine evaluates the region metadata of every node in the pool at routing time, regardless of how the node was discovered.
• Configuration: Customers define their authorized regions via algorithm_config.allowed_regions on their Reliability Pool. When no regions are configured, the system defaults to the worker's physical deployment region.
• Strict Compliance Mode: When fallbackToAnyRegion is disabled, the Engine will reject requests rather than route to a non-compliant region. This provides a mathematically provable guarantee that data never crosses jurisdictional boundaries.

Example Configuration

An EU-regulated stablecoin issuer configures their Reliability Pool with:

{
  "algorithm_type": "region_aware",
  "algorithm_config": {
    "allowed_regions": ["eu-west", "eu-central"]
  }
}

All RPC traffic is confined to EU infrastructure — regardless of which global worker processes the request.

---

Implementation Guide

Institutional Objective	Selection
Standard Wallet Activity	Stateful Pinning
DeFi Execution / Minting	Solana Health Scoring or Latency-First
Institutional Indexing	Block Freshness (EVM)
High-Scale API Performance	Region Aware + Latency-First
Cost & Capacity Control	Capacity Weighting
Regulatory Compliance (GENIUS Act, EU Data Residency)	Region Aware
Stablecoin Issuance Infrastructure	Region Aware + Stateful Pinning