A next-generation overcollateralized stablecoin with dynamic peg stability and auto-compounding yields, built on Arbitrum Orbit chain.
ArbiYield introduces the first stablecoin protocol with AI-adjusted collateral ratios that respond to market volatility in real-time, powered by Arbitrum Stylus for gas-efficient liquidations and deployed on a custom Orbit chain for maximum scalability.
Current stablecoin solutions face critical limitations:
- Algorithmic Stablecoins: Prone to death spirals during high volatility (Terra/Luna collapse)
- Centralized Stablecoins: No native yield, counterparty risk, regulatory vulnerabilities
- Overcollateralized Stablecoins: Static collateral ratios waste capital during stable markets
- DeFi Yields: Fragmented across protocols, require manual management, high gas costs
Market Gap: No stablecoin exists that combines:
- Provable stability through overcollateralization
- Dynamic risk management that adapts to market conditions
- Auto-compounding yields without manual intervention
- Capital efficiency during bull markets, safety during volatility
ArbiYield is a hybrid stablecoin protocol that maintains $1 peg through:
-
Dynamic Collateral Ratios (DCR)
- Real-time adjustment based on market volatility indices
- Range: 130% (low volatility) → 200% (extreme volatility)
- Automated rebalancing without governance delays
-
Multi-Asset Collateral Basket
- ETH, ARB, USDC weighted portfolio
- Chainlink price feeds + on-chain volatility oracles
- Cross-collateralization benefits
-
Stylus-Powered Liquidation Engine
- 10-100x faster than Solidity equivalents
- Sub-second liquidation execution
- Higher capital efficiency = lower collateral requirements
-
Auto-Compounding Yield Layer
- Deposits idle collateral into Arbitrum One DeFi protocols (Aave, GMX, Pendle)
- Automated yield harvesting and reinvestment
- Yields passed to AYD stablecoin holders
-
Custom Arbitrum Orbit Chain
- Ultra-low gas fees for frequent rebalancing operations
- Custom gas token (paid in AYD or ETH)
- Optimized block times for liquidation speed
┌─────────────────────────────────────────────────────────────────┐
│ ARBITRUM ORBIT CHAIN │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Core Protocol Contracts │ │
│ │ │ │
│ │ ┌─────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ Vault │───▶│ Collateral │◀──│ Oracle │ │ │
│ │ │ Manager │ │ Manager │ │ Aggregator │ │ │
│ │ └─────────────┘ └──────────────┘ └──────────────┘ │ │
│ │ │ │ │ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌─────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ AYD │ │ Dynamic │ │ Volatility │ │ │
│ │ │ Stablecoin │ │ Collat. │ │ Oracle │ │ │
│ │ │ (ERC20) │ │ Ratio │ │ (Chainlink)│ │ │
│ │ └─────────────┘ └──────────────┘ └──────────────┘ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ STYLUS LIQUIDATION ENGINE (RUST) │ │ │
│ │ │ - Health Factor Monitoring │ │ │
│ │ │ - Liquidation Execution │ │ │
│ │ │ - Gas-Optimized Position Management │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Yield Generation Layer │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ Aave V3 │ │ GMX V2 │ │ Pendle │ │ │
│ │ │ Lending │ │ Perps │ │ Yield │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌────────────────────┐
│ ARBITRUM ONE │
│ - Bridge Contracts│
│ - DeFi Integrations│
│ - Liquidity Pools │
└────────────────────┘
contracts/
├── core/
│ ├── AYDStablecoin.sol # Main ERC20 stablecoin
│ ├── VaultManager.sol # Vault creation & management
│ ├── CollateralManager.sol # Multi-asset collateral handling
│ └── DynamicCollateralRatio.sol # DCR calculation engine
│
├── liquidation/
│ ├── liquidation_engine.rs # Stylus liquidation core
│ ├── health_monitor.rs # Position health tracking
│ └── auction_manager.rs # Dutch auction liquidations
│
├── oracles/
│ ├── OracleAggregator.sol # Multi-oracle aggregation
│ ├── VolatilityOracle.sol # On-chain volatility calculations
│ └── ChainlinkAdapter.sol # Chainlink price feed adapter
│
├── yield/
│ ├── YieldRouter.sol # Yield strategy router
│ ├── AaveStrategy.sol # Aave V3 integration
│ ├── GMXStrategy.sol # GMX perpetuals strategy
│ └── PendleStrategy.sol # Pendle yield tokenization
│
├── governance/
│ ├── ProtocolGovernance.sol # Parameter adjustments
│ ├── EmergencyModule.sol # Circuit breakers & pauses
│ └── TreasuryManager.sol # Protocol fee management
│
└── bridges/
├── ArbitrumBridge.sol # Orbit <-> Arbitrum One
└── CCIPIntegration.sol # Chainlink CCIP for cross-chain
Algorithm:
function calculateDCR() public view returns (uint256) {
uint256 volatilityIndex = volatilityOracle.get30DayVolatility();
// Base ratio: 150%
// Volatility adjustment: +0.5% per 1% volatility increase
// Caps: min 130%, max 200%
if (volatilityIndex < 20) {
return 130e16; // 130% in low volatility
} else if (volatilityIndex > 100) {
return 200e16; // 200% in extreme volatility
} else {
// Linear interpolation
return 130e16 + ((volatilityIndex - 20) * 875e12);
}
}Inputs:
- 30-day realized volatility (Chainlink + on-chain TWAP)
- Black Swan event detector (rapid price drops)
- Correlation matrix between collateral assets
Outputs:
- Current required collateralization ratio
- Rebalancing recommendations for existing vaults
- Liquidation thresholds
Why Stylus:
- Liquidations require intensive computation (health factor checks across 1000s of positions)
- Solidity gas costs make frequent checks prohibitively expensive
- Stylus (Rust) provides 10-100x gas efficiency
Core Logic (Rust):
#[storage]
pub struct LiquidationEngine {
positions: StorageMap<Address, Position>,
oracle_prices: StorageMap<Address, U256>,
liquidation_threshold: StorageU256,
}
impl LiquidationEngine {
pub fn check_and_liquidate(&mut self, user: Address) -> Result<(), Error> {
let position = self.positions.get(user);
let health_factor = self.calculate_health_factor(position)?;
if health_factor < self.liquidation_threshold.get() {
self.execute_liquidation(user, position)?;
}
Ok(())
}
fn calculate_health_factor(&self, position: Position) -> Result<U256, Error> {
let collateral_value = self.get_collateral_usd_value(position)?;
let debt_value = position.debt_amount;
let required_ratio = self.get_current_dcr()?;
// Health factor = (collateral_value / debt_value) / required_ratio
Ok((collateral_value * PRECISION) / (debt_value * required_ratio))
}
}Performance Comparison:
| Operation | Solidity Gas | Stylus Gas | Improvement |
|---|---|---|---|
| Health Factor Check (1000 positions) | ~2.5M | ~25K | 100x |
| Liquidation Execution | ~500K | ~15K | 33x |
| Batch Oracle Update | ~1.2M | ~40K | 30x |
- Deposit idle ETH/USDC into Aave lending pools
- Auto-compound interest rewards
- Emergency withdraw on high utilization (>90%)
- Delta-neutral positions using GM pools
- Earn trading fees + esGMX rewards
- Automated hedging to maintain neutrality
- Split yield-bearing tokens (stETH) into PT + YT
- Harvest YT yields while holding PT for principal
- Auto-roll at maturity
Yield Distribution:
Protocol Revenue Flow:
├── 80% → AYD Holders (auto-rebasing)
├── 15% → Protocol Treasury
└── 5% → Liquidators/Keepers
Three-Layer Oracle Design:
- Primary: Chainlink Price Feeds (ETH/USD, ARB/USD, USDC/USD)
- Secondary: Uniswap V3 TWAP (30-min window)
- Fallback: Manual governance override (emergency only)
Volatility Oracle:
- Calculates on-chain realized volatility using exponential moving average
- Samples: every 4 hours over 30-day window
- Formula: σ = sqrt(Σ(returns²) / n)
Circuit Breakers:
-
20% price deviation between oracles → pause minting
-
50% volatility spike → increase DCR by 10%
- Oracle staleness (>2 hours) → use fallback
contract AYDStablecoin is ERC20Rebasing, AccessControl {
// Rebasing token that auto-compounds yields
// 1 AYD always redeemable for $1 of collateral
mapping(address => uint256) public shares;
uint256 public totalShares;
uint256 public totalYield;
function rebase() external {
// Called by YieldRouter after harvest
// Increases token supply proportionally to yield
}
function mint(address to, uint256 amount) external onlyVaultManager;
function burn(address from, uint256 amount) external onlyVaultManager;
}contract VaultManager {
struct Vault {
address owner;
uint256 collateralETH;
uint256 collateralARB;
uint256 collateralUSDC;
uint256 debtAYD;
uint256 lastUpdateBlock;
}
mapping(uint256 => Vault) public vaults;
function openVault(
uint256 ethAmount,
uint256 arbAmount,
uint256 usdcAmount,
uint256 mintAmount
) external returns (uint256 vaultId);
function addCollateral(uint256 vaultId, uint256 amount) external;
function withdrawCollateral(uint256 vaultId, uint256 amount) external;
function mintAYD(uint256 vaultId, uint256 amount) external;
function burnAYD(uint256 vaultId, uint256 amount) external;
function closeVault(uint256 vaultId) external;
}contract DynamicCollateralRatio {
IVolatilityOracle public volatilityOracle;
uint256 public constant MIN_RATIO = 130e16; // 130%
uint256 public constant MAX_RATIO = 200e16; // 200%
uint256 public constant BASE_RATIO = 150e16; // 150%
function getCurrentRatio() external view returns (uint256);
function getVaultHealth(uint256 vaultId) external view returns (uint256);
function isVaultHealthy(uint256 vaultId) external view returns (bool);
}#[external]
impl LiquidationEngine {
// Public functions callable from EVM
pub fn liquidate(&mut self, vault_id: U256) -> Result<(), Vec<u8>>;
pub fn batch_check_health(&self, vault_ids: Vec<U256>) -> Vec<U256>;
pub fn get_liquidation_price(&self, vault_id: U256) -> U256;
}
#[internal]
impl LiquidationEngine {
// Internal Rust-only functions
fn calculate_liquidation_bonus(&self, health_factor: U256) -> U256;
fn execute_dutch_auction(&mut self, vault_id: U256) -> Result<(), Error>;
fn distribute_liquidation_rewards(&mut self, liquidator: Address, amount: U256);
}✅ Stable Yield: Earn 5-12% APY on your stablecoins automatically
✅ $1 Peg Guarantee: Always redeemable for $1 of collateral
✅ Capital Efficient: Minimum 130% collateral in stable markets
✅ Gasless Transactions: Subsidized gas on Orbit chain
✅ Cross-Chain: Bridge to Arbitrum One, Ethereum mainnet
✅ No Lockups: Withdraw anytime (subject to collateral ratio)
✅ MEV Opportunities: Fast liquidations with 5-10% bonus
✅ Dutch Auction: Fair price discovery for liquidated collateral
✅ Keeper Rewards: Earn fees for calling rebalance functions
✅ Composable: ERC20-compatible, integrate with any DeFi protocol
✅ Open Source: MIT licensed, fork-friendly
✅ Well-Documented: Extensive NatSpec comments
✅ Upgradeable: Transparent proxy pattern for emergency fixes
- Solidity: 0.8.24 (Core protocol logic)
- Rust: 1.75+ (Stylus liquidation engine)
- Stylus SDK: 0.5.0 (Arbitrum Rust integration)
- OpenZeppelin: 5.0.0 (Security primitives)
- Foundry: Testing and deployment
- Arbitrum Orbit: Custom app-chain deployment
- Arbitrum One: DeFi integrations and liquidity
- Chainlink: Price feeds and CCIP bridge
- The Graph: Event indexing and queries
- TypeScript: 5.3+
- React: 18.2+ with Next.js 14
- Wagmi: 2.0+ (Wallet connections)
- Viem: 2.0+ (Ethereum interactions)
- TailwindCSS: 3.4+ (Styling)
- Recharts: Position analytics and yield tracking
- Node.js: 20+ (Scripts and automation)
- Hardhat: Contract compilation and testing
- Docker: Orbit chain node deployment
- GitHub Actions: CI/CD pipelines
- Chainlink Price Feeds: ETH, ARB, USDC prices
- Chainlink Automation: Keeper network for rebalancing
- Custom Volatility Oracle: On-chain volatility calculations
arbiyield/
├── contracts/
│ ├── src/
│ │ ├── core/
│ │ │ ├── AYDStablecoin.sol
│ │ │ ├── VaultManager.sol
│ │ │ ├── CollateralManager.sol
│ │ │ └── DynamicCollateralRatio.sol
│ │ ├── liquidation/
│ │ │ ├── liquidation_engine.rs
│ │ │ ├── health_monitor.rs
│ │ │ └── auction_manager.rs
│ │ ├── oracles/
│ │ │ ├── OracleAggregator.sol
│ │ │ ├── VolatilityOracle.sol
│ │ │ └── ChainlinkAdapter.sol
│ │ ├── yield/
│ │ │ ├── YieldRouter.sol
│ │ │ ├── AaveStrategy.sol
│ │ │ ├── GMXStrategy.sol
│ │ │ └── PendleStrategy.sol
│ │ ├── governance/
│ │ │ ├── ProtocolGovernance.sol
│ │ │ ├── EmergencyModule.sol
│ │ │ └── TreasuryManager.sol
│ │ └── bridges/
│ │ ├── ArbitrumBridge.sol
│ │ └── CCIPIntegration.sol
│ ├── test/
│ │ ├── unit/
│ │ │ ├── AYDStablecoin.t.sol
│ │ │ ├── VaultManager.t.sol
│ │ │ └── DynamicCollateralRatio.t.sol
│ │ ├── integration/
│ │ │ ├── YieldGeneration.t.sol
│ │ │ ├── Liquidation.t.sol
│ │ │ └── CrossChainBridge.t.sol
│ │ └── fuzzing/
│ │ ├── VaultFuzzing.t.sol
│ │ └── OracleFuzzing.t.sol
│ ├── script/
│ │ ├── Deploy.s.sol
│ │ ├── SetupOrbit.s.sol
│ │ └── ConfigureYield.s.sol
│ ├── foundry.toml
│ └── package.json
│
├── stylus/
│ ├── liquidation-engine/
│ │ ├── src/
│ │ │ ├── lib.rs
│ │ │ ├── engine.rs
│ │ │ ├── health.rs
│ │ │ └── auction.rs
│ │ ├── Cargo.toml
│ │ └── README.md
│ └── scripts/
│ ├── build.sh
│ └── deploy.sh
│
├── frontend/
│ ├── src/
│ │ ├── app/
│ │ │ ├── page.tsx
│ │ │ ├── vaults/
│ │ │ ├── analytics/
│ │ │ └── governance/
│ │ ├── components/
│ │ │ ├── VaultCard.tsx
│ │ │ ├── CollateralManager.tsx
│ │ │ ├── YieldDashboard.tsx
│ │ │ └── HealthMonitor.tsx
│ │ ├── hooks/
│ │ │ ├── useVault.ts
│ │ │ ├── useOracle.ts
│ │ │ └── useYield.ts
│ │ ├── lib/
│ │ │ ├── contracts.ts
│ │ │ ├── abis/
│ │ │ └── constants.ts
│ │ └── utils/
│ │ ├── formatting.ts
│ │ └── calculations.ts
│ ├── public/
│ ├── package.json
│ └── next.config.js
│
├── orbit-config/
│ ├── chain-config.json
│ ├── genesis.json
│ ├── validators.json
│ └── docker-compose.yml
│
├── scripts/
│ ├── deploy-orbit.ts
│ ├── setup-oracles.ts
│ ├── fund-strategies.ts
│ └── monitor-health.ts
│
├── docs/
│ ├── ARCHITECTURE.md
│ ├── SECURITY.md
│ ├── INTEGRATION.md
│ └── API.md
│
├── .github/
│ └── workflows/
│ ├── test.yml
│ ├── deploy-testnet.yml
│ └── security-audit.yml
│
├── README.md
├── LICENSE
└── package.json
# Required installations
- Node.js >= 20.0.0
- Rust >= 1.75.0
- Foundry (forge, cast, anvil)
- Docker & Docker Compose
- Git# Clone the repository
git clone https://github.com/yourusername/arbiyield.git
cd arbiyield
# Install dependencies
npm install
# Install Foundry dependencies
cd contracts && forge install
# Build Stylus contracts
cd ../stylus/liquidation-engine
cargo build --release --target wasm32-unknown-unknown
# Compile Solidity contracts
cd ../../contracts
forge build# Create .env file
cp .env.example .env
# Required environment variables
PRIVATE_KEY=your_private_key_here
ARBITRUM_RPC_URL=https://arb1.arbitrum.io/rpc
ORBIT_RPC_URL=http://localhost:8547
CHAINLINK_API_KEY=your_chainlink_key
ETHERSCAN_API_KEY=your_etherscan_key# Solidity unit tests
forge test
# Solidity integration tests
forge test --match-contract Integration
# Stylus tests
cd stylus/liquidation-engine
cargo test
# Frontend tests
cd frontend
npm run test
# Gas benchmarks
forge test --gas-report# Terminal 1: Start local Orbit chain
cd orbit-config
docker-compose up
# Terminal 2: Deploy contracts
cd contracts
forge script script/Deploy.s.sol --rpc-url $ORBIT_RPC_URL --broadcast
# Terminal 3: Start frontend
cd frontend
npm run dev# Deploy to Arbitrum Sepolia testnet
forge script script/Deploy.s.sol \
--rpc-url $ARBITRUM_SEPOLIA_RPC \
--broadcast \
--verify
# Deploy Stylus contracts
cd stylus/liquidation-engine
cargo stylus deploy \
--private-key=$PRIVATE_KEY \
--endpoint=$ARBITRUM_SEPOLIA_RPC
# Deploy Orbit chain (requires validator setup)
npm run deploy:orbitimport { useVault } from '@/hooks/useVault';
function OpenVault() {
const { openVault } = useVault();
const handleOpen = async () => {
const tx = await openVault({
ethCollateral: parseEther('1'), // 1 ETH
arbCollateral: parseEther('100'), // 100 ARB
usdcCollateral: parseUnits('500', 6), // 500 USDC
mintAmount: parseEther('2000') // Mint 2000 AYD
});
await tx.wait();
};
return <button onClick={handleOpen}>Open Vault</button>;
}import { useOracle } from '@/hooks/useOracle';
function VaultHealth({ vaultId }) {
const { getHealthFactor, getCurrentDCR } = useOracle();
const healthFactor = getHealthFactor(vaultId);
const requiredRatio = getCurrentDCR();
return (
<div>
<p>Health Factor: {healthFactor.toString()}</p>
<p>Required Collateral: {requiredRatio / 1e16}%</p>
<p>Status: {healthFactor > 1 ? '✅ Healthy' : '⚠️ At Risk'}</p>
</div>
);
}import { useLiquidation } from '@/hooks/useLiquidation';
function Liquidate({ vaultId }) {
const { liquidate, getLiquidationBonus } = useLiquidation();
const bonus = getLiquidationBonus(vaultId);
const handleLiquidate = async () => {
const tx = await liquidate(vaultId);
await tx.wait();
// Liquidator receives collateral + bonus
};
return (
<div>
<p>Liquidation Bonus: {bonus}%</p>
<button onClick={handleLiquidate}>Liquidate</button>
</div>
);
}| Market Condition | Volatility Index | Required Ratio | Example |
|---|---|---|---|
| Bull Market | <20% | 130% | Mint 1000 AYD with $1300 collateral |
| Normal | 20-50% | 150% | Mint 1000 AYD with $1500 collateral |
| High Volatility | 50-80% | 175% | Mint 1000 AYD with $1750 collateral |
| Extreme Crisis | >80% | 200% | Mint 1000 AYD with $2000 collateral |
Annual Yield Estimates (subject to market conditions):
- Aave Lending: 3-5% APY
- GMX LP Fees: 8-15% APY
- Pendle Yield Trading: 10-20% APY
- Blended Average: 7-12% APY
Fee Structure:
- Minting Fee: 0.5% (one-time)
- Redemption Fee: 0.25% (one-time)
- Performance Fee: 15% of yields (continuous)
- Liquidation Penalty: 5-10% (depends on health factor)
Monthly Revenue (at $10M TVL):
├── Minting Fees ($500K monthly volume): $2,500
├── Performance Fees (8% avg APY, 15% cut): $10,000
├── Liquidation Fees (assuming 2% monthly): $2,000
└── Total Monthly: ~$14,500
Annual Revenue Projection: ~$174,000
Critical Components:
- ✅ VaultManager.sol - Collateral accounting
- ✅ DynamicCollateralRatio.sol - DCR calculations
- ✅ Liquidation Engine (Rust) - Position liquidations
- ✅ OracleAggregator.sol - Price feed integrity
- ✅ YieldRouter.sol - Strategy fund movements
| Risk | Severity | Mitigation |
|---|---|---|
| Oracle Manipulation | High | 3-layer oracle system, 30-min TWAP |
| Smart Contract Bugs | High | Multi-stage audits, bug bounty program |
| Yield Strategy Failure | Medium | Diversified strategies, emergency withdraw |
| Extreme Volatility | Medium | DCR auto-adjustment, circuit breakers |
| Orbit Chain Downtime | Low | Fallback to Arbitrum One, state snapshots |
// Example: Reentrancy protection
contract VaultManager is ReentrancyGuard {
function withdrawCollateral(uint256 amount)
external
nonReentrant
whenNotPaused
{
require(getHealthFactor(msg.sender) > 1.2e18, "Unhealthy");
// ... withdrawal logic
}
}- Circuit Breaker: Governance can pause minting/redemptions
- Oracle Fallback: Manual price updates if Chainlink fails
- Yield Strategy Pause: Stop deposits to compromised protocols
- Liquidation Halt: Prevent cascading liquidations in flash crashes
- Unit Tests: >95% coverage for Solidity contracts
- Integration Tests: All cross-contract interactions
- Fuzzing: Vault operations with random inputs (Foundry)
- Stylus Tests: Rust property-based testing (proptest)
- Fork Tests: Mainnet fork testing against live DeFi protocols
// Test: DCR adjusts correctly during volatility spike
function testDCRAdjustmentHighVolatility() public {
// Set volatility to 80%
volatilityOracle.setVolatility(80e16);
uint256 ratio = dcrContract.getCurrentRatio();
assertEq(ratio, 182.5e16); // Should be ~182.5%
}
// Test: Liquidation triggers at correct health factor
function testLiquidationExecution() public {
// Create vault at 150% collateral
uint256 vaultId = openVault(1 ether, 1500e18);
// Drop ETH price by 30%
oracle.setPrice(address(weth), 700e18);
// Health factor should be < 1
assertTrue(getHealthFactor(vaultId) < 1e18);
// Liquidation should succeed
liquidationEngine.liquidate(vaultId);
}// Example: Using AYD as collateral in lending protocol
import "@arbiyield/contracts/interfaces/IAYDStablecoin.sol";
contract LendingPool {
IAYDStablecoin public immutable ayd;
function depositAYD(uint256 amount) external {
ayd.transferFrom(msg.sender, address(this), amount);
// Issue lending pool shares
}
function borrowAgainstAYD(uint256 collateralAmount) external {
require(ayd.balanceOf(msg.sender) >= collateralAmount);
// Lending logic
}
}// Install package
npm install @arbiyield/sdk
// Usage
import { ArbiYieldSDK } from '@arbiyield/sdk';
const sdk = new ArbiYieldSDK({
chainId: 42161, // Arbitrum One
rpcUrl: process.env.NEXT_PUBLIC_RPC_URL
});
// Get vault info
const vault = await sdk.getVault(vaultId);
console.log(`Collateral: ${vault.collateralValue} USD`);
console.log(`Debt: ${vault.debtAmount} AYD`);
console.log(`Health: ${vault.healthFactor}`);- ✅ Deploy core contracts to Arbitrum Sepolia
- ✅ Launch Orbit chain testnet
- ✅ Integrate Chainlink price feeds
- ✅ Build MVP frontend
- 🔄 Complete smart contract audits (2 firms)
- 🔄 Implement audit recommendations
- 🔄 Launch bug bounty program ($50K)
- 🔄 Stress test with simulated market conditions
- ⏳ Deploy to Arbitrum Orbit mainnet
- ⏳ Cap initial TVL at $1M
- ⏳ Enable ETH + USDC collateral only
- ⏳ Launch with conservative 170% DCR
- ⏳ Remove TVL cap
- ⏳ Add ARB collateral support
- ⏳ Activate dynamic DCR algorithm
- ⏳ Integrate additional yield strategies
- ⏳ Cross-chain bridges (Ethereum, Base, Optimism)
- ⏳ Mobile app (iOS + Android)
- ⏳ Governance token launch
- ⏳ Institutional custody partnerships
We welcome contributions! Please see CONTRIBUTING.md for guidelines.
# Create feature branch
git checkout -b feature/your-feature-name
# Make changes and test
forge test
npm run lint
# Commit with conventional commits
git commit -m "feat: add new liquidation strategy"
# Push and create PR
git push origin feature/your-feature-name- Solidity: Follow Solidity Style Guide
- Rust: Use
cargo fmtandcargo clippy - TypeScript: Prettier + ESLint (config included)
This project is licensed under the MIT License - see LICENSE file for details.
- Website: https://arbiyield.finance
- Twitter: @ArbiYield
- Discord: https://discord.gg/arbiyield
- Email: team@arbiyield.finance
- Docs: https://docs.arbiyield.finance
- Devil - Lead Blockchain Engineer & Architect
- Talha Ansari - Smart Contract Developer
- Akash Singh - Frontend Engineer
Special thanks to:
- Arbitrum Foundation for Orbit chain infrastructure
- Chainlink Labs for reliable oracle solutions
- OpenZeppelin for security primitives
- Foundry Team for best-in-class dev tools
Current TVL: $0 (Pre-launch)
Total AYD Minted: 0
Active Vaults: 0
Average APY: TBD
Liquidations (24h): 0
Arbitrum Sepolia Testnet:
- AYD Token: 0x... (TBD)
- VaultManager: 0x... (TBD)
- LiquidationEngine: 0x... (TBD)
IMPORTANT: ArbiYield is experimental DeFi software currently in development.
- Not Audited: Contracts have not undergone professional security audits
- Use at Own Risk: Do not deposit funds you cannot afford to lose
- Testnet Only: Currently deployed on test networks only
- No Investment Advice: This is not financial advice
Always conduct your own research before interacting with any DeFi protocol.