ArbiLoop

ArbiLoop – Full-Stack DeFi Risk & Yield Execution System

ArbiLoop is a full-stack DeFi execution and risk intelligence platform built for Arbitrum users who actively lend, borrow, and run leveraged loop strategies across Aave and Radiant.

DeFi users are typically forced to split decision-making across multiple protocol interfaces, manually track health factors, and react too late when liquidation risk rises. ArbiLoop eliminates this fragmentation by turning isolated protocol interactions into a continuous control system that integrates execution, monitoring, analytics, and automated alerts.

Product Layer – Unified Execution & Risk Control

ArbiLoop provides a single interface where users can:

• Discover protocol-aware yield opportunities

• Execute lending and loop strategies

• Monitor real-time health factors

• Take immediate corrective actions (repay debt, add collateral)

The system is built around actionable safety. It does not just display data — it reduces the time between risk detected and risk mitigated, which is the critical operational gap in leveraged DeFi.

Smart Contract Layer – Deterministic Execution Vault

ArbiLoop uses a dedicated on-chain execution vault (ArbiLoopVaultArbitrum) as the strategy orchestrator.

The vault architecture enforces:

• Deterministic Aave and Radiant execution routes

• Strict parameter validation

• Guarded external protocol interactions

• Explicit approval management

• Reentrancy protection

Execution flow:

validate inputs  
→ pull user assets  
→ approve protocol contracts  
→ execute supply/borrow loop  
→ settle balances  
→ return execution outputs

This explicit call structure reduces unsafe behavior surface area and keeps strategy execution predictable for users and auditors.

Data & Intelligence Layer – Real-Time + Historical State

ArbiLoop combines live on-chain reads with indexed historical analytics.

Real-time layer:

• Health factor tracking

• Immediate UI risk states

• Monitoring triggers

Historical indexer:

• Processes Aave/Radiant events (Supply, Withdraw, Borrow, Repay)

• Normalizes token metadata and USD values

• Builds wallet-level realized PnL state

• Stores persistent analytics tables

This enables:

• Historical PnL charts

• Activity timelines

• Trend-based strategy refinement

Users move beyond temporary wallet snapshots to persistent performance intelligence.

Automation Layer – Telegram Risk Delivery

ArbiLoop integrates Telegram for always-on monitoring.

Users:

• Verify wallet via signed-message authentication

• Configure alert thresholds

• Set polling intervals

Backend worker:

• Continuously evaluates wallet health

• Applies cooldown logic to prevent alert spam

• Sends liquidation-risk alerts

• Publishes optional daily portfolio summaries

• Records alerts in Supabase for traceability

Frontend and messaging remain synchronized and auditable.

Infrastructure Stack

• Next.js – execution UX, analytics dashboards, risk controls

• Solidity Vault – deterministic protocol orchestration

• Supabase – users, alerts, event indexing, PnL state

• Telegram Worker – monitoring and automation backend

• Arbitrum-native protocol integrations

Core Innovation – A Closed-Loop Risk System

ArbiLoop is not a dashboard.

It is a closed-loop control system:

Wallet action
→ On-chain execution
→ Indexed state
→ Risk engine evaluation
→ Alert trigger
→ User remediation
→ Back to execution

This transforms passive monitoring into an active risk operating system.

Why Arbitrum

Arbitrum’s low fees and fast confirmations make frequent risk adjustments economically viable. Small collateral top-ups, debt repayments, and strategy rotations are practical — not cost-prohibitive.

Combined with deep lending liquidity and mature infrastructure, Arbitrum enables both capital efficiency and operational safety.

We built ArbiLoop as a complete DeFi execution and risk system with four layers:

An on-chain execution vault, a strategy/risk frontend, a Supabase data plane, and a Telegram automation backend.

At the smart contract layer, we designed and deployed ArbiLoopVaultArbitrum as the transaction orchestrator for leveraged lending flows. The vault architecture

is centered on protocol-specific execution entrypoints (Aave and Radiant paths), strict parameter validation, approval management, and guarded external calls. The

control model follows a deterministic sequence: validate route and amounts, pull user funds, approve protocol contracts, execute supply/borrow loop actions, then

settle remaining balances and emit stateful outcomes for the UI. We implemented reentrancy protection and updated value-transfer patterns to avoid deprecated

transfer/send behavior and reduce execution risk.

On the frontend, we built end-to-end user control surfaces for dashboard monitoring, lending/borrowing views, strategy discovery, execution modals, and risk intervention actions. Strategy cards are fully actionable, not placeholders, and route users into execution flows tied to the deployed vault.

We added health/ risk visualization, transaction timeline UX, and actionable “fix risk now”buttons (repay/add collateral) to shorten reaction time when positions deteriorate.

For data architecture, we implemented Supabase schemas and policies for users, alerts, event indexing, and PnL tables. We created live liquidation_alerts

ingestion and polling so the landing and risk modules show real feed data instead of static UI content

For analytics, we implemented a historical indexer pipeline that scans Aave/Radiant events (Supply/Deposit, Withdraw, Borrow, Repay) in block ranges, normalizes token

metadata and USD values, stores canonical activity rows, and rebuilds wallet-level realized PnL state (wallet_pnl_positions, wallet_pnl_daily). This powers charted historical

PnL and health analytics directly in the app.

For automation, we built Telegram bot flows for /id, /verify, /status, /setalert, /setinterval, /togglealerts, and /disconnect. Wallet linking uses signed-message verification and

address recovery before writing user settings. We then implemented a continuous monitoring worker that periodically reads on-chain account health, evaluates per-user

thresholds/cooldowns, sends risk alerts, and stores every alert event in Supabase for both telemetry and frontend rendering. A periodic PnL indexer runner was integrated into

backend operations so historical analytics stay updated without manual intervention.

End result: ArbiLoop now runs as an integrated system where execution,monitoring, alerting, and analytics are connected by a clear control flow from wallet action -> contract execution -> indexed state -> risk evaluation -> user notification -> UI feedback loop.

Bootstrapped project. Current focus is product validation, user onboarding, and reliability at low operating cost.