Blurb

In TradFi, consumer lending is a trillion-dollar market, while DeFi lending remains limited to a billion-dollar market of over-collateralized loans. This model is fundamentally broken: requiring borrowers to already have capital creates inefficiency and slows adoption. Unlloo introduces reputation-based borrowing in Web3, enabling under-collateralized loans by leveraging on-chain identity and reputation to assess creditworthiness.

Unlloo

Unlloo is an EVM DeFi protocol for under-collateralized loans backed by reputation. It enables borrowers to access loans based on their on-chain reputation score, while lenders can earn interest by providing liquidity to the protocol.

The protocol features:

• Reputation-based borrowing: Loan eligibility and limits are determined by on-chain wallet activity

• Liquidity pools: Lenders can deposit assets and earn interest

• Admin approval system: Loan requests are reviewed and approved by administrators

• Multi-chain reputation: Analyzes wallet history across Ethereum, Arbitrum, Base, Avalanche, and Optimism

How It Works

Unlloo is built on [Scaffold-ETH 2](https://github.com/scaffold-eth/scaffold-eth-2), a development framework for building dApps on Ethereum. The system consists of three main components:

1. Smart Contracts(Hardhat)

The core protocol logic is implemented in Solidity smart contracts:

• Loan lifecycle management (request, approval, borrowing, repayment)

• Liquidity pool management

• Interest calculations (compound interest for borrowers and lenders)

• Price oracle integration for USD conversions

• Protocol fee management
  

2. Frontend (Next.js)

A Next.js application built with Scaffold-ETH 2 that provides:

• User dashboard for reputation display and loan management

• Lending interface for liquidity providers

• Borrowing interface for loan requests

• Admin interface for loan approval/rejection

• Integration with smart contracts using Scaffold-ETH hooks

3. Backend API (NestJS)

A NestJS backend service that handles:

• Reputation calculation from multiple sources:

• 3rd party services (HumanPassport, zPass, Webacy, EthosNetwork)

• Custom creditworthiness analysis using Blockscout API

• Multi-chain wallet history analysis

• Reputation aggregation and scoring
  

User Flow

1. User connects wallet to the frontend
2. Backend calculates reputation based on wallet history
3. User submits a loan request with desired parameters
4. System admin reviews and approves/rejects the request
5. If approved, user can borrow from available liquidity pools
6. Lenders can deposit assets into pools at any time to earn interest

Project Structure

This is a Yarn monorepo containing three packages:

packages/
├── hardhat/ # Smart contracts and deployment scripts
├── nextjs/ # Frontend application (Scaffold-ETH 2)
└── api/ # Backend API (NestJS)

Prerequisites

- Node.js: >= 20.18.3
- Yarn: 3.2.3 (package manager)
- Git: For cloning the repository

Overview

Unlloo is an on-chain undercollateralized lending protocol. During this hackathon we shipped two

major milestones: a smart contract architecture redesign for size optimization, and a new

Guarantors Program that enables B2B credit partnerships.

1. Extension Pattern - Smart Contract Size Optimization

Solidity contracts have a hard bytecode size limit (24KB, EIP-170). As Unlloo grew in features,

the monolithic contract was approaching that limit. To solve this without sacrificing functionality,

we introduced the Extension Pattern.

Instead of one giant contract, the protocol is now split into:

• UnllooCore - the canonical state and core lending logic (loans, pools, repayments)

• UnllooExt - an extension contract that handles auxiliary features and delegates back to storage through a shared storage layer

• UnllooStorage — isolated storage contract, readable by both Core and Ext

Both Core and Ext share the same storage layout, so state is always consistent. The proxy

(Unlloo.sol) routes calls to the appropriate implementation. This keeps each contract well under

the size limit while the protocol continues to grow.

Key benefits:

• Each contract stays within the 24KB bytecode limit

• New features can be added as extensions without touching core logic

• Upgrades can be scoped to only the affected module

• Storage is decoupled, making audits and reasoning about state easier

2. Guarantors Program - B2B Credit Partnerships

The Guarantors Program introduces a new way to expand credit access: companies can act as

guarantors for their employees, backing their loan requests on Unlloo.

How it works:

A company (the guarantor) signs an off-chain B2B contract with Unlloo and then registers

on-chain by simply recording their backing for a specific employee's wallet address. No funds

are locked upfront — the guarantee is a committed relationship, not a collateral deposit.

When the guaranteed employee applies for a loan, the protocol flags them as guaranteed. The

lender/admin can see this backing and approve the request with more confidence - potentially

at better terms or higher amounts.

Repayment model

The guarantor trusts the process via the B2B agreement. If the employee repays normally,

no action is needed from the guarantor. If the employee defaults:

1. The guarantor is alerted via the dashboard (countdown to expected resolution).

2. At any point, the guarantor can call payOnBehalf() to cover the debt - tokens are pulled from their wallet at that moment (no pre-locking required).

3. The guarantor's commitment is enforced through the B2B contract off-chain, not by on-chain collateral seizure - keeping the UX lightweight while the legal agreement ensures accountability.

On-chain mechanics

• registerGuarantee(borrower) - Records the guarantor-borrower relationship. No token transfer, no collateral locked.

• removeGuarantee(borrower) - Removes the record. Blocked if the borrower has an active or unpaid loan.

• payOnBehalf(loanId, amount) - Guarantor repays on the borrower's behalf. Tokens pulled from the guarantor's wallet at call time - works exactly like repay() but callable by the registered guarantor.

Frontend

A new Guarantor Dashboard was shipped at /guarantor with:

• "My Guarantees" tab - list of wallets the connected address is backing, with bond status, coverage amounts, and alerts for any defaults

• "Add Guarantee" modal - deposit collateral and register a new borrower

• "Remove Guarantee" action - safely exit a bond with no active exposure

• Alert banners highlighting defaulted borrowers and the countdown to bond seizure

Summary

During this hackathon we proved that Unlloo can scale both technically (extension pattern keeping

contracts deployable as features grow) and commercially (guarantor program enabling real B2B

credit relationships where companies vouch for their employees on-chain). The model is lightweight:

no collateral lock-up, no on-chain seizure logic - just a registered commitment backed by a B2B

agreement, with payOnBehalf() as the on-chain mechanism for the guarantor to honour it.

Right now, we are in discussions with some angels and are also building long-term relationships with VCs for future partnerships. We currently have one possible angel investor.