Ascenda

Demo

About

What Ascenda Does Ascenda allows users to trade options, futures, and complex derivatives strategies on major stocks (Apple, Tesla, SPY) and other real-world assets with complete privacy. Unlike traditional brokers where your data gets sold to competitors, or current DeFi where every transaction is public, Ascenda uses cutting-edge encryption technology called FHEVM (Fully Homomorphic Encryption Virtual Machine) to keep all trading activity completely confidential—not even the platform operators can see your positions, trade sizes, or strategies. The Core Innovation The platform combines three breakthrough technologies: FHEVM for privacy (all trading data is encrypted at the smart contract level), 1inch's cross-chain infrastructure for optimal liquidity and execution across multiple blockchains, and Etherlink Layer 2 for MEV protection that prevents front-running and sandwich attacks. This creates something that has never existed before: institutional-grade derivatives trading with bank-level privacy on decentralized infrastructure. Who It's For Ascenda targets three primary markets: traditional traders moving from platforms like Interactive Brokers who want DeFi yields but need familiar tools and privacy; sophisticated crypto users who want to trade complex strategies without revealing their positions to competitors; and institutions (family offices, hedge funds) who require both regulatory compliance and complete confidentiality. The platform serves anyone who needs to execute sophisticated trading strategies without broadcasting their intentions to the market. Technical Implementation Built on Solidity smart contracts deployed on Etherlink, Ascenda integrates with Chainlink oracles for real-time price feeds and 1inch protocols for cross-chain settlement. The frontend is a professional React application that looks like traditional trading platforms but operates entirely on-chain. Users can execute everything from simple call/put options to complex multi-leg strategies like iron condors and straddles, all while maintaining complete privacy through encrypted smart contract calculations. Market Impact Ascenda addresses a $4 trillion derivatives market that currently has no privacy-preserving solution. By combining the sophistication of Wall Street tools with the transparency and yields of DeFi, while adding the privacy of Swiss banking, Ascenda creates essential infrastructure for the future of finance where privacy isn't a luxury but a necessity for competitive trading.

How it's made

# Ascenda Protocol: Technical Architecture & Implementation ## Core Architecture Overview Ascenda is a privacy-first derivatives trading platform built on **Etherlink** (Tezos Layer 2) leveraging **Fully Homomorphic Encryption (FHE)** for complete transaction privacy. The protocol enables users to trade complex derivatives strategies while keeping all position sizes, prices, and collateral amounts completely confidential. ## Key Technologies & Stack ### 1. Fully Homomorphic Encryption (FHE) - The Privacy Engine ```solidity // All sensitive data encrypted using fhEVM import {FHE, externalEuint64, euint64, ebool} from "@fhevm/solidity/lib/FHE.sol"; struct ConfidentialPosition { euint64 quantity; // Encrypted position size euint64 strikePrice; // Encrypted strike euint64 premium; // Encrypted premium euint64 collateralAmount; // Encrypted collateral } ``` **Why FHE was crucial:** - Enables computations on encrypted data without decryption - Users can trade derivatives without revealing position sizes or prices - Market makers can't front-run based on order flow - Complete privacy preservation while maintaining smart contract logic ### 2. Etherlink (Tezos L2) - The Settlement Layer ```javascript // Hardhat configuration for Etherlink networks networks: { etherlinkMainnet: { url: "https://node.mainnet.etherlink.com", accounts: [deployerPrivateKey], }, etherlinkTestnet: { url: "https://node.ghostnet.etherlink.com", accounts: [deployerPrivateKey], }, } ``` **Benefits of Etherlink:** - EVM-compatible with lower fees than Ethereum mainnet - Native FHE support through fhEVM integration - Fast finality for derivatives trading - Seamless bridging to other chains ### 3. Cross-Chain Settlement Architecture #### Atomic Swap Engine ```solidity struct AtomicSwapEscrow { bytes32 escrowId; address initiator; address participant; euint64 amount; // Encrypted amount bytes32 secretHash; // HTLC secret hash uint256 timelock; bool redeemed; } ``` **Cross-chain flow:** 1. User initiates settlement with encrypted amounts 2. Resolver locks funds on destination chain 3. Secret reveal enables atomic completion 4. Fallback timelock prevents fund loss #### 1inch Fusion+ Integration ```solidity interface IFusionProtocol { struct FusionOrder { address makerAsset; address takerAsset; bytes getMakerAmount; // Dynamic pricing bytes getTakerAmount; bytes predicate; // Conditional execution } } ``` **Fusion+ advantages:** - Dutch auction mechanism for optimal pricing - Gasless trading experience - MEV protection through sealed bids - Professional resolver network ## Core Protocol Components ### 1. Confidential Collateral System ```solidity contract AscendaConfidentialCollateral is ConfidentialFungibleToken { // Wraps USDC/USDT into encrypted tokens function confidentialDeposit(address to, uint256 amount) external { uint64 confidentialAmount = SafeCast.toUint64(amount / _rate); euint64 encryptedAmount = FHE.asEuint64(confidentialAmount); _mint(to, encryptedAmount); } // Async decryption for withdrawals function finalizeUnwrap(uint256 requestId, uint64 amount, bytes[] calldata signatures) external { FHE.checkSignatures(requestId, signatures); _underlying.safeTransfer(to, publicAmount); } } ``` **Privacy-preserving features:** - All balances encrypted using FHE - Only user can decrypt their own balance - Authorized contracts can operate on encrypted amounts - Async decryption prevents front-running ### 2. Derivatives Engine ```solidity function openConfidentialPosition( string calldata underlying, PositionType positionType, externalEuint64 encryptedQuantity, externalEuint64 encryptedStrikePrice, uint256 expiration, externalEuint64 encryptedCollateral, bytes[] calldata proofs ) external returns (uint256 positionId) { // All operations on encrypted data euint64 quantity = FHE.fromExternal(encryptedQuantity, quantityProof); euint64 pnl = _calculateConfidentialPnL(position, currentPrice); } ``` **Derivative types supported:** - Options (calls/puts) - Futures contracts - Complex multi-leg strategies - Synthetic asset exposure ### 3. Complex Strategy Engine ```solidity enum StrategyType { BULL_CALL_SPREAD, BEAR_PUT_SPREAD, IRON_CONDOR, IRON_BUTTERFLY, STRADDLE, STRANGLE } function createStrategy( StrategyType strategyType, uint256[4][] calldata legParams, // [quantity, strike, limit, collateral] bytes[] calldata proofs ) external returns (uint256 strategyId) { // Validate strategy logic require(_isValidStrategyType(strategyType, legParams.length)); // Create individual legs for (uint256 i = 0; i < legParams.length; i++) { uint256 legOrderId = _createStrategyLegOrder(...); orderToStrategy[legOrderId] = strategyId; } } ``` ## Notable Technical Innovations ### 1. Encrypted Amount Validation Pattern ```solidity // Validate collateral without revealing amounts function _validateCollateralAsync( euint64 syntheticAmount, euint64 collateralAmount, uint256 price ) internal { euint64 leftSide = collateralAmount.mul(FHE.asEuint64(100)); euint64 rightSide = syntheticValue.mul(FHE.asEuint64(collateralizationRatio)); ebool isInsufficient = leftSide.lt(rightSide); // Request async decryption for validation bytes32[] memory cts = new bytes32[](1); cts[0] = ebool.unwrap(isInsufficient); uint256 requestId = FHE.requestDecryption(cts, this.finalizeValidation.selector); } ``` ### 2. Dual-Amount Architecture ```solidity struct ConfidentialOrder { euint64 quantity; // Encrypted actual amount euint64 collateralAmount; // Encrypted collateral // Public estimates for volume tracking/validation uint256 estimatedQuantity; uint256 estimatedCollateral; } ``` **Why this pattern:** - FHE operations are expensive - minimize decryptions - Need public amounts for volume limits and gas estimation - Encrypted amounts for actual execution - Estimates don't reveal exact positions ### 3. Resolver Bond & Slashing Mechanism ```solidity function lockSettlement(uint256 settlementId, externalEuint64 encryptedBond) external { euint64 bond = FHE.fromExternal(encryptedBond, bondProof); require(bond >= requiredBond, "Insufficient bond"); // Lock resolver funds confidentialCollateral.authorizedTransfer(msg.sender, address(this), bond); settlement.resolverBond = bond; } function _slashResolver(address resolver, euint64 amount, string memory reason) internal { // Transfer slashed funds to insurance confidentialCollateral.authorizedTransfer(address(this), insuranceFund, amount); resolverInfo.isSlashed = true; } ``` ## Security & Risk Management Features ### 1. Circuit Breakers ```solidity modifier whenNotCircuitBroken() { require(!_isCircuitBroken(), "Circuit breaker active"); _; } function _updateDailyVolume(uint256 volumeToAdd) internal { if (dailyVolume > maxDailyVolume) { emit CircuitBreakerTriggered(dailyVolume, maxDailyVolume, block.timestamp); } } ``` ### 2. Emergency Withdrawal System ```solidity function requestEmergencyWithdrawal() external { emergencyWithdrawalRequests[msg.sender] = block.timestamp; } function executeEmergencyWithdrawal() external { require(block.timestamp >= requestTime + EMERGENCY_WITHDRAWAL_DELAY); // Release locked collateral after delay } ``` ### 3. Multi-Role Access Control ```solidity bytes32 public constant RESOLVER_ROLE = keccak256("RESOLVER_ROLE"); bytes32 public constant ORACLE_ROLE = keccak256("ORACLE_ROLE"); bytes32 public constant EMERGENCY_ROLE = keccak256("EMERGENCY_ROLE"); ``` ## Development & Testing Stack ### Hardhat Configuration ```javascript module.exports = { solidity: { version: "0.8.28", settings: { optimizer: { enabled: true, runs: 200 }, viaIR: true, // Required for complex FHE operations }, }, networks: { etherlinkMainnet: { /* config */ }, etherlinkTestnet: { /* config */ }, } }; ``` ### Key Dependencies ```json { "@fhevm/solidity": "^0.7.0", // FHE operations "@openzeppelin/confidential-contracts": "^0.2.0-rc.1", // Privacy primitives "@openzeppelin/contracts": "^5.4.0", // Standard contracts "@nomicfoundation/hardhat-toolbox": "^6.1.0" // Development tools } ``` ## Particularly Noteworthy "Hacks" ### 1. FHE Performance Optimization Since FHE operations are computationally expensive, we implemented: - **Batched encryptions** for multi-leg strategies - **Lazy decryption** - only decrypt when absolutely necessary - **Encrypted boolean logic** for complex conditional validation - **Estimation patterns** to avoid unnecessary FHE operations ### 2. Cross-Chain Privacy Bridge The atomic swap mechanism maintains privacy across chains by: - Using hash-locked contracts with encrypted amounts - Resolver bonds in encrypted form - Secret revelation that doesn't expose underlying amounts - Fallback mechanisms that preserve privacy even in failure cases ### 3. Gasless Trading UX Integration with 1inch Fusion+ enables: - Users sign intentions, not transactions - Resolvers compete to execute orders - No gas fees for end users - MEV protection through sealed bid auctions This architecture creates a truly private, cross-chain derivatives platform that rivals traditional finance in sophistication while maintaining complete on-chain transparency and decentralization.