Detailed Instructions

Begin by selecting an under-collateralized lending protocol like Aave Arc, Maple Finance, or TrueFi. The core architectural decision hinges on the credit delegation model or pool-based underwriting. Before depositing funds, you must thoroughly assess the protocol's risk parameters and the creditworthiness of borrowers.

• Sub-step 1: Analyze Whitelisted Entities: For permissioned pools (e.g., Maple), review the on-chain identity and historical performance of the Pool Delegates who underwrite loans. Check their default rates at addresses like 0x7C....
• Sub-step 2: Review Loan-to-Value (LTV) Ratios: Unlike over-collateralized loans, these protocols may offer LTVs up to 100% or higher. Verify the specific LTV for your asset pair (e.g., USDC to a corporate borrower).
• Sub-step 3: Examine Liquidation Mechanisms: Understand the liquidation waterfall and the role of first-loss capital. Determine who bears the initial default risk—often liquidity providers or junior tranche holders.

Tip: Use a blockchain explorer to audit the smart contract code of the Pool's Smart Contract (e.g., 0x4937...) for transparency on fund flows and default handling.

Detailed Instructions

Under-collateralized protocols often use a capital stack or tranche system to separate risk. As a liquidity provider, you must choose between senior (lower yield, lower risk) and junior (higher yield, first-loss) tranches. This step involves locking your capital into a specific pool's smart contract.

• Sub-step 1: Connect Wallet and Approve Token: Connect your Web3 wallet (e.g., MetaMask) to the protocol's UI. Approve the token (e.g., USDC) for spending by the pool contract. The approval transaction will specify a spender address like 0x5aA....
• Sub-step 2: Select Investment Tranche: Decide on your risk appetite. Depositing into the junior tranche might require you to call a function like depositJunior(1000000000) where the value is in the token's smallest unit (e.g., 1,000 USDC = 1000000000 for 6 decimals).
• Sub-step 3: Confirm Deposit and Receive Position Token: Execute the deposit. You will receive a receipt token (e.g., an ERC-20 like mUSDC-J) representing your share of the pool. Track its value relative to the underlying asset.

Tip: Always verify the Annual Percentage Yield (APY) for each tranche, which can range from 5% for senior to 20%+ for junior, but is highly variable based on pool performance.

Detailed Instructions

For a borrower (typically an institution or DAO), accessing capital requires passing the protocol's off-chain credit assessment and on-chain whitelisting. This step is where the under-collateralization is formally enacted, based on trust and verified identity rather than locked crypto assets.

• Sub-step 1: Submit KYC and Financials: Provide required documentation to the Pool Delegate or protocol's credit committee. This is an off-chain process establishing creditworthiness.
• Sub-step 2: Receive Whitelisted Borrower Status: Upon approval, your wallet address (e.g., 0xBorrower123...) is added to the pool's whitelist via a governance transaction. You can verify this by checking the isBorrower mapping in the pool contract.
• Sub-step 3: Draw Down the Loan: Call the drawdown function on the loan contract, specifying the amount. For example: ```code ILoanContract(0xLoan123).drawdown(500000000000000000000000); // Draws 500,000 USDC

codeCopy
The funds are transferred from the pool to your address, creating a debt obligation.

> **Tip:** Borrowers must understand the **loan covenant** terms, including the **interest rate** (e.g., 10% fixed APR) and **repayment schedule**, which are enforced by the smart contract.

Detailed Instructions

The architecture must include robust monitoring oracles and automatic liquidation triggers to protect lenders. This step involves tracking the borrower's financial health and the protocol's overall health score, which can trigger recovery actions.

• Sub-step 1: Track Payment Status: Monitor the borrower's wallet for scheduled interest payments. Missed payments are a primary default signal. You can set up a bot to listen for the Repayment event from the loan contract.
• Sub-step 2: Assess Covenant Breaches: Oracles or keepers check if the borrower violates terms (e.g., their real-world assets drop below a threshold). A breach can be reported by calling a function like reportDefault(loanId).
• Sub-step 3: Initiate Liquidation Process: Upon a verified default, the liquidation process begins. The first-loss capital (junior tranche) is used to cover initial losses. A keeper might execute:

codeCopy
IPool(0xPool456).triggerDefault(loanId);

This starts the waterfall, potentially involving legal recourse off-chain to recover funds from the borrower.

Tip: Liquidity providers should use dashboards that aggregate pool health metrics, such as Default Rate and Weighted Average Yield, to make informed decisions about reinvesting or exiting.

Detailed Instructions

Begin by cataloging the protocol-specific parameters that directly influence risk. This includes the loan-to-value (LTV) ratio, liquidation thresholds, and the interest rate model. For each parameter, establish a baseline and a range of stress-test values. For instance, if a protocol uses a variable interest rate, you must model the rate function.

• Sub-step 1: Extract on-chain parameters using the protocol's smart contracts. Query the main pool contract for key configuration values.
• Sub-step 2: Model the interest rate curve. Determine if it's linear, kinked, or follows a complex formula like Jump Rate or White Paper model.
• Sub-step 3: Identify oracle dependencies. Note the addresses of all price oracles used (e.g., Chainlink ETH/USD feed: 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419) and their update frequency.

Tip: Use a block explorer or a library like ethers.js to read contract state. Documenting these parameters creates the foundation for all subsequent stress tests.

Detailed Instructions

Under-collateralized lending relies heavily on borrower reputation and collateral asset volatility. This step involves creating a scoring system. For collateral, analyze the price history, liquidity depth on DEXs, and smart contract risks of the token. For borrowers, examine on-chain history, including wallet age, transaction volume, and debt repayment history from other protocols.

• Sub-step 1: Score collateral assets. Use a 30-day volatility metric. For example, a stablecoin like USDC might score 1 (low risk), while a volatile altcoin might score 5 (high risk).
• Sub-step 2: Develop a borrower health metric. Calculate a score based on factors like total borrowings vs. total deposits across DeFi (health_factor = total_collateral_value / total_borrowed_value).
• Sub-step 3: Set risk tiers. Define thresholds for your scores (e.g., Green: health factor > 2.0, Yellow: 1.5-2.0, Red: < 1.5) to trigger different monitoring levels.

Tip: Leverage subgraph queries or APIs from platforms like DeFi Llama to gather historical price and protocol data efficiently.

Detailed Instructions

The liquidation engine is the primary risk mitigation tool. You must model its behavior precisely. This involves understanding the liquidation incentive (bonus for liquidators), the liquidation threshold, and the process's gas cost efficiency. Create simulations where collateral value drops rapidly to test if the system remains solvent.

• Sub-step 1: Code a simple liquidation check. For a given position, verify if it's eligible for liquidation.

javascriptCopy
// Pseudo-code for liquidation check
function isLiquidatable(collateralValue, borrowedValue, liquidationThreshold) {
    let collateralRatio = (collateralValue / borrowedValue) * 100;
    return collateralRatio < liquidationThreshold; // e.g., 85%
}

• Sub-step 2: Run price shock scenarios. Model a 24-hour price drop of 20%, 40%, and 60% for the collateral asset. Calculate the percentage of positions that become undercollateralized.
• Sub-step 3: Assess liquidation capacity. Estimate the available liquidity in the system to absorb bad debt if liquidations fail, considering the protocol's insurance fund or shared loss mechanisms.

Tip: Factor in network congestion; a gas price spike to 200 gwei can make small liquidations unprofitable, causing delays.

Detailed Instructions

A static assessment is insufficient; you need real-time monitoring. This step involves setting up data pipelines to track the key metrics defined earlier. The goal is to create an early warning system that flags deteriorating positions, oracle staleness, or parameter changes before they cause losses.

• Sub-step 1: Set up indexers or subgraphs. Subscribe to events like Borrow, Repay, Liquidate, and PriceUpdate from the protocol's contracts.
• Sub-step 2: Define alert thresholds. Program alerts for specific conditions, such as: health_factor < 1.1, oracle_last_update > 3600 seconds, or pool_utilization_rate > 90%.
• Sub-step 3: Choose an alerting channel. Configure integrations to send notifications via Discord webhooks, Telegram bots, or email. For example, a Discord webhook URL would be specified in your monitoring script's configuration.

Tip: Use a service like The Graph for indexing and a lightweight serverless function (e.g., AWS Lambda) to evaluate conditions and dispatch alerts periodically, ensuring your framework is always active.