The lack of scalability for dApps has become a significant hurdle for their adoption as high fees, limited functionality, and low throughput capacity of the blockchains that they run on are not sustainable. According to DappRadar, the number of daily active users of dapps is actually lower now than back in November 2017, and that number has shown little meaningful progress in organic growth.
State of The Dapps (SoTD) also confirms the notion that dApp activity is concerningly low. According to SoTD, out of the 1,887 dapps on Ethereum, there are only 8,640 daily active users total.
Ethereum’s scaling solutions will be implemented in stages over the coming years, but many developers and users are itching to build and use dapps now. Other smart contracts platforms have not attained substantial network effects yet or are grappling with problems of their own.
EOS represents an alternative to Ethereum with scalability its primary focus but at the expense of decentralization and a history of polarizing governance. Zilliqa shows promise offering a high-throughput blockchain for building scalable dapps, but it is still in the testnet phase.
Scalability projects and platforms explicitly tailored to building scalable blockchain networks are seemingly everywhere now. However, scalability solutions that are platform-agnostic are increasingly becoming relevant as the industry trends towards interoperability and accelerating mainstream adoption.
An interesting innovation in dapp scalability comes in the form of the Tenfold Protocol, a layer two solution for building scalable dApps that is available to use now.
The Tenfold Protocol
The Tenfold Protocol is a language and platform-agnostic layer two scaling solution from Binary Mint. The purpose of the protocol is to alleviate the problems of dapps associated with the lack of scalability of the networks that they run on, for instance, Ethereum.
The protocol securely maintains a state machine off-chain while reading its state on-chain. At a high level, Tenfold can handle payments and general state transitions off-chain. This is important due to the considerations taken when designing the protocol, particularly how to distinguish between types of transactions and consider whether or not they all need the same security, speed, and decentralization.
Tenfold considers two fundamental categories of transactions:
Bounded transactions have confined values and are where the Tenfold Protocol implements its unique off-chain approach to handling them. Bounded transactions have conceivably limited values such as a Gym Mode training session for an Etheremon. These types of transactions are moved off-chain in the Tenfold Protocol.
Unbounded Transactions transfers have no upper limit (such as in ETH) for how much of the native token can be transferred in a transaction. These types of transactions need to be processed on-chain for maximal security.
Unlike other off-chain solutions, transactions processed on Tenfold can be processed on the main chain as well. This goes a long way towards interoperability and makes the protocol much more flexible than other off-chain systems.
Tenfold uses dapp games as an example to demonstrate how their protocol works since they provide a practical example of a dapp that requires many transactions and an interactive environment. The following paragraphs will be in the context of a dapp game, particularly Etheremon for ease of understanding.
The architecture of the Tenfold Protocol consists of 3 primary components:
- State Registry
- Validator Network
- Liquidity Market
The state registry is empirically a token-curated registry (TCR). TCRs are fascinating concepts that function as cryptoeconomically incentivized registries (lists) that are self-reinforcing. TCRs use on-chain, stake-based voting mechanisms for maintaining accurately curated registries across a network of token holders and hopeful entrants. Like most stake-based protocols, incorrect validation of unqualified applicants to a registry leads to slashing of the validators (token holders in the case of TCRs) stake.
In Tenfold, there is a state registry (TCR) for each dapp (game) that stores the state relevant to the dapp. Importantly, the state registry contains the specific state of the application. In regards to Etheremon, this would be something like the results of a Battle.
Validators are the nodes that monitor the state of the state registry. They ensure that only authentic updates are applied to the state registry and vote on state proposals that attempt to update the state of the registry.
Like other stake-based mechanisms, determining whether or not updates are valid require leveraging the concept of state machines. State machines — particularly deterministic state machines — are programs that always arrive at the same value when they have the same inputs and starting value.
Deterministic programs are exceedingly useful and Tenfold uses them by modeling each dapp as its own state machine. As a result, validators can download the state machine through decentralized file storage networks and broadcast the inputs of the state machine to an authenticated P2P network. Tenfold currently uses IPFS for its decentralized filesystem.
Validators can subsequently independently verify the correctness of an update since they maintain an independent copy of the dapp blockchain and can reference whether the update reflects the state of the dapp.
Tenfold employs a dual token system for incentivizing validators to act honestly:
- Application Tokens (AT) – Tokens issued by the application developer that are used in the validator process for updating the state registry.
- Protocol Tokens (PT) – Tokens issued by Tenfold that are utilized as part of the liquidity market that allows AT holders to lend AT to validators for staking. This alleviates concerns over the mismatch between AT holders and validators.
The Tenfold protocol has documentation pending on the specifics of the tokenomics of their liquidity market.
Tenfold is agnostic to both the underlying smart contracts blockchain and the programming language used. This type of flexibility is vital to take into consideration, especially since the interoperability of blockchain networks is on the horizon and plug-and-play solutions offer much more efficient alternatives to larger and more complex platform-oriented solutions.
Tenfold is also built to be compatible with Plasma, eventually hoping to build a platform that allows for the state to be updated and assets to be moved off-chain.
Tenfold’s advantage in being compatible with any state machine, written in any language, along with its ability to implement core logic in any programming language does come with its downsides, however. Notably, Tenfold is cryptoeconomically secure rather than cryptographically secure like other layer two solutions such as state channels. Cryptoeconomic designs are notoriously challenging to implement in real-world systems, and Tenfold’s pending paper on their liquidity market will elucidate the mechanics of its solution much better.
Despite this, many dapps games do not require the maximal security of on-chain cryptography and cryptoeconomic designs may suffice as long as specific transactions that require maximal security are settled on-chain.
One of the biggest takeaways from evaluating Tenfold is that it is available now. This means that dapps developers can integrate the Tenfold Protocol into their designs now rather than waiting for other scalability solutions to develop. As a result, dapps can alleviate many of the concerns surrounding their usage in the short-term.
Tenfold explicitly references its partnership with the Ethereum dapp game HyperDragons. As part of their collaboration, HyperDragons — part of The MixMarvel Universe — integrated the Tenfold Protocol with some promising results.
According to Tenfold:
- The simultaneous character limit in HyperDragons before Tenfold was 32. After integrating Tenfold, the concurrent character limit was 2,048 characters. That’s 64 times more characters.
- Before Tenfold, the gas cost reductions in the game were at 0 percent. After integrating Tenfold, the gas cost reductions reached 95 percent.
Overall, the Tenfold Protocol provides a unique opportunity for developers to build sophisticated dapps that are otherwise inefficient and not sustainable to build on-chain.
Scalability concerns with blockchains have led to some meager usage numbers for dApps recently. However, there are plenty of promising solutions available and on the horizon. Solutions like the Tenfold Protocol offer a flexible and clever solution for dApps to build scalable environments on multiple platforms and in multiple languages.