Powered byTroptions
LIVE for Power Clients

Flash Loans.
Live Now on Base.

One contract.
Aave V3.
Your strategy.
We deploy it.

Power clients only. Closed tonight.

Isolated Wallets Aave V3 Base You Control Strategy
flash.ts

      
LIVE
Power Client Access
Now on Base
Aave V3 Primary
Custom
Flash Wallets (power)
Open source + on-chain
For power clients

Power Client Flash Wallets – Live Tonight

You write the alpha.
We set up the wallet and close the deal.

  • Isolated per-client smart contract (your own receiver)
  • Deployed on Base (Aave V3)
  • You control the executeOperation() logic
  • Non-custodial. Sovereign. No shared infrastructure
  • We handle deployment, verification, and initial testing

You want to hunt liquidations? Run arb? Do whatever the fuck you want. You write it, we ship the contract.

Minimum: $25k upfront or 20% profit share.

Request Power Client Onboarding

Qualified clients only. KYB + minimum volume. Contact via troptions or direct.

The Full Data Story

Flash Loans. Your Personal Money Printer. Private Alpha.

You are building a Power Client Flash Loan Service on Base chain using Aave V3. Normal people need collateral to borrow. You don’t. Borrow millions for seconds, do magic, pay back in same tx. Profit stays. Loss = tx reverts, lose only gas.

1. The FlashWallet (Your Personal Money Printer)

This is a custom smart contract deployed just for you. Like your own private trading bot that lives on the blockchain. Isolated per-client receiver.

2. The Strategy (Your Brain)

The code you write that says: “Borrow USDC → do some trades → make profit → pay back the loan.” Lives inside executeOperation. You write the alpha. We deploy and close.

3. The Manager (The Boss)

A system that creates these wallets for different clients (you, Sravan, etc.) and keeps everything organized. Power clients only. Closed tonight. Min $25k or 20% profit share.

Next Step (you choose):
• Simple test that just borrows and repays?
Basic arbitrage example (chosen — USDC borrow → Aerodrome WETH → back → profit → repay)
• A liquidation hunter?

Here’s Your First Real FlashWallet Contract (Ready to Test)

Exact as provided. Deploy per client. Fill strategy. We close.

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {FlashLoanSimpleReceiverBase} from "@aave/core-v3/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol";
import {IPoolAddressesProvider} from "@aave/core-v3/contracts/interfaces/IPoolAddressesProvider.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract FlashWallet is FlashLoanSimpleReceiverBase {
    address public owner;

    event FlashLoanExecuted(address asset, uint256 amount, uint256 profit);

    constructor(address _addressProvider) 
        FlashLoanSimpleReceiverBase(IPoolAddressesProvider(_addressProvider))
    {
        owner = msg.sender;
    }

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        
        uint256 totalOwed = amount + premium;

        // ============================
        // YOUR STRATEGY GOES HERE
        // This is where the magic happens
        // ============================

        // Example: Just repay for testing
        IERC20(asset).approve(address(POOL), totalOwed);

        uint256 profit = 0; // Change this when you make money
        emit FlashLoanExecuted(asset, amount, profit);

        return true;
    }

    function requestFlashLoan(address _asset, uint256 _amount) external {
        require(msg.sender == owner, "Only owner");
        
        POOL.flashLoanSimple(
            address(this),
            _asset,
            _amount,
            "",
            0
        );
    }

    function withdraw(address _asset) external {
        require(msg.sender == owner, "Only owner");
        IERC20(_asset).transfer(owner, IERC20(_asset).balanceOf(address(this)));
    }
}

See full power client templates + BasicArb + LiquidationHunter + AerodromeArb in contracts/src/power-clients/. Also in flash-system/ at repo root.

Maximum Privacy for Alpha

The Private ZK Flash Loan System

Every flash loan on Aave is completely public — everyone sees exactly what you borrowed, what strategy you ran, and how much profit you made. That's bad for alpha. The ZK version hides your strategy while still proving to the blockchain that you repaid the loan correctly.

Different Types of ZK Approaches (Easiest → Hardest)

  • 1. Easiest & Fastest (What you should do first) — Railgun Shielded Flash Loans
    Use an existing privacy protocol (Railgun) on Base or Ethereum. Deposit funds into a shielded pool first, then do private transactions from there. Fastest to get running. Least custom work. Good privacy, but not 100% invisible.
  • 2. Medium (Best balance) — Noir + Aztec/Noir tooling on Base
    Use Noir language to write private circuits. Prove that your executeOperation() did the right math without showing the actual trades. More private than Railgun. Still somewhat realistic in 2026.
  • 3. Hardest & Most Private — Custom ZK Circuit + Aave Flash Loan
    You build a full zero-knowledge proof that verifies your entire strategy executed correctly. The on-chain contract only sees a proof, not your logic. Maximum privacy. Very heavy on computation and proof size.

Contracts Map (The Pieces You Need)

  • Main FlashWallet Contract — The one that receives the flash loan from Aave (this one stays mostly public).
  • ZK Verifier Contract — A separate contract that verifies your zero-knowledge proofs.
  • Shielded Pool / Privacy Layer — Railgun or Aztec contract that hides the actual movement.
  • Strategy Prover — Off-chain tool that generates the ZK proof before you call the flash loan.

Timeline & Complications (Realistic 2026 View)

Fastest Path (1–2 weeks): Use Railgun on Base. Very available right now. Low complications. Good enough privacy for most people. Almost no one else is doing complex ZK flash loans yet.

Realistic Strong Privacy (2–6 weeks): Build with Noir. Proof generation happens off-chain on your machine. You submit the proof + minimal public data on-chain. Gas costs will be noticeably higher.

Main Complications: ZK proof generation is slow and eats your CPU/GPU. Gas fees much more expensive. Debugging ZK circuits is painful as fuck. Very few people actually run fully private flash loans — you’ll be mostly alone. Aave itself is public, so the initial borrow call is visible (you can only truly hide what happens inside the strategy).

Recommendation for you right now: Start with the Railgun approach — it's the easiest, fastest, and most available today with almost no competition. Once that’s working and you understand how the privacy flows, we can go deeper into custom Noir circuits.

Exact Railgun flow + adapter stub + off-chain prover mapped in flash-system/RAILGUN_INTEGRATION.md and contracts/src/railgun/. Includes shield/unshield adapter + TS prover stub.
Treasury Evidence / On-Chain Proof

XRP Treasury Sample — $1.2617 • Tx 8E263217...

Validated payment used as PoF / funding evidence for power client onboarding, EMD, escrow, or shielded flash capital. 20 XRP ≈ $29.42 at $1.2617.

Transaction Details
8E26321733467C94A1A4291381AA06EA737ACA0EDBF66F6738606B7779DE4F38

The transaction was successful and validated in the ledger #104159942 (index: 32).

TypePayment
Validated22 days ago (5/11/2026, 11:19:30 AM)
SourceALLHEART
rnJrjec2vrTJAAQUTMTjj7U6xdXrk9N4mT
DestinationrfbZzM6SGZHbfxrg85vyeKSEMMQCfNXTNw
Destination tag 1001
Delivered amount20 XRP ≈ $29.42
Ledger fee0.006 XRP ≈ $0.008826
Transaction linkhttps://bithomp.com/tx/C6355AC600200000

Additional data | Balance changes | Raw data | Tx Metadata available on Bithomp. Sponsored: Earn 12% on XRP | Play Slots and win 70,000 XRP ❤️

Bithomp — XRP Ledger Explorer since 2015. Used here as sample treasury / PoF packet for McKinzey EMD ($50k target), troptions-escrow-pof, or power client flash capital funding. Combine with DealSPV ZK 5-proofs + FlashRouter best rates for liquidity calls.

Light mode / dark mode: site supports data-theme toggle (see header + styles.css). Address / Connect / Bithomp Pro flows mirrored in docs for explorer-style proof presentation.

The problem

Four providers. Four integrations. One full-time job.

Every flash-loan provider has a different interface, different fees, different chains and different gas profiles. Integrating one is hard. Integrating four is a maintenance burden you carry forever.

Before Fragmented, per-provider
the_old_way.ts
// Aave V3 — premium 0.05%, ERC-3156-ish
await pool.flashLoanSimple(recv, asset, amt, params, 0);

// Balancer V2 — 0% fee, vault callback
await vault.flashLoan(recv, tokens, amounts, data);

// Uniswap V3 — flash() per-pool, fee tiers
await pool.flash(recv, amt0, amt1, data);

// Maker DSS-Flash — DAI only, 0% fee
await dss.flashLoan(recv, dai, amt, data);

// + per-chain addresses, gas tuning, fee math…
After One FlashRouter call
the_flashrouter_way.ts
import { FlashRouter } from "@flashrouter/sdk";

const fr = new FlashRouter({ chain: "base" });

// Best provider + lowest fee, picked for you.
await fr.borrow({
  asset: "USDC",
  amount: 5_000_000,
  execute: myStrategy,   // your callback
});

// Same code on Ethereum, Arbitrum, Optimism…
How it works

A smart router between your strategy and every lender.

You call FlashRouter once. It quotes every integrated provider, selects the cheapest viable route, executes your logic and settles — all inside a single atomic transaction.

Your dApp fr.borrow() Smart Router quote · rank · route best fee selected Aave V3 Balancer V2 Uniswap V3 Maker DSS Execute your callback Settle 1 tx
01

Request

Call borrow() with an asset and amount. No provider plumbing.

02

Quote & rank

The router quotes every lender on-chain and ranks by fee and available liquidity.

03

Route

The cheapest viable lender is selected automatically and the loan is opened.

04

Execute

Your callback runs with borrowed capital — arbitrage, liquidate, swap, refinance.

05

Settle

Principal and fee repay in the same transaction. Reverts atomically if it can't.

Coverage

The lenders and chains, behind one interface.

Add a provider or a chain by changing a config string — not by rewriting your integration.

Lender protocols

Aave
V3 · simple flash
Balancer
V2 · vault, 0% fee
Uniswap
V3 · pool flash
MakerDAO
DSS-Flash · DAI

Supported chains Live at launch

Ethereum
Base
Arbitrum
Optimism
BNB Chain
Polygon

Roadmap Not yet shipping

Tron PHASE 2
Non-EVM · separate adapter · no launch date
Three ways to build

From raw SDK to fully managed.

Whether you write Solidity by hand, assemble strategies in a browser, or want us to run the bots, FlashRouter meets your team where it is. Power clients: direct custom FlashWallet receivers for immediate closed access on Base (Aave V3).

Self-serve

FlashRouter SDK

A TypeScript SDK and REST API for developers who want full control. One interface, optimal routing, every chain. Power clients: use direct custom FlashWallet receivers for immediate closed access (Aave V3 Base).

  • TypeScript & Solidity bindings
  • On-chain quote & route engine
  • Simulation and gas estimation
  • Self-hosted or hosted RPC
No-code web app

Strategy Builder

Compose flash-loan strategies visually — borrow, swap, liquidate, repay — and deploy them without writing a contract.

  • Drag-and-drop strategy graph
  • Live simulation before deploy
  • Templates for common plays
  • One-click multi-chain deploy
Fully managed

Managed Bots

We run production strategies on your behalf. You provide capital or a subscription; we operate, monitor and tune the bots.

  • 24/7 monitored execution
  • Arbitrage & liquidation desks
  • Performance dashboard
  • 20% profit share, no lock-up
Built for

Capital-efficient strategies, in one transaction.

Arbitrage

Borrow, buy low on one venue, sell high on another, repay — all atomically, with zero starting capital.

Liquidations

Flash-borrow the repay asset, seize undercollateralized positions and capture the bonus without pre-funding.

Collateral swaps

Swap the collateral backing a loan in a single transaction, never unwinding or risking liquidation.

Refinancing

Move debt from a high-rate market to a cheaper one instantly, without finding interim capital.

Self-liquidation

Close your own at-risk position on your terms, avoiding the liquidation penalty entirely.

MEV

Bundle flash liquidity into searcher strategies and submit through your preferred relay.

Power Client Wallets

Isolated custom receivers for qualified clients. You write the alpha in executeOperation (liqs, arb, whatever), we deploy and close tonight.

In practice

A working arbitrage strategy, end to end.

Borrow USDC, route a swap across two DEXs, repay the loan and keep the spread — the router picks the cheapest lender automatically.

arbitrage.ts
import { FlashRouter, swap } from "@flashrouter/sdk";

const fr = new FlashRouter({ chain: "arbitrum", signer });

// Borrow 2M USDC. FlashRouter ranks Aave / Balancer /
// Uniswap / Maker by fee + liquidity and routes for you.
const result = await fr.borrow({
  asset: "USDC",
  amount: 2_000_000,
  execute: async (ctx) => {
    // 1. Buy WETH cheap on Uniswap
    const weth = await swap(ctx, { dex: "uniswap",
      from: "USDC", to: "WETH", amount: ctx.amount });

    // 2. Sell it back richer on Curve
    return swap(ctx, { dex: "curve",
      from: "WETH", to: "USDC", amount: weth });
  },
});

// Loan + fee repaid atomically. Spread is yours.
console.log(result.profit, result.provider, result.feeBps);

// Power client direct wallet (closed tonight, no router needed for your strategy)
const wallet = new ethers.Contract(POWER_WALLET_ADDR, ABI, signer);
await wallet.requestFlashLoan(USDC, amount, yourStrategyParams); // alpha lives in the deployed wallet's executeOperation
Pricing

Start free. Pay as you route.

A flat 2 bps on flash-loan notional applies across all tiers. SaaS plans add higher rate limits, support and managed services.

Free
$0

For prototypes and solo builders shipping their first strategy.

  • Full SDK & REST API access
  • All 6 chains, all 4 providers
  • 25,000 API calls / month
  • Community support
  • 2 bps on routed notional
Get API Key
Enterprise
Contact us

For funds and protocols at scale, with managed execution.

  • Everything in Pro
  • Unlimited / metered API
  • Managed Bot Platform (20% profit share)
  • Custom volume pricing on bps
  • KYB onboarding, dedicated engineer
  • Power Client Flash Wallets (custom isolated receivers, closed tonight)
Talk to sales
Compliance & security

Infrastructure you can put real capital behind.

FlashRouter never touches your funds. Everything that moves value is on-chain and independently verifiable. Base (Aave V3) live for power clients now. Full router + multi-provider in Q3 after audits. Custom flash wallets deploy immediately for qualified clients.

Audit-bound deploys (full router)

Two independent audits (Spearbit-tier + Trail of Bits-tier) required before any mainnet deploy of the full multi-provider router. Power client flash wallets (custom Aave V3 Base receivers) are deployed immediately on mainnet for qualified clients. Reports publish with SHA-256 hashes. Audit plan.

Non-custodial by design

FlashRouter never holds, escrows or pools user funds. Capital only ever exists inside your own atomic transaction.

Open-source SDK

The SDK and routing logic are open source under a permissive license. Read it, fork it, run your own RPC.

On-chain transparency

Every route, fee and settlement is emitted on-chain. Reconcile our metrics against block explorers at any time.

KYB for enterprise

Managed services and enterprise volume include know-your-business onboarding and contractual SLAs.

No fake-token or flash-USDT scams

FlashRouter is real DeFi infrastructure. We do not support, enable or tolerate fake-token minting or "flash USDT" balance-spoofing schemes. Accounts attempting them are terminated.

Borrow billions in one transaction.

Ship your first flash-loan strategy in an afternoon. Free to start, no card required.

Powered byTroptions