Ontropy Client: Your Personal Blockchain

A Chrome Extension of P2P Consensus

Apr 10, 2023

Ontropy’s Proof of Result allows users to trustlessly reach agreement on any piece of data, like random numbers or asset prices. In essence, the technology eliminates the third party oracle and empowers you, the user, to input the data yourself. This is accomplished through a simple extension that generates proofs and communicates peer-to-peer.

Completely noncustodial. Fully decentralized. 100% verifiably fair and unexploitable.

Source: DALL·E

Your Personal “Blockchain”

Blockchain is in quotes because Ontropy is not a rollup to which every user contributes data—it is far more powerful and decentralized.

Oracle networks and data nodes enable exploitation and are naturally centralized and monopolistic. Rather than external information sources on a rollup, Ontropy settles directly on the existing L1 or L2. As there is no additional point of failure, the data is as cryptoeconomically secure as the blockchain itself.

This is accomplished by the transacting users themselves acting as the oracles, nodes, and validators in a peer-to-peer consensus mechanism we call Proof of Result.

For every transaction, like two users completing a swap, they will communicate p2p, exchange proofs, and reach finality. I’ve previously described this as “off-chain consensus,” which is still true. Nevertheless, it might be easier to understand these cryptographic steps as a temporarily spun up blockchain for a transaction, in the same way one might spin up a server to handle more load.

Thinking of this as a “personal blockchain,” which replaces on-chain transactions or centralized interaction, highlights the massive cost savings and decentralization achieved.

As compared to a rollup, Ontropy enables a horizontal structure with many fault-tolerant personal blockchains. Because each chain has no external parties, verification happens instantly and for the price of electricity. As each user signs off on every piece of data individually, oracle and node exploitation are impossible.

Although data finality is achieved on the personal chains, it still must be realized on the larger L1 or L2 to exchange funds. So, users transact there based on the agreed upon price. They do this without any expensive proofs, but are able to reference the previously agreed data, and prove it unilaterally, if a dispute arises. In doing this, the personal blockchain has all of the benefits of an optimistic rollup, cheap verification, and all of the benefits of a ZK rollup, instant finality.

This entire mechanism reduces the point of failure from an unknown oracle to yourself and the blockchain being used for the transaction. The users and Proof of Result trustlessly port external data onto a blockchain, for the first time ever. Counterparty and third party data risk are abolished.

Source: Ontropy

Ontropy Client

The Ontropy Client is what makes off-chain consensus, this “personal blockchain,” possible. In the form of a browser extension, any two users with the Client will be able to communicate with each other and reach agreement in a trustless manner. It is Step 1 in the above diagram.

Ontropy is committed to the idea of verifiable fairness, so that the users can transparently prove the result in real time. The benefit of the Client is that Proof of Result will be open-sourced to achieve this. Users will have full sovereignty of their data and can even direct order flows between each other.

The Client will also temporarily store these proofs for the user in case a dispute arises in the transaction. As lying paralyzes the transaction and is easily punishable, merely storing these proofs is a strong disincentive from ever attempting to cheat. This means finality is achieved instantly in the vast majority of cases where all parties commit honestly. So, the stored proofs will rarely need to be deployed and can be deleted after on-chain agreement.

Proof of Result can be implemented directly within existing platforms, like Aave or Metamask. But the Ontropy Client is still useful because it allows users and projects to begin testing and transacting immediately, without waiting for industry adoption. Having an open-sourced version out in the world will let these projects see the tangible benefits of instant finality, cost reduction, and unexploitable information, thus expediting integration.

This Ontropy beta will serve as a large scale test for errors and bug bounties too. We can then award users on our native platform with ORB tokens and grant them a more favorable fee.

Data sovereignty is not only important for the end-users, but the Client will also give us more power and flexibility. Ontropy can allow users to directly sell the data to liquidators and oracles, and be paid for it. This would be more difficult through an Aave or Metamask intermediary.

Once Ontropy reaches substantial volume on a particular asset, users could directly swap with one another for the exact, fair market price. This is mostly likely to happen in low liquidity pairs where no reliable data feed exists. Here, users will come for the value-add of unexploitable and true spot price and stay to swap with similar users who form the only existing liquidity.

Combining these two features the Client makes possible: selling data and direct order flow, users could also sell their order flow directly to searchers during times of increased liquidations. For more on these topics, check out last week’s Low Liquidity Data Problems.

Ontropy as a Passport

The random number generation of today’s games, casinos, airdrops, NFTs, and seed phrases is not transparent. If you have ever gotten the feeling of “this game is rigged,” perhaps after getting five bad poker hands in a row or never winning your community’s lottery airdrops, you understand this problem. Randomness cannot and should not be handled by any centralized third party, especially not the one that is also distributing the winnings.

Ontropy derives from entropy (off-chain). We invented a mechanism for every user to generate verifiably fair randomness and prove it in real time. Similar to price feeds, players create a personal p2p “blockchain” that records everyone’s randomness contribution. The result is a completely unbiasable and unpredictable number for use in games, encryptions, and block proposer systems.

As the goal is to move random number generation from the game to the user, it tracks that a noncustodial layer must be added to maintain transparency. This is the Ontropy Client. Users who have installed the Client will connect with other users who are playing the same game, generate randomness, and send the result to the game or website. The game will then produce a result dependent on the user-generated number, and the Client will check to make sure this is the case (the user can also directly verify by comparing the number, card, or name generated in the client to the one displayed on the site).

Current “web3” games are merely web2 games with an NFT. All processing is still centralized and custodial…it is off-chain. Ontropy gives web3 games the power to actually be web3. Games can become decentralized without gas fees or latency, all through the power of these personal blockchains. Off-chain is a dirty word because it traditionally signifies centralization. Ontropy makes off-chain user-validated and secure.

The Client will first be integrated with web2 and web3 casinos utilizing Ontropy’s verifiably fair randomness. However, the possibilities do not end here. Because Proof of Result requires liveness and universal agreement, it can never scale to become a rollup. It is, however, perfectly situated to empower completely peer-to-peer gameplay.

To play a game of poker, users would commit their buy-ins on chain and then communicate directly and play with one another for as long as they wanted. This could work for any game lobby with less than 50 people so long as it was downloaded and not through a website—although the website server could remain one party with users performing occasional redundant checks, if desired.

Let’s take Immortal Game as an example. Immortal Games is a “web3” chess platform with NFT pieces, otherwise hosted entirely on a server devoid of true ownership. This is, of course, because no one would play a chess game that took 12 seconds and 5 cents to move one piece one time.

While it is nice for your color—black or white—to be verifiably random, the game of chess is mostly skill. How else can Ontropy decentralize Immortal Game?

Well, remember that Ontropy enables transacting users, in this case competing players, to spin up a “blockchain” for decentralized compute and agreement. This means the opposing chess players could communicate directly with one another, record moves and send only the final result (the result for which Proof of Result is named) to Immortal Game.

This is useful to the players because the experience is less latent through the removal of communication to a third party middleman. The experience is also decentralized, with neither the opposing player nor Immortal Game being able to rig or force stop the game—there would thus be no downtime, as the game results can be sent once the server is back up and running.

Peer-to-peer and off-chain consensus is useful for Immortal Game as it can dramatically reduce computation. They can reduce hosting costs as server load will decrease both from the elimination of them as a middleman and because they can intake and store less data. The NFTs and other blockchain assets gain new purpose through their use in Ontropy’s truly decentralized games. Rather than a JPEG depiction, moves can be signed with your NFT’s unique signature, without the on-chain cost. This is all not to mention the huge marketing potential of being “verifiably fair” for Immortal Game.

This example is a quick demonstration of how Proof of Result provides real utility to web2 and web3 applications. Ontropy has the potential to be the “Sign in with Google” of games and blockchain at large.