Chrono
Chrono is a time-based lending protocol on the Flow blockchain, transforming DeFi by making duration a core element of borrowing. Made by integrating Scheduled Transactions by Flow with Defi lending.
Video
Sự miêu tả
# Chrono Protocol Documentation
DeFi Lending Protocol
Full documentation available at (https://chronolabs.gitbook.io/chronolabs-docs).
Developed by ChronoLabs | Powered by ArcaneStudio | Built on Flow
Chrono is a time-based DeFi lending protocol designed to enhance borrowing flexibility while managing risk through temporal constraints. This document provides a comprehensive overview of the protocol's design, functionality, and benefits. It is structured to guide users, developers, and researchers through the protocol's core concepts and implementation details.
Last updated: November 1, 2025
For quick navigation:
* [Introduction](#introduction)
* [Why Chrono?](#why-chrono)
* [Why Flow Blockchain?](#why-flow-blockchain)
* [Overview](#overview)
* [Key Features](#key-features)
* [How It Works](#how-it-works)
* [Interest Rate Model](#interest-rate-model)
* [Liquidation Mechanisms](#liquidation-mechanisms)
* [Problems Solved](#problems-solved)
* [Architecture and Technologies Used](#architecture-and-technologies-used)
* [Risks and Considerations](#risks-and-considerations)
* [Use Cases](#use-cases)
* [Getting Started](#getting-started)
* [Community and Governance](#community-and-governance)
## Introduction
Chrono is a decentralized lending protocol that introduces time as a core parameter in borrowing mechanics, bridging the gap between instantaneous flash loans and open-ended generic borrows. Built on the Flow blockchain and written in the Cadence programming language, Chrono allows users to borrow assets with predefined time limits, offering dynamic loan-to-value (LTV) ratios and interest rates tailored to the borrow duration. This approach rewards shorter-term borrows with higher leverage while enforcing strict penalties for expirations and lenient ones for pre-expiry liquidations, promoting responsible usage and reducing systemic risk.
The protocol aims to make DeFi lending more adaptable to real-world use cases, such as short-term arbitrage or medium-term yield farming, without the extremes of flash loans (zero duration, high fees) or traditional borrows (indefinite duration, conservative LTVs). By leveraging Flow's native features like Scheduled Transactions, Chrono ensures reliable, autonomous time-based executions, setting it apart from other lending protocols.
Key Audience Guidance:
* For Everyday Users: Chrono simplifies borrowing by letting you specify a time horizon, unlocking better terms for predictable needs while protecting lenders through automated enforcements.
* For Builders: The modular design allows integration with existing DeFi ecosystems, with customizable parameters for LTV curves, interest models, and liquidation thresholds.
* For Liquidity Investors: High interest rates on shorter time-bound borrows drive better yields from increased utilization.
* For Advanced DeFi Users: Leverage dynamic LTVs and time-parameterized interest for optimized strategies, such as high-leverage short-term trades or volatility hedging, with precise duration controls to minimize liquidation exposure in complex market conditions.
## Why Chrono?
In a DeFi landscape dominated by either ultra-short flash loans or indefinite-term borrows, Chrono fills a critical gap by introducing user-defined time limits. This time-based differentiator allows borrowers to access higher LTVs (up to 90% for short durations) based on reduced volatility assumptions, while lenders benefit from enforced expirations that limit long-term exposure. Unlike generic protocols, Chrono's temporal mechanics enable tailored strategies—e.g., hour-long arbitrage with minimal interest or day-long yield positions with balanced risk—making DeFi more efficient and accessible. Users need Chrono for its unique blend of flexibility, capital efficiency, and accountability, reducing the risks of over-leverage and indefinite defaults that plague traditional lending.
## Why Flow Blockchain?
Flow is integral to Chrono's design, providing the foundation for secure and reliable time-based lending. Traditional blockchains like Ethereum struggle with time-dependent operations due to vulnerabilities in timestamps, reliance on external keepers, and MEV exploits. Flow's native Scheduled Transactions enable autonomous, on-chain execution at predefined times or intervals, eliminating these issues and allowing Chrono to enforce borrow limits without off-chain dependencies. Additionally, Cadence's resource-oriented programming (with linear typing) ensures atomic state management, preventing common DeFi exploits like reentrancy. Chrono requires Flow to deliver its core innovation—precise, tamper-resistant time mechanics—while benefiting from Flow's scalability, low fees, and DeFi-focused automation tools.
Flow-Specific Advantages:
* Scheduled Transactions: Automatic expiry enforcement.
* Secure Timestamps: Manipulation-resistant time tracking.
* Cadence Safety: Reentrancy-proof by design.
* MEV Resistance: Fair execution for all users.
* Low Fees: Affordable for any position size.
## Overview
Chrono operates as a Cadence-based implementation that incorporates time-based innovations via Flow's Scheduled Transactions. Users supply collateral and borrow assets by setting a time limit (e.g., hours or days), after which the borrow must be repaid or face punitive measures. The protocol adjusts LTV and interest rates based on this limit, assuming shorter durations correlate with lower market volatility.
Core Components:
* Time-Dependent LTV: Higher LTV (up to 90%) for short durations, tapering to standard levels (e.g., 75%) for longer ones. Specific tiers:
- 1 hour: Up to 90% LTV (10× leverage)
- 12 hours: Up to 87% LTV (7.7× leverage)
- 1 day: Up to 84% LTV (6.25× leverage)
- 7 days: Up to 75% LTV (4× leverage)
* Adaptive Interest Rate Model (IRM): Time-proportional rates, charging only for the duration used.
* Dual Liquidation System: Lenient liquidations during the active period; strict via Stability Pools upon expiry.
* Health Factor Monitoring: Time-adjusted thresholds for leniency.
* Scheduled Executions: Powered by Flow for autonomous triggers on expirations and liquidations.
The protocol is deployed on Flow mainnet (with testnet availability) and uses smart contracts for all operations, ensuring transparency and auditability.
## Key Features
* Time-Limited Borrows: Users specify a duration (e.g., 1 hour to 7 days) at initiation, enabled by Flow's Scheduled Transactions for automatic enforcement.
* Dynamic LTV Calculation: LTV scales with duration, starting high for short terms and decreasing for longer ones, calibrated via governance.
* Time-Influenced IRM: Rates adjust proportionally with utilization and time, favoring shorter borrows.
* Lenient Pre-Expiry Liquidations: Collateral handled at a discount until health exceeds time-dependent threshold.
* Punitive Expiry Mechanism: Stability Pools triggered autonomously via scheduling.
* Oracle Integration: Uses Flow-native oracles (e.g., DIA or Supra) for prices and volatility.
* Governance: Token-based DAO for tuning parameters.
## How It Works
Chrono follows a lending flow enhanced by Flow's scheduling.
### Supplying Liquidity
1. Lenders deposit assets into pools, earning interest based on utilization.
2. Assets become available for borrowing, with no time constraints on supply.
### Borrowing Process
1. User supplies collateral (e.g., FLOW) and requests a borrow (e.g., USDC).
2. Specify a time limit t (e.g., 24 hours).
3. Protocol calculates LTV(t) based on predefined tiers.
4. Borrow approved if collateral meets requirements; a Scheduled Transaction is set for expiry handling.
5. Interest accrues via time-adjusted IRM.
6. User repays before t, or protocol auto-triggers expiry logic.
### Repayment
* Repay anytime before t.
* Partial repayments adjust health dynamically.
### Monitoring
* Health factor checked on-chain.
* If health < 1 before expiry, trigger soft liquidation via scheduled checks.
## Interest Rate Model
Time-proportional model, with hourly rates applied based on actual duration:
* Borrowers pay only for the time needed (e.g., 1-hour borrow = hourly rate only).
* Rates adjust with utilization; longer terms incur proportionally higher costs.
* Parameters: Governance-tunable, calibrated with volatility data.
* Approach: Ensures cost-effective short borrows; implemented in Cadence for secure execution.
## Liquidation Mechanisms
Bifurcated, leveraging Flow's scheduling:
* Pre-Expiry: Lenient liquidation sells through Stability Pools until health > threshold (time-dependent).
* Post-Expiry: Scheduled Transaction auto-initiates Stability Pools to cancel debt, distributing collateral fairly.
Why Stability Pools?
* Faster Liquidations: Instant execution vs. auctions.
* Resilience During Market Crashes: Fair, efficient distribution.
This provides nuance: user-friendly during the period, strict afterward.
## Problems Solved
Chrono addresses DeFi lending issues, with Flow solving time-based vulnerabilities:
* Gap Between Flash and Generic Loans: Time limits enable continuum for intra-day trading.
* Volatility Management: Dynamic LTV boosts efficiency in low-vol periods.
* Moral Hazard: Expiry penalties enforce accountability.
* Inefficient Liquidations: Time-adjusted thresholds reduce losses.
* Rate Inefficiency: Time-parameterized IRM prices risk better.
Example: ETH Leveraging
This illustrates an ETH price increase (6.4% profit in <1 hour). Traditionally, 4× leverage yields 25.6% profit. With Chrono (1-hour limit, up to 10× leverage), profit reaches ~64%.
Problems in Ethereum-Based Lending (Mitigated by Flow)
* Timestamp Manipulation: Flow's decentralized clock resists gaming.
* Keeper Dependencies: No external services needed.
* MEV and Front-Running: Scheduled txs bypass public mempools.
* Reentrancy Vulnerabilities: Cadence's typing prevents exploits.
* Scalability and Gas Costs: Low fees enable frequent checks.
## Use Cases
* Leverage Trading: Access up to 20× leverage for short-term positions (via tiered stacking).
* Arbitrage: Borrow for minutes to execute profitable trades.
* Yield Farming: Leverage LP positions efficiently.
* Portfolio Rebalancing: Quick capital for tactical moves.
## Architecture and Technologies Used
* Base Protocol: Cadence implementation for lending mechanics.
* Extensions: Modules for time tracking, LTV/IRM, liquidations; uses FlowTransactionScheduler.
* Oracles: Flow-compatible (e.g., DIA).
* Automation: Flow Scheduled Transactions for expirations.
* Deployment: Flow mainnet; compatible with emulators.
* Tools: Flow CLI, Cadence libraries; audited via third-parties.
All on-chain for decentralization.
## Risks and Considerations
Inherits some lending risks, mitigated by Flow:
* Scheduling Delays: Priority system handles congestion.
* Fee Volatility: Upfront estimation prevents failures.
* Implementation Bugs: Cadence's typing reduces; multi-audits essential.
* Ecosystem Maturity: Flow's growing DeFi; ongoing bootstrapping needed.
Mitigations: Governance, simulations.
For the latest, check [Chrono Docs](https://chronolabs.gitbook.io/chronolabs-docs).
Tiến độ hackathon
Our journey began with a simple question — *how can Flow’s Scheduled Transactions be used to bring automation and precision to DeFi?* While exploring this, we came across lending protocols like **Aave, Compound, and Euler**, which form the backbone of decentralized finance. We studied how these protocols work, the mechanics of collateralization, liquidation, and interest models, and realized that while they enable permissionless lending, they all share one limitation — **time is not a parameter.** We noticed that traditional DeFi lending either offers **instantaneous flash loans** or **open-ended generic borrows**, both of which have inherent inefficiencies. Borrowers often overpay for duration they don’t use, while lenders take on indefinite risk exposure. We realized that by making lending **time-based**, we could solve several critical problems — reduce systemic risk, improve capital efficiency, and prevent indefinite defaults. Scheduled Transactions on Flow provided exactly the infrastructure we needed to make this possible. Once the concept was clear, we began studying the mathematics behind lending risk. We developed our **LTV (Loan-to-Value)** and **IRM (Interest Rate Model)** formulas by introducing *time* as a key factor. The LTV dynamically decreases with duration, allowing higher leverage for short-term borrows and safer ratios for longer ones. Similarly, our IRM adjusts rates based on both utilization and duration, ensuring that shorter loans are cheaper and long-term borrows remain sustainable. This mathematical backbone helped us design a predictable and fair system for both lenders and borrowers. Parallel to this, we identified **real-world use cases** for the protocol — from **short-term arbitrage** and **hour-long yield strategies** to **temporary liquidity needs** for traders. Borrowers benefit from flexible, time-locked access to funds with better rates, while lenders gain improved yield security through enforced expirations. This alignment of incentives built Chrono’s value proposition. We then designed the overall **contract architecture**, dividing responsibilities across modular Cadence contracts — * **CollateralVault.cdc** manages collateral deposits and withdrawals. * **LendingPool.cdc** handles core lending logic and time-bound borrows. * **Oracle.cdc** integrates price feeds for accurate valuations. * **WrappedToken.cdc** manages standardized wrapped assets. * **Counter.cdc** and supporting scripts help track active loans and automate expirations. This modular structure made it easier to integrate Flow’s features like **Scheduled Transactions** for automatic loan expiry, **resource-oriented programming** for safe asset handling, and **sub-second finality** for reliable automation. After the contract logic was finalized, we built the **transaction scripts** for lending, borrowing, repayment, and liquidation, all synchronized with Flow’s scheduler. Finally, we developed the **frontend website** to make this entire experience accessible and transparent — allowing users to supply assets, set durations, and visualize their borrow countdowns in real time. From exploring Flow’s capabilities to implementing a complete time-based lending system, our journey has been about **redefining DeFi through time automation.** Chrono stands as proof that precise, autonomous, and fair lending is possible — and only truly achievable on **Flow.**
Công nghệ sử dụng
Trạng thái huy động vốn
We are actively looking for investors. Since this project was made completely during this hackathon, currently we don't have any funds.