Architecture

Introduction

CrossFi Chain is a Layer 1 blockchain with a modular architecture that combines the capabilities of the Cosmos and Ethereum ecosystems. It is built on the Cosmos SDK framework and the Tendermint BFT consensus, which ensures high performance, fast final transaction confirmations, and fault tolerance. At the same time, CrossFi is fully compatible with the Ethereum Virtual Machine (EVM), allowing smart contracts and decentralized applications (DApps) to be deployed just as they are on the Ethereum network. This combination makes CrossFi Chain unique: the consensus and infrastructure provided by Cosmos offer scalability and interchain compatibility, while EVM compatibility supports the familiar Web3 tools and Solidity contracts. The project is aimed at creating a user-friendly platform for DeFi applications that unites traditional finance and decentralized technologies, with a focus on network security and extensive cross-chain interaction capabilities.

Architectural Layers

The architecture of CrossFi Chain is divided into three main layers, each responsible for its own set of functions:

Application Layer: This is the top layer where smart contracts and applications reside. It includes all decentralized applications (DApps) deployed on the platform, as well as the internal business logic of the network (for example, Cosmos SDK modules for token management, staking, governance, etc.). The application layer implements the rules and functions that determine the system's behavior—from executing smart contract code to the logic for issuing new tokens and other economic parameters of the network.

Execution Layer: This middle layer is responsible for the direct execution of transactions and changing the blockchain state. In CrossFi Chain, this role is fulfilled by the integrated Ethereum Virtual Machine (EVM) together with Cosmos SDK modules. The execution layer receives transactions from the consensus layer and executes them according to the predetermined logic: if it is a smart contract transaction, it is executed in the EVM; if it is a native Cosmos SDK message (for example, a native token transfer), it is processed by the corresponding module. The result of the execution layer’s work is an updated network state (balances, contract storage, etc.) and the events generated by the transactions.

Consensus Layer: This is the bottom layer of the architecture, ensuring the ordering of transactions and block creation with guaranteed security. CrossFi uses the Tendermint BFT consensus (Byzantine Fault Tolerant algorithm) with a Delegated Proof-of-Stake (DPoS) mechanism. This layer includes validator nodes that exchange consensus messages, gather transactions into blocks, and collectively approve each new block. The consensus layer operates independently of the execution logic: it guarantees that every network node arrives at a unified transaction order and state, passing the transactions to the execution layer through a standardized interface.

The separation into these layers increases the modularity of the system. Cosmos SDK and Tendermint handle the consensus and basic network operations (block production and finalization, low-level transaction processing, issuance of new coins), while the EVM component is responsible for executing user smart contracts and operating DApps. Thanks to the clear architectural boundaries between consensus, execution, and application logic, CrossFi Chain achieves flexibility: each layer can be developed and optimized almost independently without disrupting the operation of the other components.

Integration of EVM and Cosmos SDK via ABCI Using Ethermint

The key element linking the execution and consensus layers in CrossFi is ABCI (Application Blockchain Interface). ABCI serves as the interface between the Tendermint consensus engine and the Cosmos SDK-based application, which integrates the Ethermint module—a realization of the EVM adapted for Cosmos. Thanks to ABCI, different parts of the system, even if written in different programming languages, can exchange messages and operate as a unified whole.

When an external transaction enters a CrossFi node, for example through a Web3 wallet, it first enters the Tendermint mempool. At this stage, a preliminary check (CheckTx) is performed, which includes verifying the correctness of the signature, sufficient fee, and basic restrictions. Upon successful verification, the transaction is accepted into the pool and awaits inclusion in a block. Then, the validator proposer forms a new block by collecting transactions from the mempool, and the consensus process begins. For each transaction, Tendermint calls the application’s DeliverTx method, passing the transaction data via ABCI.

On the application side, detailed transaction processing takes place. If the transaction is a smart contract call, the integrated Ethermint module executes the smart contract bytecode in an isolated EVM environment, modifying account and contract states in accordance with the execution result. In the case of transactions related to native Cosmos modules, such as XFI token transfers or staking, the processing is carried out by the corresponding Cosmos SDK module.

After the execution of each transaction, the application returns a result via ABCI that includes the success or failure of the execution, the updated state, and the events generated during processing. A unique feature of CrossFi is the combination of two types of events. When EVM transactions are executed, smart contract event logs may be generated, which are intercepted by Ethermint and become available through an external RPC interface, similar to how it is implemented on Ethereum. At the same time, each transaction, regardless of its type, can generate standard Cosmos SDK events that are indexed in the block and available through the Cosmos API.

Thanks to ABCI, the combination of Tendermint, Cosmos SDK, and Ethermint functions synchronously: the consensus layer only ensures the order and delivery of transactions without delving into the details of smart contract execution, while the execution layer implemented in the application focuses on calculating the transaction outcomes. This approach allows CrossFi to replace Ethereum’s Proof-of-Work consensus with the faster and more efficient Tendermint consensus while maintaining the Ethereum smart contract execution model. As a result, transactions are processed almost in the same way as on Ethereum, but with the benefits of high performance, finality, and scalability provided by the Cosmos SDK.

Tendermint BFT Consensus

CrossFi Chain ensures network security and state consistency through the Tendermint BFT (Byzantine Fault Tolerant) algorithm. Tendermint is a Byzantine fault-tolerant consensus that can function correctly even if up to one-third of validators behave erroneously or maliciously. The main features of this protocol include the absence of forks (thanks to strict block finality) and high confirmation speed (a block is considered finally confirmed as soon as it is included in the chain, without the need to wait for many subsequent blocks).

Validators and DPoS: CrossFi implements a Delegated Proof-of-Stake consensus. This means that there is a specific set of active validators (up to 128 nodes) who directly participate in block confirmation. These validators are chosen by the community through stake delegation: token holders can delegate their coins to nodes they consider reliable. The more tokens delegated to a validator, the greater his weight (voting power) in the consensus. This mechanism stimulates competition for reputation among validators and involves the community in ensuring security—even users who do not run their own nodes can indirectly participate through delegation.

Block Production Process: Tendermint operates in rounds. In each round, one of the validators (selected based on a round-robin algorithm considering the stake weight) becomes the proposer and suggests a set of transactions in the form of a new block. Then all validators conduct two rounds of voting: Pre-vote and, if the block gathers enough pre-votes, Pre-commit. For the block to be accepted, more than 2/3 of the weighted validator votes are required at the Pre-commit stage. Once the necessary threshold is reached, the block is committed and broadcasted across the network—it is considered finalized. If consensus is not reached (for example, if the proposer is offline or the block is rejected), Tendermint automatically moves to the next round with a new proposer. This model ensures both security (there will not be two different final blocks if less than one-third of the nodes are malicious) and network liveness (the network will continue to produce new blocks as long as at least 2/3 of the honest nodes are available).

Performance and Block Time: In CrossFi, blocks are produced quickly—the target block generation time is approximately 5 seconds. Thanks to this and the property of instantaneous finality, transactions are confirmed almost immediately by blockchain standards. High throughput is achieved through Tendermint optimizations and horizontal scaling: the network can process up to tens of thousands of transactions per second. Multiple operations (batching transactions) can be executed in a single block, increasing efficiency. In the future, the architecture allows reducing block time to as low as 1 second without compromising consensus stability.

Consensus Security: Tendermint includes built-in protection mechanisms against malicious actors. If a validator attempts to cheat—for example, by signing two different versions of the same block (double signing) or by not participating in votes for an extended period—the protocol detects this. For violations, the validator faces economic penalties: a portion of their staked tokens is burned (slashing), and they may be excluded from the active validator set. This ensures a high degree of trust: to successfully attack the network, a malicious actor would have to control more than one-third of all stakes, which is extremely costly. Thus, the combination of Tendermint BFT's cryptographic protection and the economic incentives of DPoS makes the CrossFi consensus both robust and fast. Moreover, Tendermint allows easy validation of new blocks: a single confirmed signature (obtained as a result of 2/3 votes) is sufficient to be confident in the block's finality. Users can consider a transaction irreversible after just one block. All these consensus properties form the foundation of CrossFi Chain's reliability and serve as the basis for the upper execution and application layers.

Interaction with DApps

For developers and users, CrossFi Chain provides a familiar experience of interacting with both Ethereum and the Cosmos ecosystem. Thanks to full EVM support, any smart contract written in Solidity or another compatible language can be deployed on CrossFi without modifications. DApps interact with the network as follows:

Via the Web3/Ethereum Interface: CrossFi is perceived as just another EVM-compatible network. This means that DApps can connect to it using standard Ethereum libraries and wallets. The developer specifies a CrossFi RPC node (a URL similar to an Ethereum HTTP RPC endpoint) and the CrossFi Chain ID in the settings. After that, smart contract methods can be invoked, transactions can be sent, and the blockchain state can be read using familiar calls (for example, via web3.js/ethers.js in JavaScript, Hardhat, Truffle, Foundry, etc.). Users can use MetaMask or similar wallets to sign transactions—MetaMask will generate and sign transactions just like on Ethereum, and then send them to the CrossFi network. From a DApp’s perspective, invoking a smart contract on CrossFi is no different from invoking one on Ethereum—the API-level compatibility allows the use of existing frontends and tools without modifications. After sending a transaction, a DApp can check its status via JSON-RPC, obtain the transaction hash, wait for it to be included in a block, and then, for example, receive a receipt with event logs. This ensures seamless integration: Web3-oriented applications are easily ported to CrossFi, gaining benefits in speed and reduced transaction costs.

Via the Cosmos Interface: In parallel, CrossFi provides interaction capabilities inherent to networks based on the Cosmos SDK. Users interested in staking, governance, or interchain transfers can use wallets like Keplr or standard Cosmos command-line tools. For example, token delegation, voting on proposals, or sending IBC transactions can be executed using standard Cosmos SDK transactions. CrossFi addresses are compatible with the Cosmos address format (for banking operations) as well as Ethereum addresses (for smart contracts), since the network supports two parallel addressing systems. Thus, a single user can have a unified account from which they both delegate stake through Keplr and perform smart contract calls via MetaMask (in CrossFi these accounts are synchronized at the application level).

Transaction Formation and Submission: When a DApp is in operation and a user initiates an action (for example, token exchange on a decentralized exchange deployed on CrossFi), the frontend generates a transaction. If it is an EVM transaction, it is formatted in the Ethereum format (with fields like nonce, gas, to, value, data, etc.) and signed with the user’s private key via a wallet. The transaction is then sent to a CrossFi RPC node and enters the network. As described earlier, it undergoes checks and execution within the network. After the transaction is included in a block, the DApp usually receives a notification or polls the network to ascertain the results (for example, an event confirming a successful trade). In the case of a Cosmos transaction (say, an IBC transfer), the process is similar: the wallet (Keplr) signs a Cosmos SDK message, sends it to the network, and the DApp can track its execution via REST API or WebSocket events.

Thus, CrossFi provides dual interaction interfaces. Developers can choose the stack that suits them best: either Ethereum Web3 for quick smart contract deployment and leveraging a multitude of existing libraries, or Cosmos SDK for direct interaction with a modular infrastructure (gaining the benefits of IBC and built-in management). For end users, the process is transparent: they use familiar wallets and applications while CrossFi “under the hood” routes their actions either to the EVM or to the Cosmos modules. For example, a user may manage their XFI assets in Keplr and then use the same funds in an Ethereum-based application via MetaMask, since tokens and contracts coexist on the same chain. This hybrid approach significantly expands DApp capabilities and developer convenience, making CrossFi a universal platform for Web3 applications.

Cross-Chain Interaction

One of the key advantages of using the Cosmos SDK in CrossFi Chain is its built-in support for interchain interaction. CrossFi is capable of connecting to other blockchains and exchanging data and value with them, which is implemented in two main ways:

IBC (Inter-Blockchain Communication): This is a protocol for inter-blockchain communication developed within the Cosmos ecosystem. As a Cosmos zone, CrossFi supports IBC at the protocol level. This allows for establishing IBC connections with other compatible networks (zones) and creating data transfer channels between them. Practically, this means that CrossFi can move tokens and perform interchain transactions with networks such as Cosmos Hub, Osmosis, Juno, and others. For example, the XFI token can be transferred from CrossFi Chain to any other IBC-compatible network: in CrossFi, the token is locked (escrow) by a special module, and in the target network, a corresponding voucher token is minted in an equivalent amount. The reverse operation burns the voucher and unlocks the original XFI on CrossFi. All this occurs trustlessly—the security of the transfer is guaranteed by the IBC protocol itself and the validators of both networks. In addition to tokens, IBC allows the transfer of arbitrary messages—this opens up the possibility, for example, to control smart contracts in one network from another or initiate interchain swaps. For users, IBC transfers often occur “behind the scenes”: they simply see that they can send assets to an address in another network, and within a few minutes those assets become available there. For CrossFi, IBC support means deep integration into the Cosmos ecosystem, access to the liquidity and services of other networks, as well as participation in cross-chain DApps.

Bridges with EVM Networks: In addition to IBC, CrossFi is aimed at compatibility with popular blockchains outside the Cosmos ecosystem, primarily Ethereum and other EVM networks (BSC, Polygon, etc.). For this purpose, cross-chain bridges connecting CrossFi with external chains are implemented. Such bridges typically operate on the lock-and-mint principle: a bridge smart contract in one network locks the tokens, and the associated contract in the other network mints a corresponding number of wrapped tokens. In the CrossFi architecture, the role of such a bridge is simplified by the fact that the network itself is already EVM-compatible, allowing the use of standard Ethereum bridge solutions without significant modifications. Although the project utilizes technologies developed by the Evmos team (an EVM-compatible Cosmos zone), this does not mean that CrossFi forwards transactions or messages to the Evmos network for connection with Ethereum and other networks. Instead, CrossFi provides direct EVM compatibility, allowing smart contracts to interact with contracts on Ethereum, and enabling users to transfer their funds between CrossFi and Ethereum almost as easily as between CrossFi and other Cosmos zones. In the future, direct bridges may be implemented, such as launching an in-house bridge module based on Cosmos Peggy (also known as Gravity Bridge) for direct connection to Ethereum, or integrating with existing multi-chain bridges from third-party projects.

Thanks to the combination of IBC and bridges, CrossFi Chain achieves broad interoperability. This means that the limitations of any single blockchain are overcome: assets and data can move freely to where they are most useful. For developers, this opens up the possibility to create cross-chain DApps that simultaneously leverage the advantages of different networks—for example, storing data or issuing NFTs on one chain while performing calculations or trading on another, using CrossFi as the connecting link. For users, this increases the value of the CrossFi ecosystem: they are not confined to a single network but can access services from multiple blockchains, managing their assets through CrossFi. Strategically, CrossFi serves as a bridge between different blockchain worlds, uniting them into a single ecosystem.

Security and Governance

CrossFi Chain pays special attention to network security and decentralized governance. Staking, slashing, and on-chain voting mechanisms are built into the protocol, ensuring both the protection of the blockchain from attacks and its evolution under community control.

Staking and Economic Security: Network security is maintained through economic incentives via Delegated PoS. Validators are required to stake a significant portion of tokens (e.g., XFI) to demonstrate their commitment to honest operation. At the same time, regular users can delegate their tokens to validators, sharing the responsibility. The network automatically monitors validator behavior: if a node frequently misses block production (i.e., does not participate in consensus) or engages in actions that undermine consensus (for example, double signing—signing two conflicting blocks), sanctions are triggered. The slashing mechanism automatically burns a portion of the misbehaving validator’s stake, reducing their share and inflicting economic damage. Simultaneously, a small portion of the delegated funds of that validator may also be withheld as a fee for the wrong choice—this incentivizes users to choose responsible validators. In addition to slashing, a validator may be removed from the active set (i.e., temporarily barred from signing blocks) for serious violations. These measures create direct material accountability: an attack on the network or negligence results in the loss of funds, often far exceeding any potential gain from an attack, making such attempts unprofitable. Besides penalties, there are also rewards: for every block added, validators and their delegators receive compensation in the form of transaction fees and newly issued tokens. New coin issuance occurs with every block according to a pre-defined inflation protocol, distributed proportionally to the stake. This mechanism rewards participants who support the network and ensures continuous funding for the blockchain's security. As a result, CrossFi’s economic model is structured so that honest behavior is maximally profitable, and any deviation is immediately punished.

Decentralized Governance: CrossFi Chain allows token holders to directly participate in the network's governance. A governance module implemented on the Cosmos SDK platform enables the community to make decisions about future changes and protocol parameters. The process is as follows: any validator or delegator who has accumulated a sufficient amount of tokens for staking can create a proposal. A proposal may address various aspects: changing network parameters (for example, fee size, block time), allocating treasury funds, planning protocol updates, or launching new functionalities. To submit a proposal, a deposit in tokens is required to prevent spam and demonstrate the seriousness of the intent. After submission, the initiative enters a voting phase, during which all interested participants can cast their votes within a specified period. Votes can be cast in favor, against, abstain, or veto (if the proposal is considered harmful). The weight of each participant’s vote is proportional to the number of tokens they hold (directly or delegated). At the end of the voting period, the system automatically tallies the results, taking into account the quorum and the acceptance threshold. If the proposal receives the necessary number of "yes" votes and the quorum is met, it is considered approved and comes into effect: network parameters are changed or actions are carried out in accordance with the decision. Otherwise, the proposal is rejected, and the deposit is partially or fully returned (except in the case of a veto, when the deposit may be burned for particularly harmful initiatives). This process ensures the flexibility and adaptability of CrossFi Chain—the network can evolve, changing rules and parameters under the control of its users without the need for hard forks. Governance by token holders increases decentralization: important decisions are made collectively rather than by a centralized group.

Technical Security and Updates: From a development perspective, CrossFi inherits time-tested components (Tendermint, Cosmos SDK, Ethermint/EVM) that undergo audits and have a large community of supporting developers. This reduces the likelihood of critical vulnerabilities. The modular architecture means that security updates (for example, an EVM vulnerability patch or an improvement to the consensus algorithm) can be implemented relatively in isolation without breaking the entire system. In case a problem is discovered, the community can quickly decide on an emergency protocol update via the governance mechanism. Additionally, CrossFi is developing Account Abstraction—a technology for abstracting accounts that will allow flexible customization of transaction authorization rules. In the future, this will enable the implementation of additional security layers directly in wallets: for example, requiring biometric authentication or confirmation through a second device (2FA) before signing certain transactions. Such capabilities will enhance end-user security without altering the fundamental principles of decentralization.

In summary, the staking, slashing, and on-chain voting mechanisms create a robust system for protecting and governing CrossFi Chain. The network economically incentivizes honest validator behavior, actively involves the community in decision-making, and is capable of withstanding most common attacks. As a result, CrossFi provides a stable foundation for all applications and services built on top of it.

Conclusion

CrossFi Chain represents a powerful and flexible platform that combines the best features of two blockchain worlds. On one hand, thanks to the Cosmos SDK and Tendermint, it features a high-performance Delegated PoS consensus with fast block times and finality, a scalable architecture, and built-in interoperability with other networks. On the other hand, full EVM compatibility makes it a natural environment for Ethereum smart contracts: developers can seamlessly port existing applications to CrossFi or create new ones using the full richness of the Ethereum ecosystem (programming languages, development tools, smart contract audits, ERC-20/ERC-721 token standards, etc.). This combination creates a synergistic effect: CrossFi not only unites two technologies but multiplies their advantages, enabling high-speed performance without compromising functionality or decentralization.

Advantages of CrossFi Chain: Firstly, scalability and speed—the network is capable of processing thousands (and potentially tens of thousands) of transactions per second, confirming them within seconds, which suits demanding DeFi and FinTech applications. Secondly, interoperability—through IBC and bridges, CrossFi connects to a wide range of networks, from Cosmos zones to Ethereum and other EVM chains, which expands the market and audience for CrossFi applications. Thirdly, security and finality—Tendermint BFT guarantees the immutability of records after a single block and resilience against Byzantine failures, while the slashing and governance mechanisms create a healthy ecosystem of participants committed to long-term network reliability. Finally, developer convenience—the modular approach and EVM compatibility lower the entry barrier: creating a dApp on CrossFi is not much different from typical Ethereum development, and additional Cosmos capabilities are available (for example, writing modules in Go for specialized logic if needed).

Development Prospects: CrossFi’s architecture is designed with future growth in mind. As the community expands and new requirements emerge, the network can be flexibly adjusted: the number of validators may increase to enhance decentralization, the consensus protocol may be optimized for even greater throughput (potentially reducing block times to 1–2 seconds), and the range of supported bridges may be expanded (for example, direct bridges to major ecosystems or integration with cross-chain smart contract protocols). The planned implementation of account abstraction and other improvements will enhance security and usability for end users, attracting more mass-market applications to the ecosystem. CrossFi may also play a significant role in uniting traditional finance and DeFi: with support for anonymous payments, instant payment channels, and multi-account operations, the network is poised to offer financial organizations blockchain-based product infrastructure without compromising regulatory requirements and user comfort.

In conclusion, CrossFi Chain is a holistic solution for creating modern decentralized applications, where the levels of consensus, execution, and application work in unison. Its architecture ensures high speed and security, flexible cross-chain interaction, and developer convenience. This lays a solid foundation for the further growth of the CrossFi ecosystem and the emergence of innovative services built upon it, capable of taking the interaction between traditional finance and the cryptocurrency world to a new level.