Pantera Capital led the seed round in Offchain Labs, the company behind Arbitrum, a Layer 2 scalability solution. Below is additional information about the product.
● The current problem with smart contracts is that they are slow, hard to maintain, and cost a ton of money. Most contracts today are implemented on Ethereum, whose base-layer protocols require all miners to independently execute every step of the smart contract and cross-verify, which requires a ton of time and computing power. As a result, Ethereum’s transaction speed is only roughly 15 transactions per second, nowhere near where it needs to be for smart contracts to power large-scale decentralized applications.
● Offchain Labs is working on a new second-layer tool, Arbitrum, to address the immense cost and time concerns of base-layer smart contracts on Ethereum. Arbitrum essentially allows all the stakeholders in a contract to verify an agreement off-chain, or in the real world, and then record digital signatures confirming their agreement on-chain. This allows the system to advance the state of the contract without having to independently run each individual state of the contract on-chain.
● In the case of a disagreement, Arbitrum uses a bisection protocol to identify a specific step in the contract where disagreement occurs and resolve the dispute among stakeholders, reducing the amount of time and computing power necessary to fix disagreements.
● Arbitrum’s architecture also makes it possible for smart contracts to be 100% private, even from miners who previously needed to know the details of a smart contract. It’s also consensus protocol agnostic, making it extremely flexible to any kind of application–although the initial implementation sits on top of Ethereum.
● Arbitrum presents an extremely promising solution to the scalability problems of Ethereum, paving the way to fully decentralized, automated smart-contract systems that are easy-to-use, trustable, and fast.
The Scalability Problem
Smart contracts, or self-executing contracts or agreements implemented with code, are one of the most promising uses of blockchain, with applications to trading, arbitrage, and other financial systems. The gold standard for smart contracts today is the Ethereum blockchain, due to its modularity, accessibility, and relatively high-computing power for implementing these fast, automatic electronic agreements.
Yet as blockchain applications scale to millions of users and smart contracts, the pitfalls of the Ethereum protocol become more and more evident. Ethereum requires all miners (or verifiers of the contract, essentially those who implement consensus) to independently execute every step of every smart contract and cross-check against the official state of the smart contract; the most commonly cited statistic is that Ethereum can only verify 15 transactions per second, a rather small number when you consider the size and scope of blockchain networks. With applications that run dozens of transactions per second and have huge user bases, this global verification creates huge scalability issues––it’s simply not feasible for large blockchain applications to verify every single transaction independently with every miner.
What do people do about it today?
To be frank, there hasn’t been a good solution until recently. Generally, a smart contract’s demand for fast transaction speeds and verification conflicts with miners’ abilities to verify a contract transaction accurately and effectively. This causes miners to blindly approve transactions in what’s called the Verifier’s Dilemma, where they have faith to free-ride and accept transactions because:
(1) Any mistakes they make will be countered by the correct behavior of other miners who ensure the smart contracts behaves as it should, or
(2) Other miners are also free-loading, meaning that their own error won’t be detected by the system and they won’t face any personal penalties for incorrectly verifying a smart contract.
Understandably, this creates a lot of issues for applications that rely on smart contracts, because they no longer have a way to implement their smart contracts and underlying architecture in a trusted, efficient manner. Such concerns have created a lot of friction in terms of smart contract innovation and advancement.
So, what’s this new, better solution?
Offchain Labs, a blockchain research and development team run by world-class academics at Princeton and Cornell and a former deputy CTO of Obama’s White House, recently launched the Arbitrum protocol, which offers a fast, privacy-preserving, effective solution to the scalability problem.
How it works
Arbitrum is an extremely nuanced protocol, with a lot of technical and cryptographic complexity weaved in, but here’s a quick summary of its overall architecture.
The Arbitrum protocol can run on any underlying blockchain, but the first deployment will be on top of Ethereum. A component called the EthBridge (a smart contract running on Ethereum) will connect Arbitrum to the Ethereum chain, giving contracts compatibility with Ethereum but with the speed and privacy that Arbitrum offers.
All smart contracts in Arbitrum run as virtual machines (VMs), or basically a computer program that implements the rules of the smart contract through code. When the VM is created, the creator(s) assign validators to the contract, who each have the power to run the VM and force it to follow its code. Validators would generally be anyone who has a stake in the contract and would want to advance the state of the VM.
Arbitrum’s entire ethos is running contract agreement off-chain rather than on-chain. If all of the validators of a contract agree to advance the VM in the same way, Arbitrum will automatically accept the change to the smart contract, exponentially reducing the verification time. The EthBridge only has to record that hash, rather than advancing every VM on-chain.
If validators disagree about how the VM should behave, Arbitrum opens up a bisection protocol to resolve the dispute (essentially, a computational game where managers stake funds they have placed in escrow on the correctness of their claim) for the EthBridge to hone the disagreement down to a single step (think of it as a single tiny step in the VM code) in the smart contract. Once that step has been identified, a validator sends proof of that step’s execution to the EthBridge ––which can then efficiently check which of the validators has the correct state of the VM, and penalize the validator that sent the incorrect information.
All of the VMs can communicate with each other and all involved parties by running transactions and sending cryptocurrency, which makes the entire architecture extremely scalable and linkable––blockchain applications can run off of multiple Arbitrum contracts acting in tandem seamlessly.
So, altogether, what does Arbitrum offer?
Arbitrum’s benefits can be boiled down to three main categories:
1. Speed and Cost:
Traditionally, on-chain miners or verifiers have to run every step of the contract individually which exhausts a lot of computing power and incurs a lot of payments to Ethereum. With off-contract validation, the on-chain EthBridge is only verifying digital signatures instead of running the contract itself, which takes a lot less time and also incurs significantly smaller costs for the application developers. All-in-all, Arbitrum preserves the security of the smart contract while reducing a lot of the redundancy and bloat involved in its implementation.
One key takeaway of the Arbitrum protocol is that the on-chain components don’t actually run any of the smart contract’s code themselves––they only cross-check digital signatures provided by the validators, which provides little to no information about the behavior of the virtual machine, but just indicates whether there is agreement or disagreement, and resolves disputes. This means that parties who aren’t participating in a contract don’t need to see the code or the architecture of the underlying smart contract, unlike previous iterations of smart contracts where all the code and structure had to be public for verifiers to do their job. This allows blockchain developers to create truly private smart contracts while still enjoying the security privileges of smart contracts. Private blockchains are increasingly in demand, so Arbitrum provides an effective, fast way for developers to implement them.
Arbitrum’s off-chain agreement basically allows validators to change the state of the VM to whatever they want, as long as they all agree on it. This means that validators can easily adjust the VM and contract as they see fit, as long as there’s consensus. Another element of Arbitrum’s genius is that it’s consensus-agnostic. Its protocol doesn’t rely on any one underlying consensus mechanism for verifiers––it only requires that off-chain validators actually verify the contract. That means that although the first deployment is on Ethereum, in the long run application developers can choose whatever underlying consensus algorithm best fits the nature of their application, whether that be a single publisher or Bitcoin’s traditional Nakamoto consensus.
What about other Layer 2 Solutions?
You might have heard of layer two or second-layer solutions to the scalability problems of today’s most popular blockchains. A lot of them create huge advancements in the scalability and speed of these systems, but not without their own fallbacks.
To compare Arbitrum to some of the most popular second-layer solutions:
● Plasma: Plasma uses external contracts to send and receive funds, which incur huge waiting periods for users. Arbitrum doesn’t use this external contract architecture, which means that it loses no time sending funds through these external means.
● State Channels: State channels require absolutely unanimous progress to advance the state of a smart contract or runs intense computational jobs to resolve disputes. Arbitrum allows for non-unanimous progress through its bisection protocol and minimizes the computational load on the system in the case of disputes––everything is done through verification keys, not through emulating the smart contract itself, which means it is a lot lower latency.
Smart contracts are the underlying key to a lot of innovation in the blockchain space, especially as more modern developers gravitate towards decentralized, automatic systems for their backend infrastructures. Unfortunately, the poor efficiency and high costs of current smart contracts has placed a ceiling on such innovation––and there hasn’t been a great layer 2 solution, until just recently. Arbitrum offers an extremely promising way to implement off-chain agreement for smart contracts in a way that exponentially increases contract processing speed and reduces maintenance for developers. Offchain Labs’ new system might just be the key to creating fast, trustable, modular, and easy-to-use smart contracts to power a myriad of applications in various sectors.