With the new year comes the new version of Shell Protocol.
Perhaps you’re brand new to Shell, drawn in by the promise of atomically composable protocols but trying to put your thumb on what exactly is Shell, anyway? If you’ve heard of Shell before, perhaps you’re here wondering why is the v3 update such a big deal?
The answer to both is: DeFi, unified! With seamless integrations for any project, Shell is on its way to becoming the schelling point for DeFi (pun intended), where users can easily bundle any project in an atomic transaction.
While the previous version of Shell was an important innovation in composable smart contract architecture, it had limitations. In particular, its power was contained within primitives that adopted its unique smart contract interface. Integrating externally-deployed protocols like Uniswap, Aave, or OpenSea was infeasible. But with Shell v3, that has changed.
This new version of Shell v3 brings Shell’s modularity and composability to a whole new level. Shell Protocol’s architecture allows you to atomically combine any set of transactions, like LPing, lending/borrowing, or making multi-token swaps. With Shell v2, this was contained to Shell-native primitives, but the new Shell v3 is designed to handle adapter contracts as well. That means external protocols (i.e., other protocols deployed on the same chain) can connect to Shell with a simple adapter contract.
Shell v3 is really exciting for developers, who can programmatically interact with any integrated DeFi protocol.
Integrations are completely permissionless and everything is open source. That means that anyone can take initiative and write an adapter contract, and integrate their favorite project with the Shell ecosystem.
With one smart contract adapter, protocols can instantly connect to a suite of other DeFi protocols. Teams that would otherwise be obliged to write their own integrations for every protocol they need to use, can now save development time (and massive headaches) by simply making one integration with Shell.
It also means getting built-in access to a variety of major DeFi protocols and their communities. In other words, the whole Shell user base instantly becomes a shared user base for the newly integrated project. This can help projects accelerate their own community growth and brand recognition. It’s a win-win.
Perhaps most importantly, dapps that were previously isolated automatically become another DeFi lego for the Shell developer community to plug-and-play.
As a permissionless platform, this above all opens up a world of potential innovation in DeFi. Independent developers can programmatically interact with everything on Shell, to build new and creative DeFi products. Your humble protocol can easily be a part of this future!
To get started, writing adapter contracts is relatively straightforward. There are examples and other resources in our developer documentation. If you’re already familiar with Shell Protocol’s architecture and the inner workings of the Ocean smart contract, most integrations can be done in a day. If you’re new to Shell, allow 2-3 days.
So let’s summarize the why’s:
- With one integration, instantly connect your project to other major DeFi protocols (more time for surfing 🏄).
- Accelerate growth with built-in access to a suite of DeFi protocols and their communities.
- Elevate your dapp into a DeFi lego for the Shell developer community to plug-and-play.
- With open source examples in the developer documentation, integration is quick and straightforward.
How to Integrate?
As mentioned above, all you need to do is write one adapter contract. Adapter contracts can have custom logic, but must follow a few key rules. Those rules are thoroughly described in the developer documentation. We also provide open source examples of existing integrations, and will add more as Shell adds new integrations.
For now, let’s go over a simple example. Let’s say you want to integrate an unknown DEX and make it compatible with Shell. All you have to do is to inherit the already-written abstract contract OceanAdapter.sol and implement three methods:
primitiveOutputAmount. Three methods, that’s all.
The Ocean Is Dark, but Its Future Is Bright
In time, Shell will add more and more integrations. In its first week, Shell v3 featured support for both Curve and Balancer pools, and Uniswap integrations are just around the corner.
With each integration, Shell becomes exponentially more powerful. Pretty soon, it will be unreasonable for smart contract developers to write their own integrations for distinct protocols—when they can simply integrate with Shell and get broad compatibility out of the box.
With that said, we are really excited about the future. Shell is already on its way to being more than just a protocol… it’s becoming a base layer for building powerful omni dapps.
Aloha and a big mahalo for joining us on this journey! 🤙
Join the Shell community!