Execution Architecture
Safe, Scalable, Deterministic.
Intent Submission (Client-side)
Input: Unstructured user intent Example: “Swap 1 SOL on Solana → 10 USDT on Ethereum”
Output: Abstract intent object, passed to Vortex
Route Discovery — Vortex (Offchain Service)
Parses the user intent into possible execution flows
Discovers viable paths via bridges, DEXs, liquidity endpoints
Estimates gas costs, slippage bounds, approval requirements, and steps per route
Output: Structured route candidates (with steps, metadata, gas, approval context).
Next: Sends to Umbra for structural validation and Echo for Offchain Reputation Score.
Structural Filtering — Umbra (Offchain Rule Engine)
Screens route candidates for known malicious contract patterns and unsafe behaviors
Detects:
Honeypots
Approval drainers
Malicious proxies
Taxed tokens
Self-destruct logic
Reentrancy patterns
Output: Filtered list of safe routes.
Next: Annotated and passed to Echo for contextual scoring.
Behavioral Scoring — Echo (Offchain Reputation Engine)
Adds real-time metadata to each route
Aggregates:
Verified exploit reports
Admin key activity (e.g. emergency pauses, suspicious upgrades)
Social sentiment (filtered for spam/bots)
Historical incident logs
Mechanism: ML heuristics, offchain signals, no bytecode analysis
Output: Risk-weighted route annotations (optional for UI, not enforced)
Next: Passes validated route + metadata to SafeSwitch
Note: Echo's scoring is non-blocking by default. It flags risk, but does not prevent execution unless configured to.
Fallback Logic — SafeSwitch (Route-level Metadata)
Attaches fallback paths to each primary route during pre-signing
Each fallback is:
→ Pre-discovered and pre-validated
→ Fully signed by the user
→ Structurally equivalent in security level
Fallback triggers include:
→ Bridge failure or downtime
→ Slippage breach
→ Pool liquidity unavailability
→Runtime contract reverts or unexpected gas cost
Output: Executable route packet:
{primary, fallback[], metadata}
Next: Sent to the client for final signing
Route Signing (Client-side)
The user signs the execution packet, including:
→ Primary route
→ One or more fallback paths
→ All safety constraints (preconditions, limits, timeouts)
Note: Execution will not proceed unless all safety layers are passed
Output: Signed execution payload, ready for onchain execution
Onchain Execution — GravCore (Smart Contract)
Accepts signed execution packet from the user
Enforces:
→ Precondition validation before each step
→ Fallback activation logic at runtime
→ Deterministic execution under varying network conditions
Key traits:
→ Non-custodial — never holds user funds
→ Runtime-aware — can halt, reroute, or revert safely
→ Permissionless — cannot execute anything not pre-signed
Output: Final state change across chains — only if route passes all checks
Fallback Activation — SafeSwitch + GravCore
If a runtime condition is breached, GravCore triggers the fallback route:
→ Automatically, without re-signature
→ Using pre-approved logic signed during step 6
→ Ensuring no loss of funds, gas, or execution control
Fallbacks are:
→ Deterministic
→ Auditable
→ Executed onchain with the same enforcement as the primary path
Post-Execution Feedback — Umbra Learning Loop
Umbra collects execution data to evolve threat detection:
→ Frequently reverting contracts
→ Abnormal gas usage
→ Missed fallback triggers
→ New scam token patterns
Mechanism: Feedback loop → pattern engine enrichment
No manual curation required — Umbra improves autonomously over time
Trust Model
Vortex
Path builder
❌
Stateless logic
Umbra
Structural firewall
❌
Rule-based
Echo
Reputation scoring
❌
Informational
SafeSwitch
Fallback logic, pre-approved
Partial
Signed by user
Blackhole Executor
Deterministic executor
✅
Trustless
Only GravCore executes, and only after all other systems have validated or annotated the path.
Umbra blocks danger, Echo flags context, SafeSwitch rescues failure, GravCore executes truth.
Summary
Blackhole transforms raw DeFi intents into execution-safe, fallback-aware, reputationally-informed transactions — enforced onchain.
Every route can:
→ Be inspected
→ Be filtered
→ Be scored
→ Fail safely
→ Improve future threat detection
No more "best effort" routing. No more trusting blind execution. Just validated, modular, and recoverable execution — from intent to finality.
Last updated