Posts

Moonbeam Funding Announcement

A Look at Our Seed Financing for Moonbeam

We have just announced a seed financing round for our project, Moonbeam: $1.4 million from many of the most prominent venture capital firms in the blockchain industry. It’s a big milestone for us, but I’d like to take a moment to pause and explain how this fits into our overall vision for the project.

We have learned a lot since the beginning of the year, when we started the project in earnest. And we have been able to self-finance many efforts related to Moonbeam. In particular, we have made a lot of progress on development, including our collaboration with Parity on the Ethereum compatibility features in Frontier based on a grant from the Web3 Foundation. But now we have a clearer idea of what is needed for us to launch the network.

How We’ll Use the Funds

We need additional resources in a number of areas, including engineering, ecosystem development, marketing, and other crypto specialized skills. We will use the raised funds to hire additional Substrate, Rust, and Solidity engineers to help us deliver on the vision of Moonbeam.

We will also hire additional resources that can help us grow the Moonbeam project community and ecosystem. And we shouldn’t forget the legal council, security audits, and other services we need from a practical perspective to actually launch our network safely.

How We Chose Our Investment Partners

I talked to a lot of investors since the beginning of the year, when we started the project. The common thread for our investment partners is that we had a connection and engagement early on, combined with good knowledge of (and interest in) Polkadot. These investors believed in us and our vision, even before the Polkadot launch brought extra attention to the ecosystem.

Alignment around a long term vision versus a short term one was extremely important to us. We did not want to work with anyone that wasn’t willing to commit to longer time frames, or that wanted the ability to exit quickly.

Strategic alignment within the Polkadot ecosystem was also very important, which is why Hypersphere, a Polkadot ecosystem fund who led our round, was a natural partner. This — combined with support from Arrington XRP, Hashkey, KR1, Du Capital, and Bitcoin.com Exchange — gives us a strong set of strategic investors that can help us drive the project forward.

Our Anchor Partners

In addition to investors, I’ve also been talking to a lot of projects in the last couple months: both existing Ethereum-based projects, and net-new projects that are building in the Polkadot ecosystem.

We announced two initial partnerships along with our funding — Bet Protocol and Linear Finance — that will be building and deploying to Moonbeam. But we are engaged with many more projects that are exploring Moonbeam based deployments.

Based on the conversations I have had, there is no question that Moonbeam fills an important need and strategic space within the Polkadot ecosystem. There is a lot of interest in building on Polkadot. And, for some teams, building a Substrate-based parachain is the right answer. But for many other teams, Moonbeam based DApps represent an easier path that minimizes the change necessary to their existing codebases, while at the same time giving them access to the users and assets on Polkadot.

Looking Forward: Building the Moonbeam Community

We have been overwhelmed by the size and speed with which our community has grown. I know there are many people in our community that want to buy Glimmer (GLMR) tokens. We are working on ways that we can get tokens into the hands of our community members and achieve a broad token distribution, starting with our Kusama network deployment.

Our most immediate priority is to expand the team, particularly the Moonbeam engineering team, so we can deliver on the vision we have laid out. But we will also be working hard to figure out our token distribution plans for our Kusama and Polkadot deployments.

This seed funding event is an important milestone for the project, and we couldn’t have accomplished it alone. We are grateful for the support from our investors, partners, the Web3 Foundation, Parity, the Polkadot ecosystem, and everyone in our community that helped us get to this point. We will use the funds to continue to drive Moonbeam forward on a steady march to our Kusama deployment, our Polkadot deployment, and beyond.

Moonbeam Funding Announcement

PureStake Closes $1.4M Seed Round for Moonbeam Network

Company Will Use Funding to Launch the Ethereum-Compatible
Smart Contract Platform as a Parachain on Polkadot

Boston, MA – September 23, 2020 – PureStake, the company developing the Moonbeam smart contract platform, announced the completion of a $1.4 million seed round led by Hypersphere Ventures, a venture firm focused on Polkadot founded by Polkadot co-founder Robert Habermeier. Other notable participants include Arrington XRP Capital, HashKey, KR1, Bitcoin.com Exchange, and Du Capital. The funding will be used to accelerate development of the Moonbeam network, a Polkadot parachain focused on interoperability.

“Polkadot was designed to enable the creation of many blockchains, each one specialized and optimized for specific purposes,” says Robert Habermeier, Co-Founder of the Polkadot Network and Partner at Hypersphere Ventures. “Moonbeam is a great example of this principle: their smart contract platform is specialized to be accessible to a large segment of developers already familiar with Ethereum developer tools and will serve as an on-ramp to Polkadot for this community.”

BetProtocol, an Esports betting and crypto-casino protocol, will develop an implementation of their system on the Moonbeam Kusama and Polkadot networks, to allow entrepreneurs to launch blockchain betting apps with no coding required.

“Moonbeam gives us quick and easy access to users and assets in the quickly-growing Polkadot ecosystem,” says Rui Pedro Teixeira, Co-Founder of BetProtocol. “And we can develop our application using Solidity and Web3 — skills we already have — rather than needing to learn Rust and develop our own parachain using Substrate.”

Linear Finance, the first cross-chain compatible, decentralized delta-one asset protocol, is also working on projects that will leverage Moonbeam smart contracts.

“We are truly impressed by the Moonbeam team’s technological expertise in cross-chain integration and easy-to-use developer tools that allow us to quickly integrate and deploy on Polkadot with the existing Ethereum codebase,” said Drey Ng, Co-Founder and Product Lead at Linear Finance. “Users can enjoy a familiar dApp environment with a better user experience. We are excited for this partnership and see long-term value in this collaboration.”

Announced earlier this year and currently in active development, Moonbeam is a smart contract platform on Polkadot that is focused on Ethereum compatibility. This compatibility includes the ability to run Solidity smart contracts and applications built using the Web3 API. Further, Moonbeam supports popular Ethereum development tools like Truffle, Remix, and MetaMask, which allows Ethereum developers to quickly deploy applications to the Polkadot network.

The Moonbeam team received a grant from the Web3 Foundation in August 2020 for their work developing a Web3-compatible RPC library.

“From the start, we’ve been inspired by the idea of an open, interoperable blockchain ecosystem,” says Derek Yoo, CEO of PureStake. “The growth we’ve seen in our community and this investment are both expressions of support for the vision of a multi-chain future. We will be using these funds to expand the team and to help us deliver a strong Polkadot MainNet deployment next year.”

Moonbeam launched its first TestNet earlier this year and expects to deliver a parachain deployment on Polkadot in Q2 2021.

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

About the Moonbeam Network

Moonbeam is an Ethereum-compatible smart contract platform on the Polkadot network that makes it easy to build natively interoperable applications. This Ethereum compatibility allows developers to deploy existing Solidity smart contracts and DApp frontends to Moonbeam with minimal changes. As a parachain on the Polkadot network, Moonbeam will benefit from the shared security of the Polkadot relay chain and integrations with other chains that are connected to Polkadot. Currently in active development by PureStake, Moonbeam is expected to reach MainNet by early 2021. Learn more: 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 protocol implementation services and creates developer tools for next-generation blockchain networks. Learn more: https://www.purestake.com/

Moonbeam Monthly Dispatch September 2020

Introducing Moonbase Alpha, the Moonbeam Public TestNet

Moonbeam released Moonbase Alpha, its first public TestNet, today. This represents a major milestone for the Moonbeam project.

The goal of Moonbase Alpha is to provide developers with a place to start experimenting and building on Moonbeam in a shared environment. Since Moonbeam will be deployed as a parachain on Kusama and Polkadot, we want our TestNet to reflect our production configuration. For this reason, we decided that it needed to be a parachain-based configuration rather than a Substrate standalone setup. It is also essential for us to have a fully automated pipeline executing from GitHub all the way to the Moonbase Alpha deployment configuration.

Developing a Parachain-Based TestNet

Deploying Substrate-based chains as parachains has just recently become possible based on Parity’s work on the Cumulus library, among other things. This functionality is still very new and is actively being developed and improved.

While working to set up the TestNet with these technologies, we encountered several challenges which helped us understand how relay chain <> parachain interactions in Polkadot work at a lower level.

The first challenge was around building the environment, which involves a fair bit of complexity. The process requires two automated pipelines, each producing different outputs (Polkadot binary, Moonbeam binary) and these outputs need to be married to the correct, generated spec files for the Relay Chain Validator and Moonbeam Collator node roles. Then a third process requires us to create the Moonbeam genesis state and WASM binary, which is then registered to the deployed relay chain. These actions need to be automated to execute in the right sequence.

A second challenge arises from the rapid change that Substrate is undergoing. Rust limits us to only one version of a library at any given time. Thus, it took some workarounds to find a version of Substrate that was compatible across Rococo (which we are using as the base for our Relay Chain build), Cumulus (which is currently based on a one-month old version of Substrate), and Moonbeam / Frontier (which we are updating with Substrate master every few days). Hopefully, this will become less difficult as parachain functionality matures and stabilizes.

Moonbase Alpha Configuration at Launch

Currently, the infrastructure supporting the Moonbase Alpha TestNet is hosted by PureStake, the team developing Moonbeam. The initial configuration consists of a parachainrelay chain setup. The parachain has one collator producing blocks, while the relay chain consists of three validators, one of which is selected to finalize each block produced at the parachain level. This setup provides room to expand to a two-parachain configuration in the future. There are a couple of RPC endpoints for both HTTPS and WebSocket calls.

As part of this release, the Moonbase Alpha features implementations of the EVM pallet and the Web3 RPC in Substrate. Moonbeam leverages the Frontier project (for which PureStake’s contributions earned a Web3 grant) to support native Ethereum RPCs. Compatibility with existing Ethereum developer tools such as Truffle, Remix, and MetaMask have been tested and examples of using these can be found on our docs site.

TestNet Feature Roadmap

For the next TestNet update, PureStake is planning to add two key features.

First is the unification of Substrate and Ethereum accounts under the H160 format, an effort that we refer to as Unified Accounts. This is an important milestone because, in absence of this functionality, there are two completely different sets of states: one for Substrate accounts, and one contained within the EVM for Ethereum-based accounts. By unifying them, there will be only one kind of account in the system represented by a single address, instead of two.

The second feature is the inclusion of event subscription support (Pub/Sub). This component is missing on the Web3 RPC side, so we plan to add it since it is commonly used by dApps.

The alpha TestNet version that was released today does not support third-party collators. We will add support in a future update to enable interested parties to test their setups. This may also include the implementation of the rewards system, as well as the token economic model.

Other features such as on-chain governance and the treasury might be added in future updates as well.

Because the system is hosted by PureStake, Moonbase Alpha will run similar to how Polkadot MainNet ran in early times: with Proof of Authority instead of Proof of Stake. This means that block finalization is carried out by a known identity, in this case, the PureStake validators.

Getting Started with the New TestNet

As the first Moonbeam TestNet, there will be some limitations. Tokens on Moonbase Alpha, named DEV, will be issued on-demand. To request tokens, we’ve created a Discord bot (named Mission Control 😎) that will automatically send a maximum of 10 DEV tokens per hour (per Discord user). You can check it out on our Discord channel.

In addition, users only have access to Moonbeam (the parachain). In the future, we might open access to the relay chain, so users can test transferring tokens between Moonbeam and the relay chain.

Regarding smart contracts, this early iteration has no gas limit per block in order to provide an easy on-ramp for developers. This configuration will change in the future.

Getting started is fairly simple. Point your provider to the following RPC DNS for connections via HTTPS:

https://rpc.testnet.moonbeam.network

For the Web3 library, create a local Web3 instance and set the provider to connect to the Moonbeam TestNet:

const Web3 = require('web3'); //Load Web3 library
.
.
.
//Create local Web3 instance - set the Moonbeam TestNet as provider
const web3 = new Web3('https://rpc.testnet.moonbeam.network); 

Any Ethereum wallet should be able to generate a valid address or Moonbeam (for example, MetaMask).

For connections via WebSocket, you can use the following RPC DNS:

wss://wss.testnet.moonbeam.network

If you have any feedback regarding the Moonbeam TestNet, feel free to reach out through our official development Discord channel.

Moonbeam TestNet Announcement

Moonbase Alpha, the Moonbeam Network TestNet, is Now Available

This First TestNet Release Enables DApp Developers to Start Building
DApps and Solidity Smart Contracts in a Parachain Environment

Boston, MA – September 21, 2020 – PureStake, the company developing the Moonbeam smart contract platform, announced the availability of Moonbase Alpha, its first public TestNet. Now developers can test the Ethereum compatibility features of the Moonbeam network with their decentralized applications without needing to run their own nodes or host their own network.

Moonbase Alpha makes it easier for developers to deploy smart contracts to the platform. Developers can:

  • Use the existing Ethereum-based tools they know and love, like MetaMask, Truffle, and Remix
  • Re-deploy dApp front-ends and Solidity smart contract backends to Moonbeam with little or no change necessary
  • Collaborate with other teams in a shared environment that is monitored, managed, and will be updated with the latest Moonbeam code on an ongoing basis

“This is a big first step toward our KusamaNet and Polkadot-based deployments, and we’re eager to see what developers build on top of the platform,” said Derek Yoo, CEO of PureStake. “Understanding the real world use cases for some of the more complex smart contracts that we’ll support is an important part of both testing and vetting our code so we can prioritize the features we work on. The feedback we gather over the next several months will have a significant impact on the future of the network.”

To get started on Moonbase Alpha, join our Discord and visit our website: https://moonbeam.network/

This first Moonbeam TestNet is purely for development purposes — it continues to undergo significant development and enhancements from our engineering team, and the nodes are solely operated by PureStake. The team plans to release TestNet upgrades in the future that will add additional features, including the ability for external collators to start producing blocks on the network. More details are available on the Moonbeam documentation website: https://docs.moonbeam.network/networks/overview/

About the Moonbeam Network

Moonbeam is an Ethereum-compatible smart contract platform on the Polkadot network that makes it easy to build natively interoperable applications. This Ethereum compatibility allows developers to deploy existing Solidity smart contracts and DApp frontends to Moonbeam with minimal changes. As a parachain on the Polkadot network, Moonbeam will benefit from the shared security of the Polkadot relay chain and integrations with other chains that are connected to Polkadot. Currently in active development by PureStake, Moonbeam is expected to reach MainNet by early 2021. Learn more: 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 protocol implementation services and creates developer tools for next-generation blockchain networks. Learn more: https://www.purestake.com/

Moonbeam Monthly Dispatch August 2020

Moonbeam Monthly Dispatch: August 2020

Just as was the case in June, we have been primarily focused on implementation in the month of July.

Web3 Foundation Grant Award

Earlier this week, we announced that the Web3 Foundation had approved our work on a Web3-compatible RPC library and awarded us a grant. This RPC implementation is what allows developers to run Ethereum-native tools like Truffle, Remix, and MetaMask on Moonbeam’s network, which is based on Substrate.

This work is a significant milestone both in the development and continued evolution of the Moonbeam network, and for the interoperability of blockchains as a whole.

Details of the grant can be found here: https://github.com/w3f/Open-Grants-Program/blob/master/applications/web3-compatible-api.md

Progress

Technical implementation work continues in the Moonbeam and Parity Frontier repos. The first pass of work on the Web3 RPC REST endpoints is complete. We have also completed an automated test suite for the RPCs to ensure code quality.

In August, our key engineering efforts include the following:

  • Unified Accounts: This effort will unify the currently separate Substrate and EVM accounts that exist in Moonbeam. We aim to have a single Ethereum-compatible account that is used within the Moonbeam EVM and that is also used for Substrate-based functions on Moonbeam such as staking and on-chain governance.
  • Parachain-based Moonbeam TestNet: We plan to bypass the usual Substrate sovereign chain TestNets that most other projects are running, instead focusing on parachain-based TestNet. Initially, this TestNet will have a small relay chain for the Moonbeam parachain to connect to. This effort has only recently become possible based on development of the Cumulus parachain library.
  • Adding support for the subscriptions Web3 API to complement the existing REST-based RPC endpoints. The subscriptions APIs are needed by many existing Ethereum applications and are part of the Moonbeam minimum viable feature set.

Are you interested in trying out the Ethereum compatibility features of Moonbeam? We would love to hear from you. Please reach out to us on Riot.

Expanded Social and Chat Presence

We expanded the number of ways we have to engage with our community. There is a new Telegram group for general discussion about Moonbeam that can be found here: https://t.me/Moonbeam_Official

This Telegram group complements our Riot (now Element) room which is focused primarily on technical topics.

We also have a new YouTube channel, where we have posted an initial set of tutorial videos.

Here’s our full set of social channels (many of which are new):

Recent Talks

In case you missed either of last month’s talks, we’ve posted the recordings to our new YouTube channel. Here’s what’s in store:

Web3 Builders: Introducing Moonbeam

In this webinar recording, I am joined by Alan Sapède and Telmo González Michelena to discuss the strategic and technical aspects of Moonbeam. If you’re interested in learning more about the system architecture and capabilities, this is a great video to watch.

Hackusama

As a judge for the Hackusama hackathon, I put together a brief presentation for participants. In it, I discuss the fallacy of a “perfect blockchain” and the lessons we can learn from Howard Moskowitz, a market research veteran in the CPG industry. I recently wrote a blog post discussing the topic as well, which you can read here.

 

Subscribe to This Newsletter

Want to receive these updates via email? Enter your email below to sign up for our Moonbeam Monthly Dispatch newsletter.

PureStake Receives Web3 Foundation Grant for Moonbeam

PureStake Awarded a Web3 Foundation Grant for Moonbeam Ethereum Compatibility

Developed Components Will Power Moonbeam, Allowing Developers to Use Existing Ethereum Applications and Smart Contracts On Polkadot

Boston, MA – August 5, 2020 – PureStake has received a grant from the Web3 Foundation for their work developing Ethereum compatibility for Moonbeam, a smart contract parachain. Accepted as part of Wave 6 of the Web3 Foundation grants program, PureStake developed a Web3-compatibile RPC library that allows developers to run Ethereum-native tools such as Truffle, Remix, and Metamask on Moonbeam’s Substrate-based network. The milestones were met and officially accepted by the Web3 Foundation.

Moonbeam is currently in development and expected to be released as a parachain on the Polkadot network — which emphasizes cross-chain interoperability — early next year. Moonbeam is designed to ease the transition for non-blockchain developers and Ethereum developers alike as they explore the cross-chain integration capabilities of Polkadot and its underlying Substrate framework.

“Ethereum compatibility is one of the most asked-about features of the Moonbeam network,” says Derek Yoo, CEO of PureStake. “We’re bullish that interoperability is going to be critical in broadening the users of blockchain technology, and the work we’re doing to support Ethereum’s Web3 RPC is an important step to getting there.”

The deliverables for this grant included:

  • A working Web3 RPC module
  • Transaction support
  • A demo of key integrations including Remix, Truffle, and MetaMask

You can learn more about Moonbeam on the official project website: https://moonbeam.network/

About the Moonbeam Network

Moonbeam is an Ethereum-compatible smart contract platform on the Polkadot network that makes it easy to build natively interoperable applications. This Ethereum compatibility allows developers to deploy existing Solidity smart contracts and DApp frontends to Moonbeam with minimal changes. As a parachain on the Polkadot network, Moonbeam will benefit from the shared security of the Polkadot relay chain and integrations with other chains that are connected to Polkadot. Currently in active development by PureStake, Moonbeam is expected to reach MainNet by early 2021.

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 protocol implementation services and creates developer tools for next-generation blockchain networks.

PureStake Latest News Image Blue

PureStake Announces Plans to Build Moonbeam on Kusama

Polkadot’s Canary Network Serves as a
Critical Pre-Launch Point for the New Platform

Boston, MA – June 23, 2020 – PureStake, a leader in secure and reliable blockchain infrastructure and tools, has announced plans to launch Moonbeam, an Ethereum-compatible smart contract platform, on Kusama prior to launching on the Polkadot network. By launching Moonbeam on Kusama, the cousin network to the Polkadot blockchain, PureStake will be able to experiment with the new platform on a fully-functional network and under real economic conditions before releasing it on the Polkadot mainnet.

PureStake has been active on Kusama since its launch last fall, providing secure and reliable validator services to other users and participants of the network. Known as the “canary” network for Polkadot, Kusama shares much of the same code as the Polkadot mainnet, which makes it a valuable proving ground and warning system for both technical and economic components of the project.

“The Web2-style, move-fast-and-break-things approach to software development doesn’t work in the cryptocurrency space,”  says Derek Yoo, CEO of PureStake. “Kusama helps us substantially de-risk changes and updates by running code under real economic conditions and creating a place where innovation and ideas can be worked out before they are brought to Polkadot mainnet.”

Moonbeam is currently in development and expected to be released as a parachain on the Kusama network later this year. 

Moonbeam’s Ethereum-compatible platform aims to ease the transition for non-blockchain developers and Ethereum developers alike as they explore the cross-chain integration capabilities of Polkadot and its underlying Substrate framework. You can learn more about Moonbeam on the official project website: 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.

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).

Blockchain Scalability Trade-offs Banner

Blockchain Scalability Trade-offs: How to Choose a Platform

Blockchain scalability is one of the most frequently cited reasons that blockchain adoption isn’t happening faster.

The truth is, most blockchain networks are slow when compared to traditional centralized technologies and networks like AWS or the Visa network. Ethereum, for example, can process transactions in the range of 15 transactions per second — and Bitcoin is even slower.

On the other hand, blockchain networks have unique properties, such as native digital scarcity and unstoppability, that cannot be achieved in the same way with centralized approaches.

As developers continue to experiment and iterate on novel uses of these properties in decentralized software applications, popular platforms are hitting up against scalability and transaction limits. In this context, blockchain scalability is widely seen as a limiting factor in further blockchain adoption among software developers and end users.

In response to these blockchain scalability issues, the community has poured a lot of energy into developing scalability solutions at Layer 2 (e.g. Lightning, Plasma) and migrating existing platforms to faster consensus mechanisms (e.g. Ethereum 2.0). These solutions are all interesting in their own right, but I would argue that they are less important for scalability than design decisions in the protocol itself, and the use cases which are being targeted by those designs.

Developers who are investigating which decentralized platform to build on should carefully consider their requirements and the design goals of the platform they are choosing relative to those requirements.  Two important trade-offs in order to achieve your optimum level of scalability for your application are the level of decentralization and the level of programmability that you require. Not every application needs maximum decentralization nor programmability.

The Top Two Trade-offs to Blockchain Scalability

Level of Decentralization

The Blockchain Trilemma

For those who are unfamiliar with the famous blockchain trilemma, it states that when designing a blockchain protocol, you can only have two of these three properties: security, decentralization, and scalability. The insight is that it is hard to achieve all three simultaneously.

From my point of view, the most interesting use cases for blockchains are related to the storage and movement of value, so any significant sacrifices to security seem like a non-starter.

The key point behind the trilemma is the relationship between decentralization and scalability. It is easy to achieve scalability if you sacrifice decentralization. For example, traditional deployments using AWS infrastructure achieve very high scalability in a centralized model. But in this deployment model, the key properties that make blockchains interesting — namely, native digital scarcity combined with unstoppability — disappear.

Some projects use this relationship to their advantage. Take the example of EOS. In the EOS network, there are 21 block-producing nodes. This is far fewer than Ethereum or Bitcoin. By becoming more centralized, EOS achieves far higher transaction throughput than either Ethereum or Bitcoin. Twenty-one nodes isn’t totally centralized, but it is much more centralized than many other blockchain networks.

EOS’s goal is to be decentralized enough to keep the most interesting blockchain properties intact, but centralized enough to achieve significantly higher performance than competing blockchain networks. The question to ask yourself as a DApp developer is, what level of decentralization does your use case require? How worried are you about censorship of your application? Many high-value-oriented use cases may require higher levels of decentralization; for others, it may not matter.

Level of Programmability

The level of programmability that is supported by a blockchain protocol is at least as important a factor for blockchain scalability as decentralization. The key question is, what use cases are your applications going after, and what level of on-chain logic do you need to achieve your goals?

I can think of a range of applications with varying needs for platform programmability, running from money and asset transfer use cases on one end of the spectrum to Web3/decentralized applications on the other end of the spectrum. A money transfer application, a securitized tokenization platform, or a marketplace for digital collectibles may be perfectly well served by a platform that supports a rich set of asset transfer use cases. Whereas, a DAO or decentralized exchange that needs extensive onchain logic would require a full Turing-complete programming environment.

All other things being equal, platform scalability degrades as you move toward a more decentralized model. Bitcoin seems to be an exception to this rule as it is firmly on the “money” end of the spectrum, but it also isn’t scalable. The point is that Bitcoin would be even less scalable if it had full Turing-complete smart contracting functionality.

Platform scalability also decreases as you add Turing-complete smart contract functionality. With Turing-complete smart contracts, you need a gas concept to meter contract execution and produce deterministic behavior, which adds fees and operational costs to your application. You also need to allow smart contracts to store arbitrary state or data on the chain, which leads to more fees and increased storage requirements for the underlying blockchain nodes. Most smart contract platforms have a single one-size-fits-all virtual machine for all contracts on the platform, which can also become a scalability bottleneck. All of these factors reduce the scalability and throughput of Turing-complete smart contract platforms.

Opposite Ends of the Blockchain Scalability Spectrum: Algorand and Ethereum

Let’s take a couple of concrete platform examples to illustrate the point.

Algorand Prioritizes Performance Over Turing-Complete Programmability

Algorand is a high-performance, next-generation blockchain that focuses on the money and asset end of the design spectrum, and is also highly decentralized (unlike EOS). It achieves very high performance and transaction throughput by focusing on money, asset, and asset transfer use cases and doing them well.

Algorand’s new scripting language, TEAL, is intentionally non Turing-complete to avoid the gas fees, arbitrary storage, and infinite loops that come along with Turing-complete smart contract platforms. These are specific choices that allow it to achieve high performance for the money, asset, and asset transfer scenarios. This is why applications supporting these use cases that have high throughput requirements, such as Tether and Securitize, are porting their applications to run on Algorand.

However, if your use case requires Turing-complete onchain logic such as DAOs, onchain DEXes, or the development of onchain decentralized protocols sitting above the base protocol layer like Compound or 0x, then the level of programmability in Algorand isn’t as good of a fit.

GET STARTED WITH PURESTAKE’S API SERVICE FOR ALGORAND

Ethereum Prioritizes Turing-Complete Programmability Over Performance

By contrast, Ethereum is the most prevalent full smart contract platform. Ethereum puts programmability first, at the expense of throughput and scalability.

Scalability issues on Ethereum result from arbitrarily complex logic execution and arbitrarily large storage that comes along with its smart contracts. Logic and storage are metered by gas fees, and these fees have increased over time as the number of smart contracts has increased. The underlying blockchain on an Ethereum full node (let’s leave out archival nodes for now) takes over 100GB of storage and growing. Ethereum has a small fraction of the scalability of Algorand from a transaction-per-second and node storage perspective.

However, what you get in return is the ability to express arbitrary smart contract logic in the Ethereum virtual machine. And since all the programs run in the same virtual machine, you get composibility between different contracts which is driving a lot of advances in the DeFi space right now.

For DApp developers, you should carefully consider which parts of your application need to be de-centralized / onchain, and if you really need a full Turing-complete smart contract language to build your application. Turing-complete smart contract platforms allow for arbitrary expressions of onchain logic, but often at a cost in terms of scalability and throughput.

Choosing the Right Platform for Your Application

The scalability of the underlying platform is a critical part of choosing where to build. Even if your application itself doesn’t need high levels of scalability, those scalability challenges inevitably lead to high transaction fees, which will increase your operating costs as an application project, and may make certain use cases unviable from an economic perspective.

You should carefully consider the level of decentralization and programmability you need to support your use cases when choosing a platform. For a use case that requires only an ERC-20 contract on Ethereum, but does not require interoperability with other Ethereum smart contracts, it may make sense to look at platforms that are optimized for this scenario, such as Algorand. On Ethereum, you could be paying a lot more unnecessarily without realizing the benefit of the increased programmability.

 

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