Money Legos Aren't Fitting Right (But They Could)

Hello Defiers! “Money legos” has become one of the most popular memes in decentralized finance, because it describes in just two words one of the reasons why this new financial system has the potential to be so much better than the old one: Protocols are built with open sourced code on top of public and global networks, which means applications can all integrate and work together, stacked and snapped into place in the way users find most useful. Instead of the walled gardens and zero-sum businesses of the incumbent system, DeFi can become one moving, growing, integrated organism.

Except, it doesn’t exactly work that way right now, says Evgeny Yurtaev, cofounder of DeFi portfolio manager Zerion. Instead of legos, DeFi is more like a puzzle, where each developer brings their own pieces to the table, and though they look alike and are meant to build the same picture, these pieces don’t really fit together. Yurtaev proposes a standard to connect all these pieces so that DeFi can live up to its promise and potential, and truly be money legos.

Both paid and free subscribers receive full guest posts, but paid subscribers get them earlier. Paid subscribers also get complete access to The Defiant content and archive, and access to the subscribers-only Discord chat —here’s the link!

🙌 Together with Ampleforth, a digital asset protocol for a base money which doesn’t require collateral and is uncorrelated with the rest of crypto.

Money Legos Aren't Always Easy to Play With

Decentralized shouldn’t mean fragmented.

By Evgeny Yurtaev, Zerion cofounder,

Exclusive for The Defiant

Intro

We’ve all come across the three “pillars” of DeFi: interoperable, programmable and composable. Interoperable refers to the ability to exchange and make use of information across systems; programmable means money is controlled by smart contracts, not people, and composable means the entire system can be selected and assembled in various combinations that fit perfectly together. Put simply, “DeFi is like money lego”. Or at least, it’s meant to be.

The reality is that building within DeFi is like anything but playing with lego. A more apt analogy is that it sometimes feels like we’re working on a complex puzzle together, but everyone’s brought their own bits to the table. The pieces look the same, they’re definitely intended for the same purpose, but they weren’t designed to lock seamlessly together.

In this article, I explore DeFi’s fragmentation problem and offer some thoughts on its broader implications as well as what we can do to fix it.

DeFi’s fragmentation problem

DeFi is becoming overly complicated. From a user perspective, interacting with different protocols and even tracking your portfolio is a logistical nightmare. It’s very rare to see dApps and wallets that facilitate direct transactions for multiple protocols. Consequently, a DeFi user who wants to put their money into 7 different DeFi assets most likely needs 7 open tabs to assemble their portfolio.

At Zerion, our experience working with different protocols has taught us a lot about the technical pain points that limit the growth of DeFi. We’ve integrated over 15 protocols over the past 12 months, and each one required its own unique process.

In the past, we’ve spent a lot of time researching the ins and outs of each protocol we want to work with – thinking through the UX and how it fits our interface and developing the backend and frontend for all our clients on the Web, iOS and Android. Most developers in the space face similar challenges.

The “perfect fit” of composability is an illusion. Interacting with smart contracts in any language other than JavaScript means you need to create your own library for each protocol, which increases complexity. If you want to add support for a new protocol, you often need to hardcode the integration via an ABI or rely on centralized APIs created by each protocol. There are some solutions like TheGraph, but they still lack support for many protocols along with some protocol-specific data.

Even the simplest things such as user balances and prices are usually grossly miscalculated, not to mention asset returns and more complicated metrics. Consequently, most wallets simply don’t support complex DeFi derivatives or perpetually show inaccurate data. For example, centralized exchanges don’t support lending, Coinbase Wallet supports only DyDx and Compound, and MetaMask doesn’t support any DeFi derivatives.

Behind the veil: a mix of incentives

If you look a little closer, it becomes evident that DeFi’s fragmentation problem is a byproduct of the interplay between different incentives.

Let’s look at protocols first:

Protocols rely on network effects based on liquidity for their success. More volume equals more credibility. This can create a wall for other protocols trying to innovate. Even if they compete on commission, they lack the credibility and liquidity to attract dApp and wallet developers to integrate with them, which means they lose out on market share.

From a developer perspective, it’s easy to become locked into using only a handful of major protocols. Due to the barriers inherent in DeFi, most protocols create their own unique developer tools. Adding a new protocol to a dApp means additional time and money that most small startup teams can’t afford, so developers stick to using the protocol-specific libraries and APIs they understand.

Users lose out because over time, the protocols and DeFi assets offered to them aren’t based on what they want, but rather on what’s available to developers.

As of now, DeFi is interoperable and composable only in theory. We need to create the instruments that allow us to easily integrate different protocols, or we run the risk of gradual centralization. This is not because dominant protocols like Maker and Compound are purposefully trying to stifle innovation, but because the way they are built creates invisible constraints on developers.

The value in making it easier for people to build and try out different protocols is that they may not gain huge traction, but they offer a glimpse into viable alternatives that could propel the space into more robust, sophisticated or user-friendly territory. Right now, the way DeFi is set up, that kind of diversity isn’t plausible.

Why we need to make “money lego” work

How can we mitigate skewed incentives and stifled innovation given the current DeFi landscape? What DeFi needs is a new level of standardization that removes the barriers placed on developers and smaller protocols.

DeFi needs its own version of the ERC20 standard. The concept of a universal API for tokens within smart contracts unlocked billions of dollars in value creation.

Lack of interoperability is what plagues traditional finance and DeFi doesn’t want to find itself in a similar position. Without the tools that enable a truly interoperable, programmable and composable financial system, scaling becomes extremely costly – which is why companies like Plaid make billions of dollars by facilitating the transfer of data between siloed parts.

To make DeFi work as intended, it needs infrastructure that enables scaling and innovation at low cost. A good analogy is how in the late 19th and early 20th centuries, railroads connected different economic agents like factories, ports and cities (protocols) and were able to transport goods (tokens) via a network of tracks. It was this standardization of transport that allowed for the exponential growth of the global economy.

At Zerion, we’ve started building a tool that we believe could solve DeFi’s fragmentation problem and address the issue of incentives.

DeFi SDK: Making Money Lego Work

DeFi SDK is an open-source system of smart-contracts designed to make it easier for developers to integrate DeFi protocols. It consists of basic token adapters and protocols that allows anyone to add support for DeFi assets using a single library. No more complex API pulls, spending months in consultation with different protocols, or trying to wrap your head around complex DeFi derivatives.

Compared to systems like InstaDapp’s DeFi Smart Accounts and DeFi Pulse’s Registry, DeFi SDK is completely on-chain and works with the entire DeFi ecosystem. We purposefully designed DeFi SDK to be modular and extensible so that new protocols can easily be added.

When protocols build their own DeFi SDK Adapters, any updates they make are automatically reflected on all dApps that are plugged into DeFi SDK, such as Zerion, MyDeFi, DeFi Market Cap and Frontier.

Developers can spend more time understanding what their users want instead of offering only the protocols they have the time or resources to integrate.

DeFi SDK is our attempt to solve the fragmentation problem across the DeFi space. We designed it the DeFi way, trustless and open-source.

Final thoughts

It is becoming increasingly complex to build within the DeFi space. New protocols appear almost weekly, and the cost of integration for developers now seems unrealistic. To address the problem of fragmentation and make “money lego” work for everyone, we need to work on improving the developer experience. We’re making the first step in that direction with DeFi SDK, and we are excited to lay down the tracks for better financial infrastructure.

Hope you’re enjoying The Defiant. If you are, spread the word!

Share The Defiant

The Defiant is a daily newsletter focusing on decentralized finance, a new financial system that’s being built on top of open blockchains. The space is evolving at breakneck speed and revolutionizing tech and money.

About the author: I’m Camila Russo, a financial journalist writing a book on Ethereum with Harper Collins. (Pre-order The Infinite Machine here). I was previously at Bloomberg News in New York, Madrid and Buenos Aires covering markets. I’ve extensively covered crypto and finance, and now I’m diving into DeFi, the intersection of the two.