Last updated a month ago
We propose a lightweight cross-chain adapter to bridge stablecoins (USDC/USDT) into Cardano for RWA yield distribution and treasury inflows on RWA Genius Yield.
A cross-chain adapter to bring stablecoins (e.g. USDC) from Ethereum/Solana into Cardano, enabling seamless yield distribution and treasury funding for RWA DeFi protocols like RWA Genius Yield.
Please provide your proposal title
RWA Cross-Chain Bridge Adapter for Stablecoin Distribution
Enter the amount of funding you are requesting in ADA
95000
Please specify how many months you expect your project to last
8
Please indicate if your proposal has been auto-translated
No
Original Language
en
What is the problem you want to solve?
We propose a lightweight cross-chain adapter to bridge stablecoins (USDC/USDT) into Cardano for RWA yield distribution and treasury inflows on RWA Genius Yield.
Supporting links
Does your project have any dependencies on other organizations, technical or otherwise?
Yes
Describe any dependencies or write 'No dependencies'
This project depends on integration with one or more cross-chain bridge providers (e.g. wanchain, Axelar, or Wormhole). These dependencies are essential for providing secure, verifiable message-passing and asset transfer between external blockchains and Cardano. Additionally, the validator layer will depend on stable APIs or relayer services to authenticate and process bridge transactions into Cardano-native token representations.
Will your project's outputs be fully open source?
No
License and Additional Information
We will open-source key components including the validator logic, SDK adapters, and message verification scripts to ensure reuse and community auditability. However, sensitive deployment configurations (e.g., routing keys, validator security controls) will remain closed to mitigate security risk. Open-source components will be released under the MIT License.
Please choose the most relevant theme and tag related to the outcomes of your proposal.
DeFi
Describe what makes your idea innovative compared to what has been previously funded (whether by you or others).
This proposal introduces the first lightweight cross-chain adapter focused solely on bringing stablecoins (like USDC) into the Cardano ecosystem for treasury and yield operations. Unlike general-purpose bridges, our adapter integrates directly into RWA DeFi workflows, enabling on-chain distributions from Ethereum or Solana to Cardano-native assets. It complements existing Cardano infrastructure with real-world capital flows and prioritizes minimal trust assumptions, cost-efficiency, and modular deployment for other dApps.
Describe what your prototype or MVP will demonstrate, and where it can be accessed.
The MVP will demonstrate a fully functional cross-chain adapter that accepts stablecoin deposits (e.g., USDC on Ethereum) and triggers equivalent wrapped assets (e.g., cUSDC) on Cardano testnet. It will be integrated with RWA Genius Yield test modules to simulate stablecoin-based yield distributions. Users will be able to access the MVP via a public GitHub repository, along with documentation, demo UI, and CLI scripts to test deposit, wrap, unwrap, and claim flows on PreProd and Cardano EVM-compatible chains.
Describe realistic measures of success, ideally with on-chain metrics.
Successful testnet stablecoin bridging with <5s event latency (EVM to Cardano).
90% accuracy in wrapped token issuance vs deposits over 100+ test events.
Deployment of smart contracts on Cardano testnet and GitHub public release.
Integration into a dApp (RWA Genius Yield or others) showcasing yield distribution in wrapped USDC.
Community usage: ≥100 test users interact with the bridge UI or CLI.
Future-ready: documentation for mainnet deployment and dApp integration.
Please describe your proposed solution and how it addresses the problem
The Cross-Chain Bridge Adapter for Stablecoin Distribution will provide a lightweight, secure, and modular mechanism for bridging stablecoins (e.g., USDC, USDT) from EVM chains (like Ethereum or Polygon) into the Cardano ecosystem. This adapter is specifically designed to support on-chain RWA yield distribution use cases by enabling off-chain revenue flows (such as rental income or interest payments) to be seamlessly transmitted and distributed to token holders on Cardano.
The bridge leverages event-driven messaging and minimal trust assumptions using existing oracle services or attestation networks (e.g., Wormhole, Hyperlane, Chainlink CCIP). It wraps stablecoins into native Cardano tokens (e.g., cUSDC), which can then be distributed via RWA staking contracts or used within DeFi protocols. The system will include smart contracts, a CLI, and a Web UI to demonstrate deposit, mint, burn, and claim operations.
Our solution is optimized for cost and security, avoiding the need for large validator sets or heavyweight infrastructure. It will be implemented as an MVP with core functions deployed on Cardano Preprod and integrated into a pilot dApp (RWA Genius Yield or equivalent).
Core Components:
Bridge Adapter Microservice
Written in Rust or TypeScript and deployed as a cloud-based, event-driven backend.
Listens to target EVM chains for finalized events (e.g., incoming stablecoin payment to a known treasury address).
Verifies transactions using JSON-RPC calls and Merkle proof construction (or relays via secure APIs).
Triggers a signed action to lock or mint equivalent value on Cardano via an integrated Plutus script.
Cardano Smart Contract Endpoint
A Plutus-based validator receives proof and initiates distribution via:
Revenue accounting module (tracks stablecoin flows per epoch).
Distribution policy (e.g., stake-weighted or fixed yield).
Support for tokens like wrapped USDC, DJED or USDA
Security logic to prevent duplicate or forged messages, including nonces and replay protection.
Please define the positive impact your project will have on the wider Cardano community
This bridge adapter provides crucial missing infrastructure for tokenized RWA protocols on Cardano that require stable, transparent cash flow distribution — a key for institutional adoption and investor trust. It unlocks:
Real Yield Distribution: Enables profit distribution from real estate, invoice financing, and other RWA platforms denominated in stablecoins.
Cross-Chain Interoperability: Bridges economic activity from Ethereum L2s and centralized venues into Cardano, increasing overall transaction volume and TVL.
Compliance-Ready Infrastructure: Verifiable, auditable flow of stablecoins helps satisfy MiCA and regulatory requirements for asset-backed tokens.
Catalyst Ecosystem Reuse: Other funded RWA protocols (e.g. RWA Genius Yield) can plug into this open bridge adapter to bootstrap stablecoin functionality without duplicating efforts.
Bootstraps DeFi Liquidity: Stablecoin inflows provide composable assets for swaps, staking, or yield aggregation in the broader Cardano DeFi ecosystem.
Low-Cost Scaling: Instead of building a full bridge, the adapter acts as a permissioned, auditable channel that can scale horizontally across protocols.
This project accelerates Cardano’s vision as the home for regulatory-compliant, yield-distributing RWA protocols and increases participation from institutions and users demanding dollar-denominated returns.
What is your capability to deliver your project with high levels of trust and accountability? How do you intend to validate if your approach is feasible?
Genius Yield's core engineering team will lead the implementation. The team has already delivered production-grade audited systems including the Genius Yield DEX, ATLAS Plutus Application Backend (PAB), and integrations with smart contract launchpads (Genius X). Key capabilities:
Technical Capabilities:
Plutus/Haskell Expertise: The same team that authored the Genius Yield DEX and staking contracts will develop the on-chain endpoint.
Cross-Chain Integration Experience: The team has previously explored integrations with Milkomeda, Midnight, and LayerZero — providing foundational experience for this stablecoin adapter.
Secure Backend Engineering: Experience deploying scalable microservices in Rust and TypeScript ensures a robust event monitoring and relay system.
RWA Tokenization Design: Prior design of distribution logic for income-bearing assets ensures a reliable accounting and distribution policy implementation.
Feasibility Plan:
A prototype of the backend will be run on testnet using simulated stablecoin transfers from Ethereum and output logs will be matched with Cardano testnet events.
Integration with a testnet version of a Cardano RWA governance contract (such as RWA Genius Yield) will demonstrate the full distribution cycle.
Third-party audit of the minting logic and verification policies will be commissioned before mainnet release.
MVP expected within 3 months; 6 months total for full integration with UI and governance configuration.
Risk Mitigation:
Bridge exploits are common; to mitigate risk, no minting is performed blindly. Only whitelisted transactions from audited treasuries are accepted.
Oracle failure is mitigated through fallback multisig triggers and verified transaction proofs.
Regulatory concerns are addressed by using stablecoins with transparent reserves (e.g., USDC) and distribution reporting via open APIs.
Milestone Title
System Architecture & EVM Bridge Listener Prototype
Milestone Outputs
This milestone focuses on delivering a fully documented system architecture and a backend prototype capable of detecting stablecoin transfer events on EVM chains (e.g., USDC on Goerli or Base Sepolia). The team will first define the cross-chain message protocol, including the payload format (containing amount, timestamp, sender address, chain ID, and a unique nonce), message hashing standards (e.g., Keccak-256), and signature scheme (e.g., ECDSA).
The backend service will use Web3 libraries (such as ethers.js or web3.py) to connect to Ethereum-compatible testnets and subscribe to stablecoin transfer events filtered by a target treasury address (configured per deployment). Once a transfer event is detected, the service will format the event as a message payload, sign it using a designated private key (off-chain authority or multisig), and queue it for submission to Cardano.
A developer-friendly module will be packaged to encode and hash messages deterministically for smart contract verification later. The output will include a GitHub repository with modular, testable code and README instructions for running the listener and message-signing module.
Acceptance Criteria
The listener must demonstrate successful detection of ERC-20 Transfer events filtered by a pre-specified treasury address.
The backend must generate signed messages based on transfer events. The signature must include a nonce and a deterministic hash of the payload.
A sample payload structure must match the Cardano contract’s expectations (to be defined in Milestone 2) with strict type formatting.
At least 3 test transactions must be simulated on the Ethereum testnet to validate detection and message signing.
Each signed message must be logged and stored locally or in a lightweight database (e.g., SQLite or PostgreSQL).
The hash must follow a reproducible logic so it can be verified later on-chain with Plutus.
Evidence of Completion
GitHub Repository: The complete backend source code, including modules for event detection, message encoding, and signature generation, will be hosted in a repository. The repository may be private during development and made public upon successful testnet verification.
Sample Transaction Logs: Screenshots or exported logs showing transaction hashes on Goerli/Base Sepolia, emitted events, encoded payloads, and cryptographic signatures will be included.
Delivery Month
2
Cost
25000
Progress
20 %
Milestone Title
Cardano Smart Contract for Stablecoin Claims
Milestone Outputs
The core output of this milestone is a fully functional Plutus V2 smart contract that verifies EVM-originated messages and authorizes stablecoin claims on Cardano. This on-chain component acts as the secure settlement layer in the cross-chain bridge architecture. It is responsible for validating signed transaction payloads from Ethereum-based chains (e.g., Base, Polygon, Ethereum Goerli) and initiating the corresponding distribution logic on Cardano. The contract verifies that the message is unique, cryptographically valid, and has not been replayed or tampered with.
The architecture includes:
Payload Decoder: The contract accepts CBOR-encoded payloads containing the sender address, destination Cardano wallet, amount, nonce, chain ID, and timestamp. This data is parsed and structured for validation.
Signature Verifier: Using Ed25519 (or another scheme agreed upon in Milestone 1), the contract verifies the EVM-side oracle’s digital signature embedded in the payload.
Replay Protection: A stateful on-chain registry maintains a hash of used nonces to reject duplicate claims. This can be implemented via reference inputs and inline datums to optimize for cost and speed.
Mock Transfer Executor: On testnet, successful claims will trigger a mint of a mock token (e.g., tUSDC) to simulate cross-chain stablecoin flow.
Error Feedback Mechanism: Any rejected transactions emit failure logs through trace outputs, useful for auditability and debugging.
Testing Suite: Complete emulator test coverage (≥90%) will be delivered, covering valid and invalid claims, malformed payloads, signature mismatches, and replay attempts.
All code will be modular, well-documented, and written in Aiken or Plutarch for composability. The contract will integrate seamlessly with the message listener backend built in Milestone 1.
Acceptance Criteria
Deployment to Testnet: The smart contract must be deployed on Cardano pre-prod or preview testnet, publicly accessible via address and validator hash.
Successful Claim Workflow: The contract must accept a valid signed payload generated by the backend listener (Milestone 1), verify it, and mint a tUSDC token or emit a claim success event.
Signature Validation: Using Cardano’s Plutus native cryptographic primitives, the contract must validate digital signatures from the oracle/private key specified during setup.
Replay Protection: Each claim must include a unique nonce or hash. If the nonce was previously used, the transaction must fail with a custom error.
Gas-Efficiency Test: Contract must fit within 90% of mainnet CPU/memory limits per transaction. Emulator benchmarks and script size limits will be recorded.
Edge Case Handling: Emulator tests must simulate at least:
Signature mismatch
Malformed payload
Expired timestamp
Double-claim attempt
Deterministic Execution: The contract behavior must be deterministic under varied but valid input payloads.
The validator must also expose clear APIs or transaction formats usable by frontend libraries in Milestone 3, ensuring continuity across development layers.
Evidence of Completion
GitHub Repository: All Plutus smart contract code, emulator tests, and build scripts will be hosted on GitHub (open-source or private depending on IP strategy). Code comments will document function logic, payload structure, and interaction interfaces.
Transaction Logs: Screenshots or links to 3–5 successful and rejected transactions on the Cardano testnet. Logs will show expected outcomes: claim approval, token minting, and rejection messages for invalid attempts.
Test Suite: A published test harness including emulator runs, CI pipeline outputs, and unit test results with pass/fail summaries.
Architecture Documentation: A diagram and accompanying narrative describing the contract’s logic, input requirements, replay prevention technique, and integration with the listener backend.
Public Dev Update: A blog post or Twitter thread by the team summarizing Milestone 2 results, contract testing scope, integration notes, and next steps.
Video Demo: A short Loom or YouTube walkthrough of submitting a signed payload, invoking the contract, and showing successful/failed claims.
Delivery Month
2
Cost
25000
Progress
50 %
Milestone Title
Frontend Interface & SDK Library for Stablecoin Claims
Milestone Outputs
Milestone 3 delivers the user-facing tools that connect off-chain listeners and on-chain claim validation with a streamlined, intuitive interface. This includes:
Web UI (Frontend)
A responsive, mobile-friendly frontend built using React (or Svelte), allowing users to:
View their wallet balance of claimable stablecoins (based on oracle inputs)
Paste or upload signed payloads from Ethereum-based events
Submit transactions to the Cardano smart contract
Monitor status of pending claims, success/failure, and receive feedback
The UI will use wallet adapters like Lucid or Nami Wallet to sign and submit Cardano transactions. UX flow will include error detection for malformed or expired messages, with automatic formatting and data preview before claim submission.
SDK Library (JavaScript/TypeScript)
A developer-focused SDK providing programmatic access to:
Format, sign, and validate claim payloads
Submit claim transactions to Cardano testnet
Encode CBOR payloads, generate transaction metadata
Interact with smart contract endpoints
Parse oracle-signed EVM events and prepare messages for claims
This enables third-party platforms (RWA issuers, DEXs, token launchpads) to integrate automated claim UIs within their own apps.
Documentation & Developer Portal
Public docs describing:
Claim flow overview
Payload structure & validation rules
SDK usage examples
Integration examples with off-chain listeners and dApps
Design System
A small reusable component system (wallet button, claim form, payload inspector) allowing fast adaptation by ecosystem partners.
Together, the frontend + SDK provide a full-stack toolchain for secure, easy, and scalable stablecoin distribution claims on Cardano.
Acceptance Criteria
This milestone is considered successful when both end-users and developers can interact with the stablecoin claim system via a working frontend and SDK, using testnet infrastructure.
Functional Criteria:
UI Functionality:
Load wallet via Cardano-compatible wallet adapter (Nami/Lucid/Flint)
Input signed payload (JSON, CBOR, or pre-signed blob)
Preview decoded message contents (amount, timestamp, target wallet)
Submit claim transaction
Display success/failure with transaction hash
Show error messages for malformed or replayed claims
SDK Functionalities:
Function to parse EVM message logs and extract event payload
Message formatting utility to prepare CBOR-encoded payload
Signature verification utility to simulate contract logic
Helper to generate full transaction and submit via wallet
Testnet Transaction:
At least 5 successful end-to-end claims from the frontend using real signed testnet payloads
At least 3 invalid transactions rejected by the UI before submission (expired, bad signature, malformed)
Integration with Smart Contract (Milestone 2):
UI uses contract address & validator hash to submit claims
SDK exposes validator script hash, claim entrypoint, transaction builder function
Accessibility:
Deployed as a testnet web app (e.g., Netlify or Vercel link)
SDK published on GitHub with NPM deployment optional
Performance:
Claim confirmation within 1–2 blocks (≤40 seconds)
Frontend bundle size < 1MB
This milestone ensures that the bridge adapter is not just backend-validated but usable by end-users and integrators.
Evidence of Completion
This milestone will be demonstrated through a combination of public deployments, GitHub repositories, testnet transactions, and developer outreach artifacts.
UI Evidence:
Live Web App: A hosted React app (e.g., stableclaim-test.netlify.app) where Catalyst reviewers can connect a Cardano wallet and test the interface with sample payloads.
Screenshots: Interface walkthrough showing successful and failed claim flows, wallet connection, transaction hash display, and claim details.
Testnet Transactions: List of at least 5 successful claims with transaction hashes, payload contents, and timestamps. Logs will be provided for both success and failure cases.
SDK Evidence:
GitHub Repository: Full SDK source code published on GitHub with MIT or Apache 2.0 license (or private if IP sensitive).
Code Samples: Readme and developer docs with usage examples like:
formatClaimMessage(event)
submitClaim(wallet, payload)
Test Coverage: Unit tests covering message formatting, signature verification, and interaction with the Cardano smart contract.
Documentation:
Public-facing developer documentation on Gitbook or Markdown README.
Claim architecture diagram, API reference, and step-by-step integration guide.
Delivery Month
2
Cost
25000
Progress
70 %
Milestone Title
Testing, Audit Preparation & Final Integration
Milestone Outputs
This milestone ensures that the complete system—from Ethereum listener to Cardano smart contract, to frontend/UI—is secure, accurate, and ready for real-world usage. It focuses on end-to-end system validation, audit preparation, documentation finalization, and code cleanup.
Integrated E2E Test Pipeline
A dedicated test suite that simulates real stablecoin deposit events on an Ethereum testnet (e.g., Goerli or Base Sepolia), captures them via the backend listener, signs messages, and sends them through the frontend/UI to the Cardano validator for claims.
Tests cover full flows including timeouts, failures, replay attempts, and signature mismatches.
Payloads with varying sizes, token types, and timestamp windows are validated for stability.
Gas Benchmarking & Script Profiling
All Cardano smart contracts are benchmarked using emulator + plutus-script-profiler to assess cost limits, CPU/memory boundaries, and script size.
Optimization opportunities are documented and implemented before handoff to auditors.
Audit Readiness Report
The team prepares a comprehensive audit brief, including:
Functional specification
Threat model
Architecture diagrams
Test coverage summary
Known trade-offs or limitations
Oracle/operator key management
Bug Fixes & Refactors
Code cleanup of all components (Plutus, listener backend, frontend, SDK) for maintainability and documentation quality.
Documentation Finalization
Final developer documentation with cross-referenced links between modules.
Setup guides for running the backend listener, submitting claims, and integrating the SDK into third-party dApps.
Release Candidate Deployment
Release candidates for all modules published:
GitHub (contract + backend + frontend)
Docker container for backend listener
Tagged commits and versioning scheme (v1.0.0-rc1)
Acceptance Criteria
To qualify as complete, this milestone must demonstrate that the system is robust, reproducible, and fully functional across all layers.
System Validation Criteria:
End-to-End Flow:
At least 10 successful testnet claims using real signed messages from simulated stablecoin deposits.
End-to-end coverage from backend to frontend to Cardano testnet transaction completion.
Logs and summaries for both valid and rejected transactions (e.g., expired message, reused nonce).
Code Coverage:
≥ 90% test coverage across smart contract and backend logic.
SDK tested against edge cases including malformed payloads, wrong network, missing parameters.
Plutus Contract Benchmarking:
Total execution cost ≤ 80% of Cardano mainnet budget (memory, CPU).
Script size < 16 KB (to ensure deployability).
Evidence via benchmark logs or profiling tools.
Frontend & SDK Stability:
Frontend UI tested across Chrome, Firefox, and mobile browser.
SDK integration tested within a third-party mock dApp.
Security Checklist Completion:
Signature replay protection tested and verified.
Manual verification of payload hash generation and nonce uniqueness.
Audit Readiness:
Final architecture doc and threat model reviewed by internal team.
All test artifacts and known issues included in pre-audit report.
With these criteria met, the proposal is ready for a lightweight security audit or integration by RWA issuers.
Evidence of Completion
Testnet Deployment:
All components running in Cardano pre-prod/preview environment.
10+ claim transactions logged with successful and edge case outcomes.
GitHub Tags & Codebase:
All modules tagged as release candidates (v1.0.0-rc1 or similar).
README files updated to reflect final setup, usage, and deployment processes.
Benchmark Logs:
Plutus execution cost logs from plutus-benchmark or plutip emulator runs.
Profiling graphs showing where cost lies in script execution.
Test Logs & Coverage Reports:
CI test logs showing passing emulator, unit, and integration tests.
HTML or JSON coverage reports proving 90%+ coverage.
Audit Documentation:
Final audit brief uploaded to GitHub (public or private).
Delivery Month
2
Cost
20000
Please provide a cost breakdown of the proposed work and resources
Milestone 1
Resources:
1 Backend Engineer (Node.js or Python)
1 Solution Architect (part-time)
2 months
Cost : 25 000 ADA
Milestone 2
Resources:
1 Haskell/Plutus Developer
1 Security Specialist (consulting)
2 months
Cost : 25 000 ADA
Milestone 3 :
Resources:
1 Smart Contract Engineer (Plutus)
1 QA/Tester (internal)
2 Months
Cost : 25 000 ADA
Milestone 4 :
Resources:
1 Full-Stack Engineer
1 UI/UX Designer
1 Project Manager (part-time)
2 Months
Cost : 20 000 ADA
How does the cost of the project represent value for the Cardano ecosystem?
This project delivers ecosystem-wide value by enabling a low-cost, high-leverage mechanism for stablecoin distribution from EVM-based chains to Cardano. With a budget of just ₳95,000, the infrastructure we propose has the potential to unlock recurring utility for DeFi protocols, DAO treasuries, and Real-World Asset (RWA) platforms across the Cardano ecosystem. Rather than addressing a niche feature or isolated use case, the cross-chain bridge adapter provides foundational infrastructure that can be leveraged by dozens of projects needing a compliant, lightweight, and composable solution for stablecoin inflows.
The system’s output—a verified message-passing adapter with signature encoding—can be easily integrated into existing and future Cardano dApps. Whether for on-chain profit distribution, decentralized salary payments, DeFi incentives, or cross-chain DAO governance, this module enables stablecoin-triggered logic that is generic and reusable. This reduces development costs for other teams and accelerates ecosystem experimentation and adoption.
By enabling secure inflow of stablecoins such as USDC and USDT from Ethereum, Base, and other EVM chains, the bridge adapter helps address one of Cardano DeFi’s most critical constraints: capital isolation. Projects can now offer yield and payouts in stable assets, increasing attractiveness to users and liquidity providers accustomed to stable-value exposure. This leads to increased TVL, transaction volume, and long-term stickiness within the Cardano DeFi stack.
Building fully-fledged cross-chain bridges typically requires multi-million ADA budgets, long timelines, and high audit costs. This proposal sidesteps that by delivering a minimal, auditable message-passing adapter focused solely on one-way stablecoin distribution, optimizing for safety and composability. This focused scope ensures Cardano benefits from bridge-like functionality at ~3% of typical cost—a significant return on ecosystem investment.
The adapter plays a critical enabling role for profit distribution from RWA platforms, such as tokenized real estate, royalties, or yield-bearing financial instruments. With Cardano now able to receive bridged revenue, Catalyst-funded RWA projects can become economically active, rather than static representations of off-chain assets. This drives both network fees and user activity, improving economic density on Cardano.
The infrastructure is designed to follow emerging Cardano standards (e.g., CIP-68, CIP-95), and is compatible with ongoing platform developments like Atlas PAB and Layer 2 rollups. This future-proofing ensures long-term relevance, allowing other funded teams to integrate the module into evolving stacks without breaking changes or major refactoring.
Terms and Conditions:
Yes
Laurent Bellandi - Chief Executive Officer & Co-Founder
Laurent is a serial entrepreneur who has focused on digital/online businesses for over 20 years. Lately he co-founded both Genius Yield, one of the most innovative DeFi protocols, he manages the day-to-day operations of the program and launchpad operating team, formulating the long-term business strategy and leading strategic decisions.
Dr. Lars Brünjes - Chief Technology Officer & Co-Founder
Lars is a mathematician and Haskell developer. As Director of Education at Input Output Global (IOG), the engineering research company behind the development of the Cardano blockchain, Lars has taught thousands of people how to build smart contracts. As Chief Technology Officer of Genius Yield, Lars leads research & development with the technical team, and has written the smart contract code for Genius Yield.
Dr. Sothy Kol-Men - Chief Regulatory Officer & Co-Founder
Sothy has over 20 years of experience in digital finance, investments, building new ventures, and regulation. He is a legal expert, guiding Genius Yield through legal and regulatory matters for fintech rules and regulatory compliance. Sothy is also a highly regarded professional in the Swiss and European crypto network.
Dikemba Balogu - Chief Financial Officer
Dikemba is finance professional with years of experience in portfolio management, equity research, capital markets, valuation, and financial planning. As Chief Financial Officer of Genius Yield and Genius X, Dikemba leads financial planning and forecasting, profit optimization strategies for products, long-term product development and strategy, and token economics. Dikemba has advised 20+ startups on business strategy, token valuation, creating token utilities, token distribution schedules, and budgeting and forecasting.
Attila Bujaki - Senior Software Engineer
Attila is a Senior Haskell Developer with strong expertise in functional programming, distributed systems, and blockchain infrastructure. He is currently a core developer at Genius Yield, where he leads the design and implementation of the Products — next-generation smart contract dApps on Cardano. His responsibilities span architecture design, emulator testing, and Backend.
Previously, Attila contributed to Maestro, where he helped build Web3 infrastructure tools that served Cardano developers at scale. His deep knowledge of Haskell and Plutus continues to shape essential backend systems for DeFi and governance protocols within the Cardano ecosystem.