Skip to main content

Overview

ChainFlow is a fully on-chain, trustless proprietary trading platform that revolutionizes how traders access capital. Built on Paxeer Network, ChainFlow eliminates centralized gatekeepers through smart contract-enforced rules, soulbound reputation NFTs, and automated profit distribution.

100% On-Chain

No centralized dependencies for trading logic

Trustless

Smart contracts enforce all rules

Automated

Instant evaluation and payouts

Why ChainFlow is Revolutionary

Traditional prop firms operate as black boxes with opaque processes, manual evaluations, and delayed payouts. ChainFlow solves these problems through radical transparency and automation.
All evaluation, risk gating, and profit distribution are automated with zero manual intervention. No more ad-hoc exceptions or opaque processes.
The rules are the same for everyone—open, immutable, and verifiable on the blockchain. No favoritism or hidden levers.
Deterministic on-chain logic allows the platform to support unlimited traders with instant access and payouts.

Architecture

ChainFlow’s architecture consists of 6 distinct layers with 11 interconnected smart contracts:

Layer 1: Core Libraries

Mathematical foundation powering PnL calculations, liquidations, and risk metrics.
ContractAddressPurpose
Math0xD4d37681FBd276d45B867A28668C09fB115C47DeAdvanced mathematical operations
SafetyChecks0x9EE12BEe3f246f4Cb30Be3b558b49ec9c60afB20Risk validation logic
PositionManager0xf233245A1Ed5A118c2e3085d564B03e87ADCd8D6Position tracking and management
View on Explorer →

Layer 2: Reputation System

Soulbound NFTs representing trader credentials and performance history.

ReputationNFT

Address: 0x202B81a89Adc1039656E78ea1749A038155d8540Features:
  • Non-transferable (soulbound)
  • Permanently bound to trader addresses
  • Prevents credential farming
  • On-chain performance history
View Contract →

Layer 3: Oracle Infrastructure

Decentralized price feeds with staleness protection and deviation limits.

Oracle Registry

Address: 0xA10506DEabD72f3708a7DAeB654b4925d0081253Central registry for price oracles

BTC/USD Oracle

Address: 0x729e3c277CDE256dBD54Af517998719Bc6a821B4Initial Price: $50,000.00

ETH/USD Oracle

Address: 0xc60792a2de58D4D822BF2C7fBA56528e0c3701C5Initial Price: $3,000.00
Features:
  • 5% maximum price deviation
  • Staleness protection
  • Modular design (add pairs without redeployment)

Layer 4: Treasury Management

Multi-vault system managing capital with sophisticated allocation logic.
VaultAddressBalancePurpose
TreasuryManager0x4B2E8B4850f9EDf3509eeeAf664f5D6Cc2178fF8500,000 USDCFirm capital
TradingVault0x7aA4C34351905Ea0521C3c327ED44558157bb5Ac200,000 USDCTrading capital
Total Deployed Capital: 700,000 USDC

Layer 5: Evaluation System

Virtual trading environment for trader qualification.

EvaluationManager

Address: 0xB03A50e11f9dF169B46dF31189A4544ad727Acb5Configuration:
  • Virtual Balance: 10,000 USDC
  • Profit Target: 10%
  • Max Drawdown: 5%
  • Minimum Trades: 5
View Contract →
Features:
  • Gas-efficient virtual position tracking
  • Off-chain execution with on-chain verification
  • 90% cost reduction vs fully on-chain

Layer 6: Production Trading

Funded trading vaults with automated profit distribution.

TraderVaultFactory

Address: 0x53A2d0aAF2d405C34940b8507003Af0D98f1CA12Configuration:
  • Initial Capital: 100,000 USDC per trader
  • Profit Split: 80% trader / 20% firm
  • Deterministic addresses (CREATE2)
View Contract →

How It Works

1

Trader Registration

User connects wallet and completes KYC verification
// Connect wallet
const { address } = useAccount();

// Register for evaluation
await evaluationManager.registerTrader();
2

Virtual Evaluation

Trader enters evaluation with virtual capitalRules:
  • 10,000 USDC virtual balance
  • Reach 11,000 USDC (10% profit)
  • Stay above 9,500 USDC (5% max drawdown)
  • Execute minimum 5 trades
// Open virtual position
await evaluationManager.openPosition(
  'BTC-USD',
  10000, // $10,000 size
  true,  // Long
  50000  // Entry price
);
3

Reputation NFT Issuance

Upon successful evaluation, receive soulbound NFT
// NFT automatically minted on evaluation success
const tokenId = await reputationNFT.tokenOfOwner(address);
const metadata = await reputationNFT.tokenURI(tokenId);
4

Funded Account Deployment

Factory deploys personal trading vault with real capital
// Factory creates funded vault
const vaultAddress = await traderVaultFactory.createVault(trader);
// Vault receives 100,000 USDC
5

Live Trading

Execute trades with real capital through trading vault
// Execute trade through vault
await traderVault.openPosition(
  'BTC-USD',
  50000, // $50,000 position
  true   // Long
);
6

Profit Distribution

Automatic 80/20 profit split on withdrawal
// Withdraw profits
await traderVault.withdrawProfits();
// 80% to trader, 20% to firm (automatic)

Smart Contract Interfaces

Evaluation Manager

IEvaluationManager
interface IEvaluationManager {
    // Register for evaluation
    function registerTrader() external;
    
    // Virtual trading
    function openPosition(
        string memory symbol,
        uint256 size,
        bool isLong,
        uint256 price
    ) external;
    
    function closePosition(uint256 positionId) external;
    
    // Check status
    function getEvaluationStatus(address trader) 
        external view returns (
            uint256 balance,
            uint256 profitTarget,
            uint256 maxDrawdown,
            uint256 trades,
            bool passed
        );
}

Trader Vault Factory

ITraderVaultFactory
interface ITraderVaultFactory {
    // Create funded vault
    function createVault(address trader) 
        external returns (address vault);
    
    // Query vault
    function getVault(address trader) 
        external view returns (address);
    
    // Vault configuration
    function getInitialCapital() 
        external view returns (uint256);
    
    function getProfitSplit() 
        external view returns (uint256);
}

Reputation NFT

IReputationNFT
interface IReputationNFT {
    // Soulbound NFT (non-transferable)
    function mint(address trader, string memory uri) external;
    
    // Query trader reputation
    function tokenOfOwner(address owner) 
        external view returns (uint256);
    
    function hasReputation(address trader) 
        external view returns (bool);
}

Integration Example

Complete example of integrating ChainFlow:
ChainFlowIntegration.ts
import { ethers } from 'ethers';

const EVALUATION_MANAGER = '0xB03A50e11f9dF169B46dF31189A4544ad727Acb5';
const REPUTATION_NFT = '0x202B81a89Adc1039656E78ea1749A038155d8540';
const FACTORY = '0x53A2d0aAF2d405C34940b8507003Af0D98f1CA12';

async function joinChainFlow(signer: ethers.Signer) {
  const evaluationManager = new ethers.Contract(
    EVALUATION_MANAGER,
    EVALUATION_MANAGER_ABI,
    signer
  );

  // 1. Register for evaluation
  const registerTx = await evaluationManager.registerTrader();
  await registerTx.wait();
  console.log('✅ Registered for evaluation');

  // 2. Trade in virtual environment
  const openTx = await evaluationManager.openPosition(
    'BTC-USD',
    ethers.parseUnits('10000', 6), // 10K USDC
    true,  // Long
    50000  // $50,000 entry
  );
  await openTx.wait();
  console.log('✅ Position opened');

  // 3. Check evaluation status
  const status = await evaluationManager.getEvaluationStatus(
    await signer.getAddress()
  );
  
  if (status.passed) {
    console.log('✅ Evaluation passed!');
    
    // 4. Get reputation NFT
    const repNFT = new ethers.Contract(REPUTATION_NFT, NFT_ABI, signer);
    const tokenId = await repNFT.tokenOfOwner(await signer.getAddress());
    console.log('✅ Reputation NFT ID:', tokenId);
    
    // 5. Get funded vault
    const factory = new ethers.Contract(FACTORY, FACTORY_ABI, signer);
    const vaultAddress = await factory.getVault(await signer.getAddress());
    console.log('✅ Funded vault:', vaultAddress);
  }
}

Technology Stack

Smart Contracts

  • Language: Solidity 0.8.20+
  • Framework: Hardhat
  • Libraries: OpenZeppelin
  • Testing: Mocha, Chai
  • Network: Paxeer Network (Chain ID: 229)
npm install --save-dev hardhat @openzeppelin/contracts
npx hardhat test

Key Features

Protocol Layer (Smart Contracts)

All performance metrics and rules are calculated and enforced by smart contracts:
  • Virtual balance tracking
  • Profit/loss calculation
  • Drawdown monitoring
  • Trade counting
  • Pass/fail determination
100% transparent and auditable.
Smart contracts automatically gate risky trades and enforce limits:
  • Maximum drawdown enforcement (5%)
  • Position size limits
  • Leverage restrictions
  • Real-time risk calculations
  • Automatic liquidation protection
Payouts triggered automatically upon successful evaluation:
  • 80% to trader
  • 20% to firm
  • No withdrawal delays
  • No manual approval needed
function withdrawProfits() external {
    uint256 profits = calculateProfits(msg.sender);
    uint256 traderShare = profits * 80 / 100;
    uint256 firmShare = profits * 20 / 100;
    
    // Automatic distribution
    usdc.transfer(msg.sender, traderShare);
    usdc.transfer(treasury, firmShare);
}
Non-transferable NFTs that permanently bind to trader addresses:
  • Cannot be sold or transferred
  • Prevents credential farming
  • Permanent performance record
  • Enables reputation-based features

Application Layer

Feature-rich interface with:
  • Limit & Market order forms
  • Real-time market data (WebSocket)
  • Portfolio views
  • Trading history
  • P&L analytics
Integrated KYC flows:
  • Progress visualization
  • Step-wise gating
  • Automated verification
  • Beta disclaimer acceptance
Comprehensive back-office for managing:
  • CRM: Users, roles, KYC, support tickets
  • Finance: Deposits, withdrawals, wallets
  • Trading: Futures, forex, staking, ICOs
  • System: Settings, announcements, logs

Deployed Contracts

Production Deployment

Deployment Date: October 4, 2025
Network: Paxeer Mainnet (Chain ID: 229)
Status: 🟢 Production Ready
Tests: 24/24 Passing ✅
LayerContractAddress
1Math0xD4d37681FBd276d45B867A28668C09fB115C47De
1SafetyChecks0x9EE12BEe3f246f4Cb30Be3b558b49ec9c60afB20
1PositionManager0xf233245A1Ed5A118c2e3085d564B03e87ADCd8D6
2ReputationNFT0x202B81a89Adc1039656E78ea1749A038155d8540
3OracleRegistry0xA10506DEabD72f3708a7DAeB654b4925d0081253
3BTC/USD Oracle0x729e3c277CDE256dBD54Af517998719Bc6a821B4
3ETH/USD Oracle0xc60792a2de58D4D822BF2C7fBA56528e0c3701C5
4TreasuryManager0x4B2E8B4850f9EDf3509eeeAf664f5D6Cc2178fF8
4TradingVault0x7aA4C34351905Ea0521C3c327ED44558157bb5Ac
5EvaluationManager0xB03A50e11f9dF169B46dF31189A4544ad727Acb5
6TraderVaultFactory0x53A2d0aAF2d405C34940b8507003Af0D98f1CA12

Getting Started

For Traders

1

Connect Wallet

Visit dashboard.paxeer.app and connect your wallet
2

Complete KYC

Verify your identity through the KYC process
3

Start Evaluation

Begin trading with 10,000 USDC virtual capital
4

Pass Evaluation

Achieve 10% profit with max 5% drawdown
5

Receive Funding

Get 100,000 USDC funded account automatically
6

Trade & Earn

Keep 80% of profits, firm keeps 20%

For Developers

git clone https://github.com/paxeer/chainflow
cd chainflow
pnpm install

API Documentation

REST Endpoints

GET /api/public/announcements
curl https://dashboard.paxeer.app/api/public/announcements
GET /api/settings
curl https://dashboard.paxeer.app/api/settings

WebSocket Streams

const ws = new WebSocket('wss://dashboard.paxeer.app/ws');

ws.onopen = () => {
  // Subscribe to market data
  ws.send(JSON.stringify({
    type: 'subscribe',
    channel: 'market.BTC-USD'
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log('Market update:', data);
};

Security & Compliance

Security is paramount. ChainFlow implements multiple layers of protection:

Protocol Security

  • ✅ OpenZeppelin security libraries
  • ✅ Role-based access control (RBAC)
  • ✅ Pausable emergency-stop
  • ✅ Reentrancy guards
  • ✅ SafeMath operations
  • ✅ Input validation
  • ✅ Event audit trail

Application Security

  • ✅ End-to-end TLS encryption
  • ✅ KYC verification
  • ✅ Fine-grained permissions
  • ✅ Input validation & sanitization
  • ✅ CSRF/XSS protection
  • ✅ Rate limiting
  • ✅ Comprehensive logging
Commission third-party security audit from:
  • Trail of Bits
  • OpenZeppelin
  • ConsenSys Diligence
Launch public bug bounty with rewards:
  • Critical: 10,00010,000 - 50,000
  • High: 5,0005,000 - 10,000
  • Medium: 1,0001,000 - 5,000
Start with limited capital:
  • Alpha: 10 traders, 10K each
  • Beta: 50 traders, 50K each
  • Production: Unlimited, 100K each

Deployment Statistics

Total Development Time: ~4 hours
Deployment Duration: 47 minutes
Failed Attempts: 5 (all resolved)
Final Tests: 24/24 passing ✅

Capital Deployed

  • Treasury Manager: 500,000 USDC
  • Trading Vault: 200,000 USDC
  • Total: 700,000 USDC

Gas Consumption

  • Total Deployment: ~0.02 ETH
  • Average per Contract: ~0.0018 ETH
  • All Transactions: < $1 total cost

Innovation Highlights

Soulbound Credentials

Non-transferable NFTs prevent credential farming and ensure authentic trader identity

Layered Treasury

Separated firm capital from trading capital for independent accounting and risk management

Virtual Evaluation

Gas-efficient evaluation using off-chain tracking with on-chain verification (90% cost savings)

Factory Pattern

CREATE2 deterministic addresses for predictable vault deployment

Modular Oracles

Add new trading pairs without redeploying core contracts

Automated Distribution

Smart contracts handle 80/20 profit split automatically

Roadmap

1

Phase 1: Alpha Testing

  • Internal testing with 5 traders
  • Frontend integration
  • Bug fixes and optimizations
2

Phase 2: Security Audit

  • Professional third-party audit
  • Bug bounty program launch
  • Security improvements
3

Phase 3: Public Beta

  • 50 trader limit
  • Real-time announcements
  • Community feedback
4

Phase 4: Full Launch

  • Unlimited traders
  • Additional trading pairs (10+ assets)
  • Advanced features (copy trading, automation)

Resources

Success Metrics

Capital Deployed

700,000 USDC

Contracts Deployed

11 Contracts

Test Coverage

24/24 Passing

What Makes ChainFlow Different

FeatureTraditional Prop FirmsChainFlow
Trust ModelCentralizedTrustless (Smart Contracts)
TransparencyOpaqueFully transparent on-chain
Evaluation TimeDays/WeeksReal-time
Payout Time7-30 daysInstant (automated)
Rule EnforcementManualAutomated (100%)
Credential PortabilityNoneSoulbound NFT
ScalabilityLimitedUnlimited
Profit SplitVariesFixed 80/20

Next Steps