The Problem: Two Worlds, Disconnected

Today’s financial world suffers from a fundamental disconnect. On one side, a huge pool of global trading talent is locked out of professional careers for lack of capital. On the other, the largest pool of liquid capital in modern history—DeFi—is locked out of sustainable yield because it lacks trustworthy, real-world connections.

The Broken Ladder: The Prop Firm Paradox

The proprietary trading (prop-firm) industry is built on the compelling promise that traders who prove their skill can trade a firm's capital, sharing in the profits without risking their own money. This "funded trader" model offers a direct pathway to a professional trading career based on merit, not personal wealth. The appeal of this model is experiencing explosive growth in global interest, a surge that is especially prominent in emerging markets.

However, this growth masks a broken system plagued by a crisis of trust and scalability:

• Conflict of Interest: Most firms use opaque, off-chain capital, creating a model where they often profit more when traders fail their evaluations.
• Failure to Scale: Relying on finite private balance sheets, these firms cannot meet the immense global demand for capital.
• Opacity and Risk: Operations are a black box with no transparency into capital reserves, leading to frequent insolvencies and scams.

The Solution: An On-Chain Career Ladder

Tenxto is the bridge. We solve this disconnect by creating a self-reinforcing economic flywheel that connects on-chain liquidity with regulated, off-chain trading. We aren’t just building a better prop firm; we are building the world's first on-chain career ladder for traders.

For Traders: A Clear Path to a Career

Tenxto offers a merit-based path to professional trading with access to a deep, scalable, and provably real pool of capital. Our innovative "Proof of Skill" evaluations mean that talent—not wealth—is the only requirement for success.

For DeFi LPs: A New Source of Real Yield

Tenxto gives Liquidity Providers access to a new, sustainable asset class: real-world yield generated by global trading markets. This stable, non-speculative return is sourced from evaluation fees, profit splits, commissions, and our own AI trading engine, all secured by institutional-grade security.

Providing Liquidity

Providing liquidity to Tenxto is a straightforward process that allows you to earn real-world yield from our global trading ecosystem. The on-chain foundation of our ecosystem is the Capital Layer, where users deposit capital to receive this yield.

How to Deposit

1. Connect Your Wallet: Start by connecting a compatible Web3 wallet to the Tenxto application.
2. Select a Pool: Navigate to the "Pools" section. We will launch with multi-asset pools for USDC and ETH, with a wBTC pool planned post-launch.
3. Deposit Capital: Enter the amount you wish to deposit and approve the deposit() transaction in your wallet.
4. Receive Receipt Tokens: Upon a successful deposit, the contract mints and sends you an equivalent amount of a yield-bearing liquid receipt token (e.g., tUSDC or tETH). These tokens represent your share of the pool and can be freely traded or used in other DeFi protocols.

The Withdrawal Process

Because our underlying assets—capital deployed with traders—are not instantly liquid, we have designed a sophisticated hybrid model called the Buffered & Epoch-Based Withdrawal System to ensure fairness, transparency, and stability.

Core Concepts

• On-Chain Liquidity Buffer: A configurable percentage of total assets is required to be held liquid in the smart contract at all times. This ensures a predictable amount of capital is available to service withdrawals.
• Withdrawal Epochs: User withdrawal requests are batched into time-based periods called "epochs". This prevents a "first-come, first-served" race condition and ensures fair, proportional fulfillment of all requests.
• Merkle Tree Claims: For maximum gas efficiency and decentralization, withdrawal fulfillment is handled via a Merkle tree. After an epoch ends, a trusted Keeper calculates claims off-chain and submits a single Merkle root to the contract. Users can then use a Merkle proof to claim their funds directly.

The Withdrawal Lifecycle: Step-by-Step

1. Request (On-Chain): A user calls requestWithdrawal(), locking their receipt tokens and creating a pending request in the current epoch.
2. Epoch Ends: The epoch concludes (e.g., after 24 hours), and no new requests can be added to it.
3. Calculation (Off-Chain): A trusted Keeper service queries all requests in the epoch and determines the pro-rata fulfillment percentage based on available liquidity.
4. Finalization (On-Chain): The Keeper generates a Merkle tree of all valid claims and submits the final Merkle root to the smart contract via submitWithdrawalMerkleRoot(). This single transaction finalizes the outcome for all users in the epoch.
5. Claim (On-Chain): The user receives their unique Merkle proof from the Tenxto frontend and calls claimWithdrawal(). The contract verifies the proof, burns the receipt tokens, and sends the underlying asset to the user. Any unfulfilled portion is automatically rolled over.

Paths to Get Funded

Our Meritocratic Talent Engine is designed to find and fund the world's best traders. We offer two innovative "Proof of Skill" pathways to a funded account, catering to both new and experienced traders.

🏆 The Genesis Ascent: Airdrop Overview

The "Tenxto Genesis Ascent" is not a traditional airdrop; it is a strategic economic mobilization event designed to bootstrap our multi-sided marketplace from day one. We believe an airdrop is not a marketing expense but an act of economic creation.

The campaign is framed as a journey where every participant—LPs, Traders, and Partners—climbs an "on-chain career ladder". Your final TENX token allocation will be a direct reflection of the verifiable value you contribute to the ecosystem.

This is achieved through a meticulously engineered, points-based system that creates a powerful, self-reinforcing flywheel of value, inspired by the cutting-edge practices of protocols like Ethena, EigenLayer, and Blast.

Earning TENX Points

The points system is the engine of the Genesis Ascent. It is designed to be transparent and fair, rewarding actions that generate tangible value for the Tenxto protocol. A live dashboard will track your progress and display global leaderboards to foster healthy competition.

The system is bifurcated to address our two primary user groups: capital providers (LPs) and talent (Traders).

Points Allocation Matrix

Key Differentiator: Rewarding Skill

A critical innovation in our design is the shift from rewarding mere activity to rewarding demonstrable skill. By heavily rewarding realized profit (P&L), we create a powerful narrative: "At Tenxto, your skill doesn't just earn you profits; it earns you ownership of the platform you trade on".

The TENX Catalyst Partner Program

The TENX Catalyst program is a strategic B2B2C incentive model designed to power our global user acquisition by transforming partners from transactional affiliates into aligned ecosystem builders. It is heavily inspired by the successful "Blast Gold" distribution model from Blast.

How It Works

1. Curated Partners: The program is for vetted, reputable partners like trading educators, prop firm reviewers, and key opinion leaders (KOLs) with established audiences in our target regions.
2. Performance-Based Allocation: A dedicated pool of TENX rewards, branded as TENX Catalyst, is distributed to these partners regularly. The amount each partner receives is determined by a transparent, on-chain formula based on the economic activity (fees, volume, P&L) generated by their referred users.
3. Mandatory Pass-Through: The core mechanic is a programmatically enforced requirement for partners to pass through the vast majority (e.g., 90%+) of their Catalyst rewards to the end-users they onboarded. This creates a powerful, decentralized user acquisition engine.

This system creates a virtuous cycle: partners are incentivized to attract and educate successful traders, which increases the value their community generates, which in turn increases the partner's next Catalyst allocation, allowing them to offer even greater rewards.

Vesting & Anti-Sybil Rules

A successful launch is measured by long-term stability, not initial hype. We are implementing a robust set of anti-dumping and fair play mechanisms to fortify the TENX token economy from day one.

Multi-Tiered Airdrop Vesting

To balance user experience with market stability, we will use a tiered vesting schedule based on final points ranking. This provides immediate liquidity to the broad community base while neutralizing the market impact of the largest "whale" recipients. This structure will be communicated transparently from the start of the campaign.

The "Loyalty Lock" Multiplier

To convert airdrop recipients into long-term stakeholders, we will introduce a powerful post-TGE incentive. Immediately after the TGE, a 7-day "Loyalty Lock" window will open. Users who choose to stake their new TENX tokens or provide liquidity during this window will receive a permanent, significant points multiplier (e.g., 2.0x) on all points earned in future seasons. This transforms the airdrop from a one-time payout into a foundational asset that enhances a user's future earning potential.

Sybil Resistance Protocol

To ensure fair distribution, we will employ a multi-faceted defense against Sybil attacks:

• On-Chain Heuristics: Analyzing wallet histories to flag classic Sybil behavior, such as being newly created and funded from a single source.
• Platform Engagement Hurdles: Requiring simple, non-financial tasks like joining social channels or passing a quiz to add friction for bot farmers.
• Mandatory KYC/AML: A built-in defense for the capital-providing side of the ecosystem.
• Transparent Geolocation Policies: Learning from the mistakes of others, all geographic restrictions will be stated clearly and upfront.

System Architecture

Tenxto's architecture is built in three distinct layers, with our OES Custodian acting as a firewall to deliver institutional-grade safety and trust.

1. The Capital Layer (DeFi Protocol): The on-chain foundation where users deposit capital into multi-asset pools (USDC, ETH, wBTC) to earn yield. Users receive liquid, yield-bearing receipt tokens (tUSDC, tETH) in return.
2. The Trust Layer (OES Custodian): Our most critical innovation. All capital from the DeFi protocol is held by a regulated, third-party Off-Exchange Settlement (OES) Custodian. This ensures protocol capital is always segregated and never held on the brokerage's balance sheet, eliminating the primary counterparty risk of the prop firm industry. The custodian acts as a secure bridge, settling only the net Profit and Loss (P&L) with the brokerage, meaning the principal is never exposed to operational risk.
3. The Revenue Layer (Brokerage & Engines): Where commercial activity happens, generating real-world revenue to power the ecosystem. This includes our fully licensed brokerage, the "Proof of Skill" evaluation engine, and a proprietary AI Trading Engine that deploys idle capital to generate additional yield.

The TENX Token

The TENX token is the economic engine of Tenxto. It is a real-yield utility token designed to capture value from all platform revenue streams—commissions, spreads, profit splits, and evaluation fees—and distribute it back to the community.

Token Utility

• Staking & Yield (sTENX): TENX holders can stake their tokens to receive sTENX. All platform revenue is sent to the DAO Treasury, which then programmatically buys back TENX on the open market and distributes it to sTENX stakers. This gives stakers a direct share of the platform's real-yield profits.
• Governance: sTENX holders gain voting rights in the Tenxto DAO, empowering them to guide the future of the protocol.
• Loyalty Multipliers: Holding TENX or sTENX gives users a permanent points multiplier in all future rewards campaigns, rewarding our most dedicated community members.

Token Allocation

Governance: A Community-Owned Future

Tenxto is governed by its community through a decentralized autonomous organization (DAO), where sTENX holders direct the future of the protocol via secure, on-chain voting.

How It Works

• On-Chain Voting: sTENX holders can vote on proposals that determine everything from protocol fees and platform upgrades to treasury grants.
• Security: The process includes delegation, quorum requirements for major decisions, and a time-lock on all approved proposals for security.
• Committees: To improve efficiency, the DAO elects specialized committees for Treasury, Security, and Growth. The Treasury is managed by its committee through a multi-signature wallet, with every transaction visible on-chain for full community oversight.

Smart Contract Overview

The Tenxto protocol is a system of smart contracts built on a secure and modular architecture. The contracts are built using the most widely audited and secure base contracts from the OpenZeppelin library, including for ERC20, AccessControl, Pausable, ReentrancyGuard, and MerkleProof implementations.

Roles & Permissions

The protocol uses a granular AccessControl system to manage permissions, adhering to the principle of least privilege to minimize the impact of a single key compromise.

• DEFAULT_ADMIN_ROLE: The Tenxto Foundation's multi-sig. This role can grant/revoke other roles and update key parameters like the liquidity buffer and epoch duration.
• CUSTODIAN_ROLE: A secure, operational multi-sig wallet. This is the only address authorized to transfer capital from the pool to the off-chain custodianWallet.
• KEEPER_ROLE: A trusted, automated service responsible for off-chain calculations and submitting the final Merkle root to the contract for each epoch.
• PAUSER_ROLE: An emergency-only role that can pause and unpause all critical functions of the contract to protect user funds in unforeseen circumstances.

Liquidity Pool Contracts

The TenxtoUsdcPool and TenxtoEthPool contracts form the Capital Layer of the ecosystem. They are functionally identical, differing only in their handling of an ERC20 token (USDC) versus a native asset (ETH). Below is an overview of their key functions.

Core User Functions

• deposit(): The entry point for LPs. The user transfers assets and the contract mints an equivalent amount of receipt tokens.
• requestWithdrawal(uint256 _amount): A user signals their intent to withdraw. The contract takes their receipt tokens and creates a pending request in the current epoch.
• cancelWithdrawalRequest(): Allows a user to cancel a pending request, but only if the epoch has not yet been finalized.
• claimWithdrawal(uint256 _epochId, uint256 _claimAmount, bytes32[] calldata _merkleProof): The final step. The user provides a Merkle proof to claim their fulfilled withdrawal after an epoch is finalized.

Admin and Keeper Functions

• submitWithdrawalMerkleRoot(uint256 _epochId, bytes32 _merkleRoot): Called by the KEEPER_ROLE to submit the Merkle root that finalizes an epoch's withdrawal outcomes.
• transferToCustodian(uint256 _amount): Called by the CUSTODIAN_ROLE. Moves capital to the off-chain custodian, but only if the transfer does not violate the required on-chain liquidity buffer.
• setLiquidityBuffer() / setEpochDuration(): Admin functions for the DEFAULT_ADMIN_ROLE to adjust key protocol parameters.
• pause() / unpause(): Emergency controls for the PAUSER_ROLE.

Contract Code Example (TenxtoUsdcPool)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./TenxtoReceiptToken.sol";

contract TenxtoUsdcPool is AccessControl, Pausable, ReentrancyGuard {
    bytes32 public constant CUSTODIAN_ROLE = keccak256("CUSTODIAN_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant KEEPER_ROLE = keccak256("KEEPER_ROLE");

    // --- State Variables ---
    IERC20 public immutable underlyingAsset;
    TenxtoReceiptToken public immutable receiptToken;
    
    // --- User Functions ---
    function deposit(uint256 _amount) external whenNotPaused nonReentrant {
        require(_amount > 0, "Deposit must be > 0");
        underlyingAsset.transferFrom(msg.sender, address(this), _amount);
        receiptToken.mint(msg.sender, _amount);
        emit Deposited(msg.sender, _amount);
    }

    function claimWithdrawal(
        uint256 _epochId,
        uint256 _claimAmount,
        bytes32[] calldata _merkleProof
    ) external whenNotPaused nonReentrant {
        bytes32 merkleRoot = epochMerkleRoots[_epochId];
        require(merkleRoot != bytes32(0), "Epoch not finalized");
        require(!hasClaimed[_epochId][msg.sender], "Already claimed");

        bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _claimAmount));
        require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Invalid Merkle proof");

        hasClaimed[_epochId][msg.sender] = true;
        receiptToken.burn(address(this), _claimAmount);
        underlyingAsset.transfer(msg.sender, _claimAmount);

        emit WithdrawalClaimed(msg.sender, _claimAmount, _epochId);
    }

    // --- Admin and Keeper Functions ---
    function submitWithdrawalMerkleRoot(
        uint256 _epochId,
        bytes32 _merkleRoot
    ) external onlyRole(KEEPER_ROLE) {
        require(_epochId < (block.timestamp / epochDuration), "Cannot finalize current epoch");
        require(epochMerkleRoots[_epochId] == bytes32(0), "Epoch already finalized");
        epochMerkleRoots[_epochId] = _merkleRoot;
        emit EpochFinalized(_epochId, _merkleRoot);
    }
}