Abstract Introduces “MyFi”: A Case Study
dApps as Consumer Software on Distributed Compute
Abstract
As the technology for decentralization evolves, so should the ideas that surround it. MyFi, short for My Finance, is a new era of decentralized finance (DeFi) that promotes self-sovereign financial applications. MyFi’s inception was sparked by technical advances in smart-contract application development. At its core, MyFi allows developers to vend their decentralized applications (dApps) as consumer software while reducing users’ trust assumptions about that software.
DeFi dApps: A Pragmatic Analysis
Decentralized Applications, dApps in short, are applications hosted on distributed systems, the most common of which are blockchains. Each dApp defines a set of unbreakable rules in code, broadly called smart-contracts. Smart-contracts can be deployed to a blockchain network which ensures that they are executed correctly.
After the application is deployed, any user is free to interact with it by initiating a transaction on that blockchain network. Blockchains use these transactions to share the network’s compute with its users. As applications often get upgraded with new features or bug fixes, the original developers typically remain in full control over these dApps, giving them responsibility for the safety of the contracts’ code.
These properties: a secure execution environment, the monolithic deployment of applications, and the shared access to those applications through transactions is what makes blockchain applications so different. These unique features lead to the birth of Decentralized Finance (DeFi) and the creation of hugely successful dApps. Examples include Uniswap , an automated market maker protocol, and Compound, a lending and borrowing protocol, both of which have attracted billions in capital. So what’s next for this industry as it matures? History has us convinced it lies in software distribution.
Software Distribution
The act of making an application available to users, promptly named “software distribution” has seen its fair share of evolution since the introduction of programmable computers.
In the early days of software development, programs were written and made available through mainframes, big and expensive computers that were shared between user like a valuable commodity. The process of distributing the software written for these behemoths wasn’t very different from how software is deployed and managed on modern blockchains. Developers would:
- Write their software.
- Test it on a mainframe (when one was available).
- Finally, deploy it to a mainframe for others to use the next day.
The process for dApp developers today looks the same:
- Write their smart-contract.
- Test it on a public testnet (testing blockchain).
- Finally, if all seems fine, push it to a mainnet blockchain for public use.
Luckily software distribution have moved a long way since the mainframe era. In the modern age, people have ownership of their own devices like a smartphone or a PC, allowing them to install whichever applications that they like.
Software distribution platforms like the Apple App Store and Google Play Store enabled these device owners to discover and “own” their software by installing it on their own devices. These practices lowered the barrier for users to try out new software and for developers to get their software in the hands of users. This ability to publish software on widely-used app marketplaces enabled smaller teams to compete with software monoliths, launching the era of software startups operated out of musky basements.
While DeFi dApps are technically decentralized as they exist on blockchains, their management is fairly centralized, as most dapps are still hosted services. dApp creators maintain the ability to update their dApps at any time, risking users funds and robbing them of the sovereignty Web3 should bring to users. DeFi as a service is not decentralized.
Abstract Money is bringing dApp ownership back to users and paving way for MyFi: a new era of decentralized personal finance.
MyFi
Self-sovereignty and ownership are foundational values of Web3, nonetheless our status-quo has partly relinquished these responsibilities to on-chain financial services providers. Blockchains give us the tools we need to create public financial infrastructure (DeFi), and using these same tools, we can build sovereign personal financial infrastructure (MyFi).
Over the past two years, we’ve developed the Abstract SDK, a modular framework for dApp development. The Abstract SDK is designed for organizations and individual developers to build composable, distributed applications in a fast, secure, and cost-effective manner.
For maximum composability and extensibility, Abstract Apps are built upon Abstract Accounts, our smart-contract accounts. If you’re coming from EVM, these are similar to a Gnosis Smart Accounts, though far more interoperable (more on that later). Developers using the Abstract SDK build modules: standardized smart-contracts that isolate shared logic and can extend the functionality of an Account, making it an application. These modules can be composed, allowing teams to collaborate in building more advanced applications, component by component.
So every Abstract App is account-based. What difference does it make?
First, it allows users to be in full control of their funds and their applications. Similar to how mobile apps are installed directly on user’s devices, Abstract apps are installed directly on user’s Accounts. The user remains in full control over their installation at all times, and can choose to upgrade to new versions should the developers publish bug fixes or otherwise. And because the contract instance is owned by the user, they can have much finer control over the settings of their applications.
And for developers, letting users self-custody their funds in their personal apps has enormous legal advantages. As teams never gain control over or custody funds, they are much better protected from legal scrutiny. Knowing this up-front can save teams tens of thousands of dollars in legal costs! Contrary to what some people might think, developers don’t actually want the risk of managing funds that are not theirs. Until now, this responsibility has been assumed.
The MyFi model inverts the traditional relationship between users and dApps. As users are now in control, they need a way to discover and manage their applications. Enter the Abstract dApp Launcher: a multi-chain dApp distribution and discoverability platform.
Dapp Distribution and Discovery
With Abstract MyFi, instead of deploying dApps themselves, developers publish their dApps on-chain to the Abstract App Store (shown below).
Interacting with the Abstract App Store will feel familiar. Available dApps are showcased and new releases are featured on the home page. Upon discovery, users can install the dApp directly on their Account, making it available as a shortcut in the Launcher for immediate use.
We’ve designed this experience to be as seamless as possible, hiding all the complexities of the underlying technology to let users focus on apps, not chains. Cross-chain transactions, bridging, and even gas expenditure are hidden from the user, making it as seamless as downloading and using an app on a smartphone.
Chain abstraction is native to our platform. With Abstract Accounts, users can manage their dapps and accounts on any chain, though they are none the wiser. For devs, they can write their apps once, distributing them to users of any chain in the overarching CosmWasm ecosystem.
Let’s see a concrete example of how this is used.
MyFi Case Study: Carrot Savings
To showcase MyFi and flex the power of our multi-chain platform, we’ve developed Carrot Savings, a multi-chain stablecoin yield aggregator.
Carrot Savings is an Abstract App that gives users access to high stablecoin yield opportunities from protocols and chains across Cosmos.
You can onboard to Carrot Savings in 2 easy steps:
- Create a new Abstract Account with any sign-in method.
- Install the Carrot App with initial funding, giving immediate access to yields.
Once installed, the app itself performs the yield strategy directly on your assets without them sending them out of your Accounts! So just like on your phone, the Carrot App will request certain permissions — not your location or access to your photos — but permissions to interact with external protocols on your behalf.
V1 of Carrot Savings leverages an Osmosis stableswap pool, providing liquidity from a user’s wallet using AuthZ for proxied permissions. Each user is in full control of the underlying contract and has the ability to revoke permissions at any time. After the setup, a bot will execute compounding actions on the user’s behalf. The user can inspect their position on the Osmosis frontend itself or through our web-app.
V2 of Carrot Savings, currently under development, will integrate additional yield sources and allow for multiplexing across multiple protocols. The process of migrating from V1 to V2 will be simple and the custody of the funds always remains with the user.
Closing Thoughts
From a confusing multi-chain UX to the struggles of creating brand awareness, the Web3 landscape is plagued by challenges effecting both users and developers.
MyFi is a wholistic response to these challenges. Users can discover and interact with the interchain through our launcher without being confronted with technicalities. In turn these users become an attractive audience for developers to target through our built-in app-store. By creating personalized blockchain products, developers have an easier time identifying the needs of their users and iteratively pushing updates to those who are willing to experiment.
In the end, our goal is to foster experimentation and ideation by significantly lowering the barrier to bring a dApp to market.
Do you want to help us make this a reality or are you interested in building with our software? Follow up with us on Discord, start reading our docs or discover our open positions!
