NEARCore, the reference implementation of the NEAR Protocol
The NEAR Protocol owes its existence to NEARCore, which is the software that makes its operation possible. NEARCore is built entirely using the Rust programming language, making it portable to different architectures and highly secure against various attacks and exploits. In this way, the developers have created a first layer of security around NEAR making their nodes implemented with security in mind.
All this means that NEARCore is built so that the community can take advantage of its capabilities using the tools that best suit their needs.
Nightshade Sharding, the NEAR Protocol sharding scheme
The central core of the operation of the NEAR Protocol is the Nightshade sharding protocol. Nightshade is integrated with NEARCore in order to make an efficient and secure operating partitioned network. In this way, the NEAR nodes can process and validate transactions in parallel, making it work much faster and thus increasing the total scalability of the network.
With Nightshade each shard on the NEAR network will produce a part of the next block. Each of these parts is called a chunk. All of the chunks produced are then sent to the rest of the network, where they are compiled, processed and stored, generating a new block within the network. In this new block are the records of all NEAR transactions and their last synchronization status. Once the process is done, it is repeated in an endless cycle that keeps the computational power of the NEAR network running.
This operating scheme would allow NEAR to offer scalability of hundreds of thousands of transactions per second. However, the limitation of the system is in the connection and the latency between the nodes that are part of the network. If nodes are far apart on the planet or have connection issues Nightshade's ability to scale is greatly affected. In fact, under certain conditions this can lead to hard forks of the network.
In order to prevent this, Nightshade bets on a consensus protocol hybrid powered by Thresholded Proof of Stake (TPoS) to select validators. The consensus protocol, and specifically its BFT part, is built around three well-proven technologies:
- The longest chain consensus system in Bitcoin. In Nightshade, the longest chain is the correct chain, thus cutting off the chance of malicious hard forks breaking its performance.
- The Casper system of Ethereum 2.0 merged with the GRANDPA concept of Polkadot is used. In this way, the sharding chains have protection against malicious domain attacks, in which a small group of nodes can attack a sharding and end up contaminating the rest of the chains.
For its part, TPoS is similar to an auction system in which a large pool of potential validators indicate how many NEAR tokens they are willing to stake through a signed transaction. In that case, TPoS helps determine the minimum threshold to become a validator every epoch (typically a 12 hour interval) and decides based on those dynamic parameters. In this way, the network adds additional protection against attacks to the staking scheme.
Rainbow Bridge and Aurora, cross-chain capabilities and smart contracts
The second important part in the operation of NEAR is seen in Rainbow Bridge and its Layer2, Aurora. Rainbow Bridge is an app on NEAR that allows users to transfer tokens ERC-20, stablecoins, wrapped tokens and even NFT, between the Ethereum and NEAR blockchains. This allows developers and users to take advantage of the increased processing power and low fees of the NEAR Protocol.
Rainbow Bridge is a fully decentralized, permissionless gateway that can be used with any Web3 wallet. The system works thanks to a series of smart contracts on Ethereum and Near's Layer2, Aurora. The operation is identical to that of most of the bridges that we know for cross-chain activities (for example, Multichain). This means that the tokens in Ethereum are locked in the smart contract within that network while in Aurora an exact copy of that asset is released, which can then be mobilized in NEAR without limitations. The opposite process is also possible, by burning the asset in NEAR and its release in Ethereum.
Now, Rainbow Bridge is possible because NEAR's Layer2, Aurora, has a fully supportive implementation of the Ethereum Virtual Machine. This means that any Ethereum smart contract can be ported to NEAR without major modifications. Thanks to this, it is possible to recreate ERC-20, ERC-721 and ERC-1155 tokens (the latter with NFT capacity).
Reasons to do this?
Well, operating in NEAR is much cheaper. For example, creating an NFT in NEAR can cost as much as $1 USD. On the other hand, in Ethereum, that value can be up to $100 or more, depending on the cost conditions of the Gas in Ethereum.
The other powerful reason is speed. Aurora is capable of reaching transaction confirmation in as little as 2 seconds. This leaves the 45 seconds on average that an Ethereum trade takes (as long as you pay the correct Gas) a long way off. This means that applications DeFi over NEAR Protocol are not only possible, but are hundreds of times cheaper than using networks like Ethereum. In fact, the DeFi ecosystem on NEAR Protocol has grown rapidly thanks to the facilities it offers to develop these applications on its blockchain.
On the other hand, Aurora uses the same working principle as Ethereum. That is, the computation fees of the smart contracts must pay a "Gas" using the NEAR token. There are also limitations on the size and capacity of Gas that smart contracts can use. This is to avoid infinite computing cycles and keep the network protected from spam attacks.
The NEAR token is the native token of the NEAR Protocol. It is a token derived from ERC-20 that works on the NEAR blockchain and takes advantage of the capabilities of Aurora for its operation. The token has a maximum supply of XNUMX billion tokens, making it a deflationary token. Among the main uses of NEAR is the payment of network commissions, payment of rewards, payment for access to dApps and services within the network and governance of the protocol.
A curious point about NEAR is that to maintain its scarcity, the rest of the transaction fees are burned. In this way, the inflation of the network is controlled and the increase in value of the token is encouraged.
Governance within the protocol
Governance within the NEAR Protocol allows the community to participate in deciding the future of the protocol. From making and voting on improvement proposals, to participating in bug fixes and bug bounties, to participating in updating system parameters and introducing large-scale changes to the core technology of the protocol. The ability to manage resources often includes the allocation of grant funds from community sources, such as the allocation provided to the Foundation.
NEAR's design principles apply to its governance:
- Usability: Governance processes must be clear and understandable. Active participation and voting mechanisms (where available) should be simple and straightforward. Governance must be effective and efficient, so that decisions are made quickly and implemented efficiently. The stakeholder community must have enough voice to support the legitimacy of the decisions and not abandon or fork the platform.
- Scalability: Governance needs to expand as the scope and complexity of the platform itself, the diversity of its stakeholders, and the breadth of participation grow.
- Simplicity: The strongest processes tend to be the simplest, so good governance must avoid over-engineering processes and recognize that person-to-person communication is often the easiest approach.
- Decentralization sustainable: Governance must allow the participation of all stakeholders in the platform, but must be resistant to capture by any of them over time.
To participate in governance, all you have to do is stake within the platform, which will give you voting power within it. You can also participate in governance discussions using the community forum arranged for it.