Smart Contracts and dApps: Comprehensive Overview of the Landscape

Smart contracts and dApps remove the need for intervention or trust in finance and all its extensions. As Web 3.0. becomes more and more decentralized, dApp use cases and relevance will increase. The Merge of Ethereum, interoperable platforms, and other blockchain innovations revolve around smart contracts.

What is a Smart Contract?

With great financial decisions comes great risk. And protect against these risks, parties use formal agreements. That way, if one party doesn’t comply, a third one makes sure they do, whether that’s an escrow company, a bank, or the government.

The question is, how reliable are these 3rd parties?

Experience shows they’re not necessarily safer. Instead, they introduce different risks:

• Conflicts of interest where they take advantage of both parties (insider financial fraud).
• Management of platforms, access, and accounts (suspensions).
• Arbitrary change of terms and conditions.

These “authorities” also make themselves a target for cyber-attackers. What if instead of looking for the most trusted 3rd-party, you remove them altogether? That’s the problem smart contracts solve.

These are computer programs that run automatically without needing anyone’s intervention. They’re like a vending machine where you put cryptocurrency coins to get what’s in the contract. All conditions are coded, so there’s no legal binding required.

By contrast, traditional contracts require third parties, which involve more costs and delays, and still can’t guarantee security.

We say smart contracts are secure because the executed functions appear on public, transparent blockchains. Anyone can see any wallet’s history from an online block explorer, so there’s no room for confusion. And contracts often leverage decentralized data providers (oracles) to guarantee that off-chain information is accurate.

The more secure information there is, the more functional they become. To interact with smart contracts, we use decentralized applications (dApps).

What is a Decentralized Application?

Decentralized applications (dApps) are regular apps with smart contract functionality. This means they can be developed for any purpose or coding language, but the transactional layer is blockchain-based. The biggest difference for users is that dApps don’t need registration, as they don’t manage your data or funds.

When using dApps, you can distinguish these parts:

• The main website (frontend) with a button to Launch App
• The app (backend) with a button to Connect Wallet
• The smart contracts that appear on your wallet when performing actions
• Most dApps often have their utility token (e.g., UNI for Uniswap v3)

While there are thousands of dApps, the foundational one is the wallet, also called decentralized or Web3 wallet. They’re like digital wallets, except there’s no registration, and there’s an integrated app browser. You need a wallet dApp like Metamask to use all other apps.

All you need for a Web3 wallet is saving a seed phrase (phrase password). As long as you don’t share it, you keep exclusive access to your wallet. You can then add funds for different networks (typically Ethereum) and browse dApps like Uniswap, LiquidLoans, or GnosisSafe.

Different Types of Smart Contracts

Millions of new smart contracts appear every year, so what makes them different from each other? Developers categorize them by niche, purpose, programming language, and others. The three most common types of smart contracts are:

Open Source Smart Contracts

Open source code allows anyone to see, distribute, or modify it. It allows users to know how the contract works and quickly recognize bugs and unintended features. Because anyone can change it, open-source smart contracts become more secure and efficient over time.

Most blockchains are open-source for this reason, especially developer networks like Ethereum.

Transparency allows users to find out inefficiencies and suggest corrections on future updates. But people can also use exploits to their advantage. Hence why sometimes the opposite is safer: private smart contracts.

Upgradable Smart Contracts

Like any code, smart contracts are expected to have flaws. On normal apps, developers would debug the code and create a version update. This isn’t easy with smart contracts, because they’re based on immutable blockchains.

Upgradeable smart contracts not only are autonomous but also include self-referential code. Developers can design how much freedom they have for future updates before sealing the code. They can use multisig systems to choose how many people should confirm actions of different security risks (e.g., tweaking a variable isn’t the same as creating new functions).

It’s not 100% decentralized, but at least users won’t be at high risk of bug exploits. Most contracts, however, aren’t upgradeable but immutable.

Compatible Smart Contracts

Just like the Internet, Web 3.0. is a community where someone else’s work can help others. Compatible smart contracts are programs that seamlessly integrate with different languages or blockchains. Developers should focus on their dApps rather than reinventing the same infrastructure.

Incompatible blockchains have limited growth for this reason.

The best compatibility example is Ethereum Virtual Machine (EVM). When a different blockchain is EVM compatible, it can import smart contracts from Ethereum Mainnet, which is the largest dApp marketplace by far. Any project forked, derived, or built on Ethereum is compatible with it: BNB Chain, Polygon, Avalanche, Cardano, Tron, EOS, or PulseChain.

Different Types of dApps

Browsing dApps can be as overwhelming as every other app store. There are roughly 10M mobile apps and “only” 4,000 dApps. The difference is that many do the same, and not all of them are safe (there’s no “dApp store” to regulate decentralized software).

The good news is, you don’t need to install hundreds of dApps, because they’re interconnected. It’s like installing a browser that allows you to visit thousands of pages. You visit the most recommended apps or the ones you need(that browser is your WEB3 wallet).

Even with a $0 wallet, you can connect to the three types of dApps:

Infrastructure Dapps

Think of a blockchain that doesn’t have smart contracts. There’s none. Unless it’s exclusively a currency (e.g., Monero), even networks like Bitcoin start with foundational contracts. When we refer to Ethereum as the smart contract pioneer, it’s not that they didn’t exist before, but Ethereum allowed users to create their own.

“Infrastructure” refers to the contracts blockchains themselves use to function. Because the application of a smart contract is called a dApp, blockchains can be considered infrastructure dApps. Bitcoin would be a dApp for payments, Ethereum a meta dApp to build other dApps, and so on.

A visual example is comparing blockchain and Web3 dApps as laptops and personal computers. Laptops have built-in components (often from the same brand), but they’re hard to replace, and the performance (scalability) isn’t as high. A PC is customizable and faster, as you can upgrade it with electronics from any brand.

Infrastructure “dApps” like Bitcoin have their own integrated contracts, code functions, and decentralized wallet. Protocol and application dApps can use others.

Primitive Dapps

Primitive dApps are also called dApp tools, as they have utility for most sectors. Just like online businesses need Internet services, application dApps need infrastructure and primitive dApps. Examples of these are:

• ENS or Unstoppable Domains for Web3 identification
• Certik or Hacken for crypto audits and security
• Curve, UniSwap, or PulseX for decentralized exchanges (DEXs)
• Filecoin, Storj, or IPFS for decentralized storage
• Lido, Nexus Mutual, Aave, Wormhole Bridge, or LiquidLoans for DeFi services
• Opera, Brave, or Metamask for browsers and decentralized wallets
• OpenSea or Magic Eden for NFT marketplaces

The more primitive dapps there are, the more applications developers can build for everyday people.

“Application” dApps

Application dApps are primitive dApps adapted for specific needs. They’re like 3rd party software providers, but decentralized. Entrepreneurs then use these smart contracts and dApps to solve problems in production chains, healthcare, legal agreements, cybersecurity, gaming, real estate, and all sectors except finance.

Financial apps are considered primitive and extensions of every other dApp.

Infrastructure, primitive, and application dApps work more like layers. The first one requires the most knowledge and design skills whereas the last one only needs a wallet and the Internet. All three create an inverted funnel to ease the adoption of crypto.

Smart Contracts Examples

Blockchain can sound abstract if you’re not a developer, and smart contracts don’t sound any clearer. Let alone coding one. What we do know is that Ethereum smart contracts are different from Solana, Binance, or Cardano. 

With such contrast, we can see the different ways smart contracts work and what they have in common:

Ethereum Smart Contracts

The overwhelming majority of smart contracts are created on Ethereum (over a million per quarter). It was the first ever dApp marketplace, and it will remain relevant as long as it’s scalable. Ethereum smart contracts are coded in the Solidity language and look like this.

Developers save a lot of time because of how large the ecosystem is. When building an application-type dApp, most of the code is just calling functions and contracts created by others. Not only is the language easy to learn but a common choice among blockchains. This means they’re EVM-compatible smart contracts.

The reason not all developers choose Ethereum is scalability/efficiency. How do you code a dApp that doesn’t spend unnecessary fees on the most expensive blockchain? The easy answer is switching networks.

Binance Smart Contracts

Binance is one of the most popular Ethereum forks, which implies they’re compatible and very similar. If you compare this BSC example with Ethereum’s, it’s almost the same structure. Many choose Binance instead for its high speed and low network fees.

You can see on BSCscan that most of the Binance history shows exponential growth, whether it’s gas usage, unique addresses, or average gas price.

There’s barely any difference between both developer environments. ERC-20 projects can migrate to Binance as BEP-20 (or the other way), which uses the same language (Solidity or JavaScript). However, Binance is far more centralized, as its consensus is identity-based, and there can only be 21 validators (recently increased to 40).

Solana Smart Contracts

Solana is one of the most efficient, fast-growing blockchains. Transactions are nearly instant and fees are below $0.01. It’s possible because of proof-of-history, a consensus mechanism that allows verifying the block order and time passed.

Unlike Ethereum, Solana has only experimented with contracts since 2020. It wasn’t until 2021 that they introduced the first DeFi apps and NFT marketplaces. This sped up Solana’s growth to the level of Binance, like SOL crossing $250 for the first time, or the millions of daily transactions it handles at light speed.

Solana isn’t EVM-compatible. Rust is the programming language used for creating new contracts (which look like this). Most developers will instead use JavaScript for Web3 integrations, as many dApps already have the contracts they need.

Cardano Smart Contracts

Cardano is all about efficiency and reliability. It doesn’t have the largest ecosystem (in fact, it’s the smallest and newest one). But it has the right balance for scalability, decentralization, and security. There are over 3,000 Cardano smart contracts with ~100 daily new ones.

One reason Cardano doesn’t grow as quickly as other environments is complexity. Developers have different languages to choose from, like Haskell, Plutus (simplified Haskell, more reliable), Marlowe (for financial smart contracts), or Glow (for Cardano sidechains). Not only does this complicate communication among developers, but none of these make Cardano EVM compatible.

Using smart contracts isn’t easier. Metamask doesn’t support Cardano tokens, so you’ll need a different Web3 wallet (e.g., Yoroi). Interacting with Cardano smart contracts is similar to Binance: on average, transactions cost $0.20 and take 40 seconds.

Avalanche Smart Contracts

Not only is Avalanche scalable (4,500 TPS), but it’s designed around centralization. Which sets it apart from others like Binance or Solana and makes it a viable Ethereum competitor. They call it the blockchain of blockchains because of its complex, original architecture.

Avax is a Primary Network that coordinates three others. There’s the C Chain for smart contracts, X Chain for asset exchanges, and P Chain for platform staking and governance. Validators distribute across “subnets” and manage multiple chains at once.

C Chain is the most popular, as it’s EVM compatible. Developers build AVAX smart contracts like these on Solidity and apps like Remix, Truffle, and Vercel. Whether you build on X Chain or C Chain, transactions take below $0.18 and 1s.

Decentralized Application Examples

While you can access any dApp from your wallet, that doesn’t mean they’re all the same. Some apps exist only on other networks, and some are so exclusive you need a different wallet. But 90%+ of all dApps (and every single important one) belong to one of these ecosystems:

The Ethereum dApp Ecosystem

For every new dApp, 3 out of 4 are built on Ethereum. It’s the largest and most diverse ecosystem, with over 3,000 dApps and a dozen new ones per day. If you include all tokens created on EVM blockchains, the Ethereum ecosystem size is unimaginable.

The most predominant dApp type is financial protocols. Yield farming platforms, wallets, and exchanges make $35B to $100B+ in total value locked (TVL). A handful of projects dominate over 80% of the volume:

• Collateralized Debt Position, CDP: Maker DAO
• Liquid Staking: Lido
• DEXs: Uniswap, Curve,
• Lending: Aave, Compound
• Yield: Convex Finance, HEX
• Wallets: Metamask

Other featured dApps include:

• NFT Marketplaces: Opensea, X2Y2, LooksRare, and Gem
• Games: Illuvium, CryptoKitties, Decentraland
• Other: Crypto.com swap, Gnosis Protocol

The Binance dApp Ecosystem

As EVM, the Binance ecosystem benefits from Ethereum. Still, barely 300 dApps are native on the BNB Chain. Out of those hundreds, most are inactive, and only about 20 are relevant.

In DeFi, the TVL is $5.5B ($20B at its peak), 54% of which belongs to PancakeSwap (DEX). Featured projects include:

• DEXs: BiSwap, BakerySwap, KnightSwap
• Yield: Alpaca Finance, Venus Protocol
• NFT Marketplaces: Altura, AirNFTs
• Games: Mobox, MetaverseMiner, BinaryX
• Other: Seedify, Quantic

The Solana dApp Ecosystem

Solana has rapidly grown an ecosystem of 350+ dApps, most of which launched in late 2020. Some of these have become as relevant as Ethereum’s featured projects, even though Solana isn’t EVM compatible.

The TVL ranges from $1.5B to $10B, and it consists of platforms like:

• Lending: Solend, Mango Markets
• Liquid Staking: Marinade Finance
• DEXs: Raydium, Serum, Orca
• Yield: Tulip, Quarry, Saber
• NFT Marketplaces: SolanArt, MagicEden
• Wallets: Phantom, Solflare

Solana isn’t always a stable network, which slows down the marketplace expansion (e.g., Solanart is no longer a Top 5 dApp for this reason).

The Cardano dApp Ecosystem

Cardano is an ecosystem in development with negligible influence. While there might be up to 1000 projects, most have no volume or have tiny communities. An estimated 70 dApps are active, five of which make dominate the TVL (currently at $100M and $400M at its peak):

• DEXs: Minswap, WingRiders, SundaeSwap, MuesliSwap
• Lending: Meld
• Wallets: Daedalus, Yoroi, AdaLite

The Avalanche dApp Ecosystem

Avalanche is compatible with hundreds of dApps from Ethereum, yet only a few successful ones are made in Avalanche. Like Cardano, you might see AVAX as an early-stage ecosystem. DeFi dApps make a $3B TVL ($23B+ at its peak), and the dominant platform is Aave (Ethereum-native).

Featured platforms:

• DEXs: TraderJoe, Yeti, Pangolin, Curve
• Yield: Benqi, Vector Finance, Yield Yak
• NFT Marketplace: JoePegs
• Other: Wonderland, Stargate, GMX,
• Wallet: Avalanche Wallet

Use Cases for Smart Contracts and dApps

Smart contracts and dApps bring a new approach to finance, which extends to almost every sector. Use cases include the reinvention of existing services, new features coming from innovation, and the combination of both.

Proof Of Ownership

Proof of ownership is the evidence used to identify assets as yours. Until smart contracts, however, ownership was trust-based. To prove that you own a house or a trademark, you’d need agreements from a legal entity. To prove you own a website or digital asset, you trust the records from a web provider.

Regardless of the intention, a trusted party creates a single point of failure. What smart contracts do is execute the same agreements without party intervention. And because of its trustless security, your identity isn’t revealed or required for anything.

What is it like to interact with a smart contract? All you need is to install a wallet dApp like Metamask, add some funds, and you’re ready to sign transactions. There’s no KYC verification, and the smart contract confirms your action within seconds (depending on the blockchain’s block time).

Now, digital assets can stand for NFTs, allowing you to instantly prove or transfer ownership to anyone worldwide. NFT dApps help creators establish property rights and monetize art, software, and digital media products.

On-Chain Governance

Blockchain governance can be off-chain (in the form of informal forum discussions) or on-chain (when updates and voting rules are hard-coded). Since they’re trustless and autonomous, smart contracts create tamper proof systems. Everybody can participate in Improvement Proposals by suggesting or voting on changes.

On-chain governance doesn’t manage off-chain data such as market prices. Which makes its usage limited unless combined with decentralized blockchain oracles. As long as it prevents centralization, it makes DAOs more accessible and secure.

DeFi Services and Trading Tools

Traditionally, trust has been the foundation of finance. We trust governments for monetary regulation, banks for savings and lending, or exchanges for liquidity and services. But trust doesn’t work when there are conflicts of interest, which is why financial fraud is one of the biggest scams, especially online.

DeFi brings a trustless approach to those services while introducing new ones that weren’t possible because of those conflicts.

Providers can’t act against users’ interests because of smart contracts. And users interact with these through decentralized wallets. Because of DeFi dApps, users can place DEX limit orders, use arbitrage bots, or borrow without a credit score.

Legal Contracts

Legal agreements are the no.1 smart contract use case. Think of the many costs associated with formal contracts just to secure the deal. Clients often pay an extra 10% on closing costs, agent commissions, escrow fees, insurance, and more on safety deposits.

Trust is expensive and security isn’t guaranteed. Smart contracts are designed for security and don’t allow manipulation, which removes conflict concerns and costs. Imagine:

• Buying a home without wasting weeks and 5% of closing costs
• Completing international payments within minutes, bypassing middle banks and escrow fees
• Buying insurance where conditions are stated on code, so they can’t deny your deserved coverage
• Writing Terms of Use as blockchains programs to protect platforms from misuse.
• Instantly verify your ownership with NFTs for intellectual property and trademarks

The Future Landscape Of Smart Contracts

How relevant are smart contracts and dApps for the next decades? Blockchain looks nothing like what we thought it would be in 2017. We’ve seen early versions of DeFi, NFTs, and metaverse, none of which would be possible without smart contracts.

Whether they’re essential or not isn’t a question. It’s about who’s going to lead these technologies. With the current landscape, it seems Ethereum will dominate for a long while.

But we’ve also seen new blockchains catching up in just two years. So we should expect smaller competitors to gain relevance (e.g., PolkaDot, Harmony One, VeChain, Elrond…). Maybe Binance becomes more decentralized and competitive, Solana creates a more stable network, or maybe the Ethereum Merge outmatches everything else. You could also see Avalanche take off, which further complicates the landscape.

The future of smart contracts isn’t one blockchain but all of them. It’s about decentralization, interoperability, and cooperation. Those values brought Ethereum where it is today.