Posts

Multi-Chain as a Scalability Strategy: Leveraging Moonbeam for Ethereum-Based Deployments

In the past few months, we’ve received a number of questions about our relationship with Ethereum. I’d like to clarify something: Moonbeam is designed to complement and extend existing Ethereum-based deployments, not to compete with Ethereum.

In a multi-chain future, Ethereum will continue to occupy a central position, particularly around DeFi and related use cases. We expect its already significant developer and project traction to continue. At PureStake, we are personally big fans of the Ethereum ecosystem including its battle-tested developer tools, among many other things.

In this future, it’s difficult to imagine a world with only Ethereum, or only Bitcoin. Many other chains will co-exist with Ethereum, including Moonbeam and other chains on the Polkadot network. There won’t be a chain monopoly on a particular use case — there will be DeFi activity on chains other than Ethereum as well to serve the users and assets on those chains.

With this context, Moonbeam will be highly complementary to Ethereum, offering the ability for existing Ethereum-based projects to migrate some of their workloads and state off of Ethereum layer 1 to Moonbeam, while at the same time extending their reach to users and assets on other chains.

Moonbeam as an Alternative Ethereum Scaling Strategy

There are two main ways that Moonbeam can help existing Ethereum-based projects: it can alleviate scale and cost challenges, and it can help extend the reach of those projects to users in the growing Polkadot ecosystem. Moonbeam will be optimized for hybrid deployment scenarios, where some of a project’s transactions and state are migrated to Moonbeam while continuing to maintain key components on the Ethereum MainNet.

As existing projects consider their scaling strategy in the face of rising Ethereum costs (in some cases making use cases unviable), Moonbeam presents an alternative to rollup strategies such as ZK and optimistic, and sidechains such as OMG and Matic Network. Moonbeam can provide many of the same scalability benefits as these strategies, but requires far fewer changes in order to achieve them. Its faster blocktime also enables better responsiveness and more granular on-chain data, which is highly valuable in many use cases, particularly for oracle price data.

Moonbeam itself will have substantially more throughput (and, in turn, lower cost) based on its Proof of Stake-based approach when compared to Eth1 and its Proof of Work-based approach.  Since Moonbeam is a single shard environment, composability will work the same way it currently does on Eth1.

Using Parachains for Projects with High Scalability Demands

It’s important to note that Moonbeam is not the final destination for applications that need the highest degrees of scalability. Projects with very high scalability needs will migrate some or all of their backend to their own dedicated app-specific blockchain, where they will have full control over upgrades, governance, and have the ability to optimize the underlying storage and transaction implementations to their use case. This dedicated blockchain can also include the Ethereum compatibility components that Moonbeam uses to provide a dedicated EVM instance.

An app-specific blockchain represents the ultimate in scalability and control for a given workload, even if it comes with additional responsibilities such as the underlying runtime implementation, establishing a token economy, and incentivizing and building a node community. If these app-specific blockchains become parachains on the Polkadot network, they will be able to gradually relocate workloads and state from Moonbeam to their dedicated parachains, as needs dictate.

Moonbeam was very much designed for these upgrade and migration scenarios; its entire purpose is to serve as a way to reduce implementation friction, quickly scale to meet immediate needs, and provide an easy entry point to expand into Polkadot and chains connected to Polkadot. And whether projects are deployed on Moonbeam or as Polkadot-based parachains, Moonbeam can continue to be a place where integrations are done and where functionality from app-specific parachains on the network can be composed into higher-order functions before being presented to end users.

Features to Support This Hybrid Model

This focus on Ethereum compatibility and integration has informed the priority features for Moonbeam. These include:

  • Full EVM implementation based on Substate’s Pallet-EVM (which in turn is based on SputnikVM). This is needed to provide assurance that existing Solidity contracts will have the same execution behavior as they do on Ethereum.
  • Web3 RPC compatibility which means that change will be minimized for existing DApp frontends, and that you can use existing Ethereum development tools such as Truffle, Remix, and MetaMask. We are already working with Parity to implement this as part of the Frontier project.
  • A bridge that allows movement of tokens and state between Ethereum and Moonbeam. This is needed to support the hybrid deployment model with a partial movement of logic, workload, and state to Moonbeam.

In the longer term, once XCMP and SPREE are available on the Relay Chain, we will introduce new operations that provide easy developer access to Polkadot’s cross-chain integration functionality from an Ethereum-compatible environment. These features will extend the reach of existing Ethereum projects to other Polkadot parachains and even other sovereign chains that are bridged to Polkadot.

To learn more about testing your Ethereum-based project on Moonbeam, please contact us. You can also join our Riot room or sign up for the monthly Moonbeam Dispatch to be notified when a testing environment is available.

Moonbeam Smart Contracts for Polkadot

Moonbeam: A Smart Contract Parachain with Ethereum Compatibility

We announced Moonbeam today, a smart contract platform that provides a scalable and accessible alternative to other developer platform options.

Moonbeam aims to provide developers with the ability to port existing Ethereum DApps or to create new DApps using familiar Ethereum development tools. This will substantially decrease the barrier to entry for successful Ethereum DApps that want to move to a more performant and cost-effective platform. Since Moonbeam is based on Substrate, the blockchain development framework from Parity Technologies, we are able to create a native Ethereum execution environment that provides Web3 RPC and EVM implementations to support most Ethereum DApps without significant modification. Moonbeam’s scalability and security is derived from running under Polkadot’s sharded design and shared security umbrella.

As a parachain on the Polkadot network, Moonbeam will also enable a number of interoperability scenarios, including integration with other chains to provide services such as Oracles, DEXes, and token transfers from chains such as Bitcoin and Ethereum.

Why We Decided to Build Moonbeam

We started last year as a validator on the Kusama network. Since then, we have engaged with the community, the technology, and the emerging ecosystem of tools and services. During this evolution of our engagement with Polkadot, we realized that an accessible smart contract parachain would fill a strategic need within the Polkadot ecosystem.

The primary development framework for building applications on Polkadot is the Rust-based Substrate framework. Substrate is very powerful, but it also is quite complex, where DApp developers need to account for things like how to incentivize node operators, how the resultant chain will be governed, and what the underlying token economics looks like. For some projects, it will make sense to use Substrate to build a full parachain or parathread. But for many others, a smart contract backend will be much easier and make more sense as a starting point.

By making it easier to create and migrate DApps to Polkadot, we believe we can help existing projects address the scalability challenges they are facing today. At the same time, we want to enable new cross-chain interoperability use cases — based on Polkadot — that will extend each developer’s ability to reach new users and assets. As more and more app-specific blockchains are developed to solve problems in a scalable way, this extension of developers’ reach to work with users and tokens on remote chains will be increasingly needed.

Our Focus on Ethereum Compatibility

This is a strategy motivated by practicality. Getting traction for a new developer platform is a numbers game. By providing Ethereum compatibility, we give ourselves access to the largest market of existing blockchain developers. It also allows us to leverage the relatively mature ecosystem of tools that exist in the Ethereum ecosystem such as Truffle and MetaMask.

There are also many Ethereum-based projects today that are facing serious scalability challenges due to the expense and constraints of the network. We have had conversations with projects that are considering a variety of strategies including Layer 2 solutions such as Plasma and ZK-Rollups, sidechain solutions, and also porting to other more scalable platforms. There are pros and cons to each of these strategies. The key friction in porting to another platform lies in all of the work that is required: project developers would need to reimplement existing Solidity backend contracts and DApp front ends using an entirely different technology stack, thus losing most of the valuable work they have already done. We believe that offering Ethereum compatibility on Moonbeam will greatly reduce this friction, and thus increase the attractiveness of the porting option.

Moonbeam Longer Term Vision

While our near-term energy is focused on implementing Ethereum compatibility and other base functionality on Moonbeam, we are very excited about supporting cross-chain interoperability scenarios. As XCMP, SPREE and other interoperability protocols are enabled on the Polkadot relay chain to power cross-chain token movement and remote chain RPC-like functionality, we will be actively adding integrations to other parachains into Moonbeam.

We anticipate that parachains on Polkadot will be purpose-built chains that provide specific functionality to the network and to their users. We envision that Moonbeam can serve as a simple and accessible place for these different parachain functionalities to be composed and combined into novel forms.

Naturally, this will position Moonbeam as an experimentation ground for building new applications that leverage Polkadot’s interoperability and shared security. If applications built on Moonbeam need more direct control over their resources and economy over time, they can always upgrade to a full parachain or parathread. This migration, if necessary, can be done using a gradual and co-existent approach, minimizing risk and providing project developers with multiple roadmap options.

Interested in Learning More?

We want to engage with you as we build out the Moonbeam ecosystem.  We’re actively seeking:

  • Substrate/Rust developers
  • Node operators interested in running collators

We’d also love to hear from:

  • Polkadot projects who are interested in collaborating
  • Ethereum projects that could benefit from Moonbeam

To learn more about the Moonbeam smart contract parachain, visit the project website or tune into my Sub0 talk (which will be focused on the technology).

PureStake Latest News Image Yellow

PureStake Announces Moonbeam, a Smart Contract Platform for the Polkadot Network

Moonbeam Allows Developers To Use Their Existing
Ethereum Applications And Smart Contracts On Polkadot

Boston, MA – April 27, 2020 – PureStake, a leader in secure and reliable blockchain infrastructure and tools, today announced plans for the Moonbeam smart contract platform. Due later this year, Moonbeam expands the accessibility of smart contract functionality by providing Ethereum compatibility and making it easier for developers to build applications that are natively interoperable with other blockchains and technologies.

Moonbeam will be released as a parachain on the upcoming Polkadot network, which is set to launch later this year. As a parachain — Polkadot’s approach to sharding — Moonbeam will benefit from shared security and composability with the entire Polkadot network while operating and developing independently. This also enables users of the Moonbeam network to move cryptocurrencies and other tokens natively across Polkadot parachains and parathreads, or across other networks via bridges.

“On Moonbeam, developers will be able to build applications that work with users and assets from other chains,” says Derek Yoo, CEO of PureStake. “This is a huge step forward in creating decentralized applications that natively interoperate across chains — opening up new potential markets for DApp developers.”

The Moonbeam network features several differentiators centered on promoting accessibility and interoperability across chains:

  • Smart contracts that work natively with other Polkadot chains or connect to external chains, like Ethereum and Bitcoin, via bridges.
  • Web3 and EVM support that makes it easy for existing Ethereum DApps and smart contract backends to migrate to Moonbeam and Polkadot.
  • Compatibility with familiar Ethereum development tools such as Truffle and MetaMask.

Moonbeam provides an essential service for the Polkadot network, which does not natively include smart contracts. Moonbeam smart contracts make it much easier and cheaper to build decentralized finance applications, which helps developers globally solve real-world finance problems using Web 3.0 technologies.

“Moonbeam’s approach promises to democratize the world of smart contract platforms in a way we haven’t seen before,” said Dieter Fishbein, Head of Ecosystem Development at Web3 Foundation. “Platforms that make it easier for developers to leverage the work they have across networks is core to Polkadot’s future and to the success of decentralized technologies as a whole.”

Visit the Moonbeam website for more information and updates: https://moonbeam.network/

About PureStake

PureStake’s team has extensive experience building technology companies and complex software platforms. Led by Derek Yoo, former Fuze Founder and CTO, PureStake provides infrastructure services and creates developer tools for next-generation blockchain networks.

Polkadot vs Ethereum Comparison Blog Banner

Choosing a Platform: A Comparison of Ethereum vs Polkadot

Polkadot is one of the most highly-anticipated next-generation, developer-focused blockchains. This comparison with Ethereum, the most widely adopted developer-oriented chain, is meant to help newcomers to the networks understand the differences between the two, and may help developers choose which one to build on.

At a high level, the two projects are only partially overlapping. Ethereum is a platform for deploying smart contracts, or pieces of logic that control the movement of native assets or state on the single Ethereum chain. In contrast, Polkadot aims to provide a framework for building your own blockchain and an ability to connect different blockchains with each other. Despite these differences, both platforms are designed for developers to build decentralized applications.

Despite Similarities, Very Different Strengths

In terms of similarities, both Ethereum and Polkadot aim to provide a space where developers can create decentralized applications. Both platforms include smart contract functionality, based on Solidity for Ethereum and Ink! for Polkadot. If we look forward to Ethereum 2.0, both platforms are pursuing a scaling strategy based on parallelized execution. Each thread of execution is called a shard in Ethereum 2.0, and a parachain or parathread in Polkadot. Both Ethereum 2.0 and Polkadot will use Wasm as an underlying technology to power on-chain logic and state transitions.

There are, however, important differences between Ethereum and Polkadot.

One of the biggest differences is design goals. Ethereum aims to be a platform for distributed finance and smart contract execution, whereas Polkadot has a vision of helping people build entire blockchains and integrating these blockchains with each other.

I have attempted to summarize what I consider some key points of difference below:

Ethereum 1.0 Ethereum 2.0 Polkadot
Architecture Single chain Multiple chains (shards) Multiple chains (parachains, parathreads)
Backend Development Solidity (JavaScript-like), Vyper (Python-like) Solidity (JavaScript-like), Vyper (Python-like) Rust, Substrate Framework
Execution Environment Single VM Multiple homogenous shards Multiple heterogeneous parachains
Composability Smart contracts can call each other synchronously Smart contracts can call each other synchronously in the same shard, or asynchronously between shards Smart contracts can call each other synchronously in the same parachain, or asynchronously across parachains
Governance Off chain Off chain On chain (e.g. Democracy, Council, Treasury modules)
Consensus Mechanism Ethash Proof of Work Casper Proof of Stake BABE/GRANDPA Proof of Stake
Program Execution Fees Per-call gas/metering-based Per-call gas/metering-based Market cost for parachain slot with unlimited usage or per-call parathread fee
Status (as of Nov 2019) Live since 2015 Will be released in phased milestones through 2021 MainNet launch expected in Q1 2020

LEARN MORE ABOUT STAKING ON POLKADOT WITH PURESTAKE

Ethereum: Large & Thriving, But Hitting Scalability Challenges

Ethereum’s key strength is its large and established ecosystem of developers, users, and businesses including its rich set of developer tools, tutorials, etc. It already enjoys significant network effects from this ecosystem, making it the de-facto smart contract platform to develop on. Ethereum standards, in many cases, become industry standards such as ERC-20.

The value of the Ethereum network is similarly significant, providing a high degree of economic security based on the value of the underlying Ether token. The DeFi space, which is one of the areas in the crypto space with the most developer traction, is largely built on Ethereum and leverages the composability between different Ethereum smart contracts that can call each other in the single Ethereum virtual machine that powers Ethereum 1.0.

The key challenge facing Ethereum is scalability. The success of the CryptoKitties application demonstrated some of the scalability limits that affect Ethereum 1.0. One popular application was able to significantly degrade the performance and throughput of transactions on the network.

Another challenge is the gas cost required to run smart contracts on the platform. Gas fees are required for the security of the system overall, and to protect the system from being stalled by runaway programs. But as the value of Ether has risen, gas fees for running smart contracts has also risen and has made certain use cases prohibitively expensive. These costs tie back to scalability, because if there were more capacity, the fees for each transaction could be lowered.

Ethereum 2.0 aims to solve all of these scalability issues, but it is multi-year roadmap with the execution risk that comes with a multiyear re-platforming initiative. Most of the Ethereum core dev energy is going into Ethereum 2.0, which leaves not much in the way of upgrades and improvements in the existing Ethereum 1.0 chain.

Polkadot: Built on a Flexible Framework, But It’s New and Unproven

Polkadot’s greatest strength is Substrate. Substrate is a development framework for creating Polkadot-compatible blockchains, offering different levels of abstraction depending on developer needs. Polkadot is itself built using Substrate. It dramatically reduces the time, energy, and money required to create a new blockchain.

Substrate provides a much larger canvas for developers to experiment on, as compared to smart contract platforms like Ethereum. It allows for full control of the underlying storage, consensus, economics, and state transition rules of the blockchain, things which you generally cannot modify on a standard smart contract platform.

The design of Polkadot — which allows for shared security within its network — is another strength. Shared security has 2 key benefits.

First, it reduces the burden on parachain builders by providing security-as-a-service from the relay chain. This is different than the approach taken by other networks such as Cosmos, where each zone is fully responsible for its own security. This shared security simplification lowers friction for builders and simplifies the process of launching a new parachain.

Second, shared security provides a framework for parachains to talk to each other, which ultimately allow will parachains to specialize. It reminds me of the old Unix philosophy, where you create tools that do one job and do it well. Then you can achieve higher order goals by combining these purpose-built tools together. I can see something similar happening in the Polkadot ecosystem. This is the power of the Polkadot design that should create strong network effects on the network.

To mirror the old real estate saying, the top three challenges for Polkadot are in my mind are: adoption, adoption, and adoption. Ethereum has a dominant position and the largest developer community of any developer-oriented platform. Further, there are a lot of new platforms coming to market that are looking to compete with Ethereum and gain developer mindshare.

At present, there are only so many developers to go around. We are in a situation where there are more developer platforms than there are developers to support and build on them. The real challenge for Polkadot is getting enough traction and building enough of an ecosystem and developer community for the network effects of their architecture to start to kick in.

How to Choose

In summary, if you are a developer researching these two platforms for your decentralized application, it is a little bit of an apples-and-oranges comparison.

Building on Ethereum is a safe choice and makes sense if your application can be expressed easily as a smart contract, if your use case is affordable in terms of gas fees, if you don’t need a large amount of transaction throughput or control over the underlying economics of your system, or if you need interoperability with other Ethereum ecosystem projects at launch. Development on Ethereum is generally going to be simpler than Polkadot.

If on the other hand, your application is best served by a dedicated blockchain, if it needs higher transaction throughput performance, if you want full control of the environment, state transition function, storage, and economics that your application runs under, and if you are okay with higher implementation complexity, or have use cases that require integration across blockchains, Polkadot will satisfy these requirements.

Have KSMs on Kusama? Nominate PureStake via This Address:

GhoRyTGK583sJec8aSiyyJCsP2PQXJ2RK7iPGUjLtuX8XCn