JustFlash Protocol

Overview

Why JustFlash?

Features

Architecture

┌─────────────────────────────────────────────────────────────────┐
│ JustFlash Protocol │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────┐ ┌──────────────────┐ │
│ │ FlashLoanPool │◄───│ FeeCollector │ │
│ │ │ │ │ │
│ │ • flashLoan() │ │ • collectFees() │ │
│ │ • deposit() │ │ • 80/20 split │ │
│ │ • withdraw() │ │ │ │
│ └────────┬─────────┘ └──────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────┐ ┌──────────────────┐ │
│ │ PoolRegistry │ │ Your Contract │ │
│ │ │ │ │ │
│ │ • Token mgmt │ │ Implements │ │
│ │ • Whitelist │ │ IFlashLoan │ │
│ │ │ │ Receiver │ │
│ └──────────────────┘ └──────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘

Flash Loan Execution Flow

1. Your Contract calls flashLoan(receiver, token, amount, params)
2. Pool validates liquidity and calculates premium (amount ×ばつ 0.05%)
3. Pool transfers tokens to receiver
4. Pool calls receiver.executeOperation(token, amount, premium, initiator, params)
5. Receiver executes strategy (arbitrage, liquidation, etc.)
6. Receiver approves Pool for amount + premium
7. Pool pulls repayment via transferFrom()
8. Pool verifies balance and distributes fees
9. Transaction completes (or reverts entirely if repayment fails)

Quick Start

Prerequisites

Installation

# Clone the repository
git clone https://github.com/Steake/JustFlash.git
cd JustFlash
# Install dependencies
npm install
# Copy environment configuration
cp .env.example .env

Local Development

# Start local TRON node (Tron Quickstart)
docker-compose up -d tron-quickstart
# Wait for node to be ready (~30 seconds)
docker-compose logs -f tron-quickstart
# Compile contracts
npm run compile
# Run tests
npm run test
# Deploy to local network
npm run migrate

Deploy to Testnet (Nile)

# Set your private key in .env
PRIVATE_KEY_NILE=your_private_key_here
# Get testnet TRX from faucet: https://nileex.io/join/getJoinPage
# Deploy
npm run migrate:nile
# Bootstrap liquidity (if you have test tokens)
npm run bootstrap:nile

Smart Contracts

Core Contracts

Interfaces

Adapters

Supported Tokens (Mainnet)

Integration Guide

Implementing a Flash Loan Receiver

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/IFlashLoanReceiver.sol";
import "./interfaces/IFlashLoanPool.sol";
contract MyFlashLoanStrategy is IFlashLoanReceiver {
 IFlashLoanPool public immutable pool;
 constructor(address _pool) {
 pool = IFlashLoanPool(_pool);
 }
 function executeOperation(
 address token,
 uint256 amount,
 uint256 premium,
 address initiator,
 bytes calldata params
 ) external override returns (bool) {
 // Ensure caller is the pool
 require(msg.sender == address(pool), "Unauthorized");
 // ============================================
 // Your custom logic here
 // Example: arbitrage, liquidation, collateral swap
 // ============================================
 // Calculate total owed
 uint256 amountOwed = amount + premium;
 // Approve pool to pull repayment
 IERC20(token).approve(address(pool), amountOwed);
 return true;
 }
 function initiateFlashLoan(
 address token,
 uint256 amount,
 bytes calldata params
 ) external {
 pool.flashLoan(address(this), token, amount, params);
 }
}

Using the Base Receiver

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "./adapters/FlashLoanReceiverBase.sol";
contract MyStrategy is FlashLoanReceiverBase {
 constructor(address pool, address owner)
 FlashLoanReceiverBase(pool, owner)
 {}
 function _executeOperation(
 address token,
 uint256 amount,
 uint256 premium,
 address initiator,
 bytes calldata params
 ) internal override returns (bool) {
 // Your strategy logic here
 // Base contract handles approval automatically
 return true;
 }
}

JavaScript Integration (TronWeb)

const TronWeb = require('tronweb');
// Initialize TronWeb
const tronWeb = new TronWeb({
 fullHost: 'https://api.trongrid.io',
 privateKey: 'your_private_key'
});
// Get pool contract
const pool = await tronWeb.contract().at('POOL_ADDRESS');
// Check available liquidity
const liquidity = await pool.getAvailableLiquidity('TOKEN_ADDRESS').call();
console.log('Available:', liquidity.toString());
// Deposit liquidity
await pool.deposit('TOKEN_ADDRESS', '1000000000000').send({
 feeLimit: 200_000_000
});
// Initiate flash loan (from receiver contract)
const receiver = await tronWeb.contract().at('YOUR_RECEIVER_ADDRESS');
await receiver.requestFlashLoan(
 'TOKEN_ADDRESS',
 '1000000000000',
 '0x' // params
).send({ feeLimit: 500_000_000 });

Deployment

Network Configuration

Deploy Commands

# Local development
npm run migrate
# Nile Testnet
npm run migrate:nile
# Shasta Testnet
npm run migrate:shasta
# Mainnet (CAUTION!)
npm run migrate:mainnet

Post-Deployment Checklist

Security

Security Features

Attack Mitigations

Audit Status

Fee Structure

Revenue Example

Development

Project Structure

JustFlash/
├── contracts/
│ ├── interfaces/ # Contract interfaces
│ │ ├── IFlashLoanReceiver.sol
│ │ ├── IFlashLoanPool.sol
│ │ ├── IFeeCollector.sol
│ │ └── IPoolRegistry.sol
│ ├── core/ # Core protocol contracts
│ │ ├── FlashLoanPool.sol
│ │ ├── FeeCollector.sol
│ │ └── PoolRegistry.sol
│ └── adapters/ # Integration adapters
│ ├── FlashLoanReceiverBase.sol
│ ├── JustLendLiquidator.sol
│ └── SunSwapArbitrage.sol
├── frontend/ # SvelteKit dashboard
├── scripts/ # Deployment & bootstrap scripts
├── test/ # Contract tests
├── migrations/ # TronBox migrations
├── docs/ # Documentation
├── docker-compose.yml # Local development setup
├── tronbox.js # TronBox configuration
└── package.json

Commands

npm run compile # Compile contracts
npm run test # Run tests
npm run lint # Lint Solidity files
npm run migrate # Deploy contracts
npm run bootstrap # Seed liquidity
npm run console # TronBox console

External Integrations

JustLend (5ドル.95B TVL)

SunSwap DEX

Resources

License

Disclaimer