The Superteam Blog: Project Deep Dives

Indexing on Solana

Prapti Sharma — Fri, 05 Sep 2025 11:31:28 GMT

Building payment infrastructure on Solana requires understanding how to properly index blockchain data for centralized applications. Whether we’re building a centralized exchange (CEX), crypto gateway, or e-commerce platform, indexing is the foundation that enables us to track user deposits, process withdrawals securely, and maintain accurate balances.

This comprehensive guide covers everything we need to know about Solana indexing, from basic concepts to advanced security considerations for production systems.

What is Indexing?

Indexing means copying over the state of a blockchain to a Web2 system. In the context of Solana, it involves extracting specific transaction data from the high-throughput blockchain and storing it in traditional databases like PostgreSQL or MongoDB.

The goal isn’t to copy the entire blockchain — that would be expensive and unnecessary. Instead, we focus on indexing specific addresses or transactions relevant to our application. For example, we might want to track:

All transactions to our exchange’s deposit address
Activity on specific liquidity pools
Transactions involving particular token contracts
User deposits and withdrawals

The Solana blockchain processes hundreds of transactions per second since Genesis, generating terabytes of data. Our indexing system needs to efficiently filter this stream to capture only the transactions we care about.

How to Index: Yellowstone & Geyser

The most robust approach to Solana indexing is using Yellowstone, built on top of the Geyser plugin. These tools allow us to subscribe to real-time blockchain events as they happen.

Understanding the Architecture

When validators on the Solana network receive transactions and create blocks, they can run additional processes (plugins) that extract and forward specific transaction data. Yellowstone provides a gRPC interface to these plugins, enabling us to:

Subscribe to specific accounts or programs
Filter transactions based on our criteria
Receive real-time updates as transactions are confirmed

Available RPC Providers

Several providers offer Yellowstone services:

Triton: Created Yellowstone, offers premium indexing services
Helios: Competitor with their own indexing tools
Quicknode: Provides RPC and indexing infrastructure
Alchemy: Web3 infrastructure provider

Pricing and Access

Free Yellowstone servers exist (like parafi.tech) but with limitations—typically only allowing subscriptions to predefined accounts like the vote program. For production use, expect to pay:

Shift.io: ~$200/month for one connection
Titan: ~$1000/month for premium access
Custom validators: Exchanges often run their own validators with Geyser plugins

The Problem with Naive Payment Flows

Before diving into proper indexing solutions, let’s understand why simple payment flows fail. Consider a basic e-commerce site selling t-shirts for 0.5 SOL:

Broken Flow:

User sends 0.5 SOL to our address
User’s client gets the transaction signature
Client forwards the signature to our backend
Backend verifies the signature and ships the product

Critical Problems:

1. Lack of Atomicity (Client Crash) If the user’s client crashes after step 1 but before step 3, the money is sent, but our backend never knows. The user loses their SOL with no product shipped.

2. Transaction Sniping (Impersonation) An attacker can monitor our payment address, grab any transaction signature, and claim it with their own session cookie before the real user can. Our backend has no way to verify who actually sent the payment.

The Solution: Memo Program + Indexing

Solana’s Memo Program (MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr) provides the solution. This program logs arbitrary strings on-chain, allowing us to attach identifiers to transactions.

Secure Architecture:

Frontend requests to make a purchase
Web2 Backend generates a unique identifier (random number or user ID) and returns it
Frontend constructs a transaction with TWO instructions:
system_program::transfer to send SOL to our address
memo_program call with the unique identifier
User signs and sends this atomic transaction
Indexer (Yellowstone client) sees the transaction and parses the memo
The processor uses the identifier to credit the correct user

Implementation Example:

import {
  Connection,
  Keypair,
  LAMPORTS_PER_SOL,
  SystemProgram,
  Transaction,
  sendAndConfirmTransaction
} from "@solana/web3.js";

import { createMemoInstruction } from "@solana/spl-memo";

// Connect to Solana cluster
const connection = new Connection("http://localhost:8899", "confirmed");

// Create keypair for the fee payer
const feePayer = Keypair.generate();

// Request airdrop
const airdropSignature = await connection.requestAirdrop(
  feePayer.publicKey,
  LAMPORTS_PER_SOL
);

// Confirm airdrop
const { blockhash, lastValidBlockHeight } = 
  await connection.getLatestBlockhash();
await connection.confirmTransaction({
  signature: airdropSignature,
  blockhash,
  lastValidBlockHeight
});

// Create transaction with transfer and memo
const memoInstruction = createMemoInstruction("Hello, World!");
const sendSolana = SystemProgram.transfer({
  fromPubkey: feePayer.publicKey,
  toPubkey: Keypair.generate().publicKey,
  lamports: 0.5 * 1000_000_000
});

const transaction = new Transaction()
  .add(sendSolana)
  .add(memoInstruction);

// Sign and send
const transactionSignature = await sendAndConfirmTransaction(
  connection,
  transaction,
  [feePayer]
);
console.log("Transaction Signature: ", transactionSignature);

Why This Works:

Solves Atomicity: The indexer runs independently and will always see confirmed transactions
Prevents Sniping: Payment and user identifier are locked together in one atomic transaction
Cost-Effective: We can use simple RPC polling instead of expensive Yellowstone for single-address indexing

Required Memo Extension for Token Accounts

For enhanced security with token transfers, Solana offers the Required Memo extension. This ensures all incoming token transfers must include a memo.

Creating Token Account with Required Memo:

import {
  TOKEN_2022_PROGRAM_ID,
  getAccountLen,
  ExtensionType,
  createInitializeAccountInstruction,
  createEnableRequiredMemoTransfersInstruction,
} from "@solana/spl-token";

export async function createTokenWithMemoExtension(
  connection: Connection,
  payer: Keypair,
  tokenAccountKeypair: Keypair,
  mint: PublicKey,
): Promise {
  // Create account instruction
  const accountLen = getAccountLen([ExtensionType.MemoTransfer]);
  const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);

  const createAccountInstruction = SystemProgram.createAccount({
    fromPubkey: payer.publicKey,
    newAccountPubkey: tokenAccountKeypair.publicKey,
    space: accountLen,
    lamports,
    programId: TOKEN_2022_PROGRAM_ID,
  });

  // Initialize account instruction
  const initializeAccountInstruction = createInitializeAccountInstruction(
    tokenAccountKeypair.publicKey,
    mint,
    payer.publicKey,
    TOKEN_2022_PROGRAM_ID,
  );

  // Enable required memo transfers instruction
  const enableRequiredMemoTransfersInstruction =
    createEnableRequiredMemoTransfersInstruction(
      tokenAccountKeypair.publicKey,
      payer.publicKey,
      undefined,
      TOKEN_2022_PROGRAM_ID,
    );

  // Send transaction
  const transaction = new Transaction().add(
    createAccountInstruction,
    initializeAccountInstruction,
    enableRequiredMemoTransfersInstruction,
  );

  return await sendAndConfirmTransaction(
    connection,
    transaction,
    [payer, tokenAccountKeypair],
  );
}

Transferring to Required Memo Account:

const message = "Hello, Solana";

const transaction = new Transaction().add(
  new TransactionInstruction({
    keys: [{ pubkey: payer.publicKey, isSigner: true, isWritable: true }],
    data: Buffer.from(message, "utf-8"),
    programId: new PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
  }),
  createTransferInstruction(
    sourceAccount,
    destinationAccount,
    payer.publicKey,
    transferAmount,
    undefined,
    TOKEN_2022_PROGRAM_ID,
  ),
);

await sendAndConfirmTransaction(connection, transaction, [payer]);const message = "Hello, Solana";

const transaction = new Transaction().add(
  new TransactionInstruction({
    keys: [{ pubkey: payer.publicKey, isSigner: true, isWritable: true }],
    data: Buffer.from(message, "utf-8"),
    programId: new PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
  }),
  createTransferInstruction(
    sourceAccount,
    destinationAccount,
    payer.publicKey,
    transferAmount,
    undefined,
    TOKEN_2022_PROGRAM_ID,
  ),
);

await sendAndConfirmTransaction(connection, transaction, [payer]);

Deposit Architecture Patterns

Pattern 1: Memo-Based Deposits (Recommended)

All users send funds to a single address with unique memo identifiers:

Advantages:

Simple to implement and maintain
Cost-effective indexing (can use simple RPC polling)
No private key management complexity
Perfect for most applications

Process:

User requests a deposit
Backend generates a unique seed/nonce, stores it in the database as ‘pending’
Frontend creates a transaction with transfer + memo containing the seed
Indexer monitors a single address and processes transactions
Processor matches memo to database record and updates user balance

Pattern 2: Unique Deposit Addresses (Binance-Style)

Every user gets their own unique deposit address:

Advantages:

Familiar to users from traditional exchanges
Clear separation of user funds
Easy to track individual user activity

Disadvantages:

Complex private key management for millions of addresses
Requires fund consolidation (“sweeper”) process
Higher gas costs for moving funds between addresses
More complex indexing (must monitor many addresses)

The Sweeper Problem

When using unique deposit addresses, funds get scattered across thousands of wallets. A sweeper process must periodically consolidate these funds:

Monitor all user deposit addresses for incoming funds
Calculate gas fees needed to move funds from each address
Send SOL to addresses that need gas for token transfers
Sweep funds from deposit addresses to the main treasury
Timing sweeps during low gas periods for cost efficiency

This complexity makes memo-based deposits preferable for most applications.

Withdrawal Architecture and Security

Withdrawals are the most critical and dangerous operations in any centralized crypto platform. Once funds leave our control, they cannot be recovered, making security paramount.

The Withdrawal Problem

When a user wants to withdraw 100 SOL from their 400 SOL balance:

The database shows that 400 SOL belongs to the user
The actual SOL sits in our centralized “hot wallet”
We must atomically reduce the user’s database balance AND send a blockchain transaction
Any failure in this process can result in lost funds or double-spending

Naive Withdrawal Flow (DANGEROUS):

app.post('/withdraw', (req, res) => {
  // 1. Check user's balance (400 SOL)
  // 2. REDUCE balance in DB (set to 300 SOL)
  db.balances.update({ userId: 1, currency: 'SOL' }, { $inc: -100 });
// 3. Get MPCs to sign withdrawal transaction
  const signature = MPC1.sign() + MPC2.sign() + MPC3.sign();
  // 4. Send transaction to blockchain
  connection.sendTransaction(signature);
});

Critical Problems:

1. Database Before Blockchain

If we reduce the balance first, but the blockchain transaction fails (network issues, old blockhash), the user loses their funds in the database, but the money never leaves our wallet.

2. Blockchain Before Database

If the blockchain transaction succeeds but the database update fails (DB crash), the user receives their 100 SOL but still has 400 SOL in their account — they can withdraw again (double-spend).

3. Race Conditions

Multiple simultaneous withdrawal requests could all check the same balance, all see sufficient funds, and all proceed — allowing withdrawal of more funds than available.

Robust Withdrawal Implementation

Queue-Based Processing

The solution is using a message queue system (like Kafka) for sequential processing:

API Endpoint validates the request and places it in the withdrawal queue
Single Worker process pulls requests one by one:

Checks and locks the user’s balance
Creates and signs a transaction
Sends transaction to blockchain
Updates the database on confirmation
Acknowledges the queue message

Idempotent Withdrawals

To handle worker crashes, we must make withdrawals idempotent (safe to retry):

Critical Insight: Store signature BEFORE broadcasting

async function processWithdrawal(withdrawalRequest) {
  // 1. Create withdrawal transaction
  const transaction = createWithdrawalTx(withdrawalRequest);
  
  // 2. Get MPC signatures
  const signature = await getMPCSignatures(transaction);
  
  // 3. STORE signature in database BEFORE broadcasting
  await db.withdrawals.update(withdrawalRequest.id, { 
    signature: signature,
    status: 'signed'
  });
  
  // 4. NOW broadcast to blockchain
  await connection.sendTransaction(signature);
  
  // 5. Wait for confirmation and update status
  await confirmTransaction(signature);
  await db.withdrawals.update(withdrawalRequest.id, { status: 'completed' });
  await updateUserBalance(withdrawalRequest);
}

If the worker crashes after storing the signature, a new worker can:

Check if the signature exists in the database
Query the blockchain to see if the transaction was confirmed
If confirmed, just update the database status
If not confirmed: safely create a new transaction

Advanced Security: Defending Against Insider Threats

Attack Vector 1: Stolen JWT Secrets

Threat: Malicious insider or hacker obtains JWT secret key, can forge user cookies, and call the withdrawal API.

Mitigation: Multi-Factor Authentication (MFA)

Withdrawal API requires a valid OTP sent to the user’s email/phone
Even with stolen cookies, the attacker needs access to the user’s communication channels

Attack Vector 2: Internal System Bypass

Threat: Malicious developer with server access bypasses public API entirely, directly calls internal MPC functions.

Mitigation: Cryptographic Handshake Between Browser and MPCs

Key Generation: Upon login, the user’s browser generates an ephemeral public/private key pair
Key Registration: Using MFA, the browser registers the public key directly with each MPC server
Request Signing: For withdrawals, the browser signs the request with the private key
Verification: MPCs verify the signature against the registered public key before signing the blockchain transaction

This ensures that even with full backend access, attackers cannot forge withdrawal requests without the user’s private key (which never leaves the browser).

Implementation Example:

// Browser-side: Generate and register keys
const keyPair = await crypto.subtle.generateKey(
  {
    name: "ECDSA",
    namedCurve: "P-256",
  },
  true,
  ["sign", "verify"]
);
// Register public key with MPCs (after MFA verification)
const publicKeyJWK = await crypto.subtle.exportKey("jwk", keyPair.publicKey);
await registerKeyWithMPCs(publicKeyJWK, otpToken);
// Sign withdrawal request
const withdrawalRequest = { amount: 100, address: "...", userId: 12345 };
const signature = await crypto.subtle.sign(
  { name: "ECDSA", hash: "SHA-256" },
  keyPair.privateKey,
  new TextEncoder().encode(JSON.stringify(withdrawalRequest))
);
// Send signed request to backend
await fetch('/withdraw', {
  method: 'POST',
  body: JSON.stringify({ request: withdrawalRequest, signature: signature })
});

Multi-Party Computation (MPC) for Fund Security

Modern exchanges secure their hot wallets using MPC clusters instead of single private keys:

MPC Architecture:

3–5 MPC nodes each hold a “share” of the private key
Threshold signing requires a majority (e.g., 3 of 5) to sign transactions
No single point of failure — compromising one node doesn’t expose funds
Geographic distribution of nodes for additional security

MPC Workflow:

Withdrawal request validated and placed in the queue
Worker process creates an unsigned transaction
Transaction sent to the MPC cluster for signing
Each MPC node validates the request and provides a signature share
Shares combined to create the final transaction signature
Signed transaction broadcast to the blockchain

Proof of Reserves: Building Trust

Leading exchanges are implementing Proof of Reserves to demonstrate they hold sufficient funds to cover user balances. As highlighted by Backpack’s recent announcement, this involves:

Core Components:

Daily Balance Attestations: Cryptographic proofs of all user balances
Merkle Tree Inclusion Proofs: Users can verify their balance is included in the total
External Audits: Third-party verification of reserve calculations
Real-time Reconciliation: Continuous monitoring of asset vs. liability balance

Implementation Considerations:

Physical Balances Only: Include assets that can be “touched” on-chain (available balances, open orders, unborrowed lends)
Margin Risk Management: Over-collateralized borrows must be factored into reserve calculations
Fiat Complications: Traditional bank deposits require special handling (deposit tokens)
Perpetual Futures: Real-time P&L settlement automatically included in reserves

Cost Optimization Strategies

Cheap Indexing for a Single Address

For applications using memo-based deposits, we can avoid expensive Yellowstone subscriptions:

// Simple polling indexer
async function pollForTransactions() {
  const signatures = await connection.getSignaturesForAddress(
    ourDepositAddress,
    { limit: 50 }
  );
  
  for (const sig of signatures) {
    if (!processedSignatures.has(sig.signature)) {
      const transaction = await connection.getTransaction(sig.signature);
      processMemoTransaction(transaction);
      processedSignatures.add(sig.signature);
    }
  }
}
// Run every 20 seconds
setInterval(pollForTransactions, 20000);

This approach costs nearly nothing compared to $200–1000/month Yellowstone subscriptions.

When to Use Expensive Indexing

Reserve Yellowstone/Geyser for scenarios requiring:

Multiple address monitoring (unique deposit addresses)
Real-time processing (high-frequency trading, liquidations)
Program-wide monitoring (DeFi protocol indexing)
Cross-chain arbitrage (sub-second transaction processing)

Production Deployment Checklist

Infrastructure Requirements:

Message queue system (Kafka/Redis) for withdrawal processing
Database with proper indexing on user_id, transaction signatures
MPC cluster for secure transaction signing
Monitoring and alerting for all critical processes
Geographic redundancy for indexing infrastructure

Security Measures:

MFA is required for all withdrawal operations
Browser-MPC cryptographic handshake implemented
Regular security audits and penetration testing
Incident response procedures documented
Key rotation procedures for MPC nodes

Operational Procedures:

Daily proof of reserves generation
User balance reconciliation monitoring
Withdrawal queue monitoring and alerting
Regular sweeper execution (if using unique addresses)
Gas fee optimization for blockchain operations

Conclusion

Building a robust indexing infrastructure on Solana requires careful consideration of security, cost, and operational complexity. The memo-based deposit approach provides an excellent balance of simplicity and security for most applications, while proper withdrawal architecture with MPC security and queue-based processing ensures funds remain safe.

Key takeaways for implementation:

Use memo-based deposits unless we have specific requirements for unique addresses
Implement proper withdrawal queues with idempotent processing
Secure hot wallets with MPC clusters and cryptographic handshakes
Consider proof of reserves for building user trust
Optimize costs by avoiding expensive indexing when simple polling suffices

The landscape of centralized crypto infrastructure continues evolving toward more transparent, verifiable, and secure systems. By implementing these patterns correctly, we can build applications that provide the user experience of centralized systems with the security guarantees that approach decentralized protocols.

Written with ❤ by Prapti for the Solana community.

Deep Dive of the State of Developer Tooling on Solana

khushi panwar — Wed, 20 Aug 2025 09:30:45 GMT

Introduction
Tooling Evolution on Solana
Anchor and Rust Foundations
Python and Solidity Support Offerings
Frontend SDKs and Wallet Integration
RPCs, Indexers, and Dev Infra
Local Testing and Simulation Tools
Account Abstraction and Smart Accounts
Real World Adoption (Gaming, DePIN, Consumer Apps)
Tooling Ecosystem Map
Community-Led Tooling and Grants
Limitations and Pain Points
Future Roadmap and RFPs
Conclusion
References

1. Introduction

A couple of years back, building on Solana wasn’t easy. It was fast, but there weren’t enough tools to guide you. Rust was powerful, but it was hard to learn; the documentation was scattered, and debugging was painful. If you wanted to build something, you had to push through a lot on your own.

But fast-forward to 2025, it’s a whole different vibe.

Now, you’ve got a growing list of frameworks, SDKs, and infra tools tailored to different dev styles. You can write Solana programs in Rust, Python, or even Solidity. You can simulate mainnet on your laptop, use plug-and-play SDKs for wallets and NFTs, and deploy apps with the help of battle-tested CLI kits, dev dashboards, and powerful RPCs.

And that’s showing up in the numbers, too. Solana became the #1 blockchain for new developers in 2024, with over 3,200 monthly active devs in 2025 and a retention rate above 70%.

In this deep dive, we’ll break down the full stack, including tools, infra, community, and gaps, and show why this is one of the most exciting ecosystems to build in right now!

2. The Tooling Evolution (2020–2025)

When Solana launched in 2020, it came with raw power, namely fast block times, low fees, and parallel execution. But building on it was a real grind.

The earliest tools were basic:

The Solana Command Line Interface (CLI), introduced in 2019, was the primary entry point for developers. It supported basic functions like deploying programs, generating key pairs, managing accounts, and interacting with clusters. It remains a foundational tool in the Solana dev workflow even in 2025.
The SPL Token Program, launched in 2020, enabled developers to issue fungible tokens and NFTs. It provided the core token logic but had limited customization. Developers had to work around its constraints to support complex use cases.
The game started to change with the launch of Anchor, which simplified Rust development drastically. It reduced boilerplate, added helpful macros for structure and security, and generated IDLs (Interface Description Language) for easier client integration. Anchor quickly became the de facto framework for serious Solana development.
Around this time, tools like Solana Playground (solpg) also gained traction. It was a browser-based IDE that helped devs experiment and deploy without a full local setup, especially during hackathons.
From 2022 onwards, Solana’s dev stack started opening up to non-Rust developers. Tools like Seahorse (Python) and Solang (Solidity) helped onboard devs from other ecosystems. Mucho CLI was introduced to streamline local workflows, while LamportDAO provided a web IDE, technical content, and grants to support early-stage builders.
By 2024–2025, Solana’s tooling matured into a full-stack platform. Umi and Kinobi enabled smooth frontend-to-program integration. Squads v4 brought smart account infra and multisig workflows. Tools like Helius, Surfpool, and Pinocchio tackled RPCs, local mainnet simulations, and account abstraction. Even SPL itself evolved, and Token Extensions introduced features like confidential transfers and interest-bearing tokens.

3. Anchor and Rust Foundations

If there’s one tool that truly defines how developers build on Solana, it’s Anchor.

Before Anchor, writing smart contracts in Solana meant working directly with low-level Rust. Developers had to manually handle accounts, manage serialization, set up security checks, and deal with a lot of boilerplate code.

Anchor framework changed that!
It introduced macros that automated common patterns, enforced safe coding practices, and removed much of the repetitive setup. One of its biggest contributions was generating IDLs (Interface Description Language). This was the Solana version of Ethereum’s ABI, which made building frontend integrations much simpler.

The result was better code safety, faster development, and more structured programs.

Anchor quickly became the default framework for Solana development. By 2023, most serious on-chain programs and most of the applications (DAOs to DEXs) were being built using Anchor.

Its GitHub repo today shows 4.4K+ stars and 1.6K forks, reflecting high adoption and active contribution from the dev community.

Despite the rise of Python (Seahorse) and Solidity (Solang), Anchor remains the most stable and widely-used tool for writing Solana programs in 2025. Its ecosystem is backed by strong community support, ongoing updates (e.g., LazyAccount memory optimization in 2025), and deep integration with Solana dev infra like Kinobi, Umi, and Surfpool.

That said, learning Rust is still a barrier for many & comes with a steep learning curve. Anchor makes it more manageable, but developers still need to understand Rust fundamentals like ownership, lifetimes, and borrowing.

In short, Anchor and Rust remain the gold standard for secure, production-grade smart contract development on Solana. The rest of the tooling stack is largely built around this foundation.

4. Python and Solidity Support

While Rust and Anchor remain the dominant combo for Solana development, the need for accessibility led to alternative language support — most notably Python and Solidity. These tools are still maturing, but have played a key role in onboarding new devs into the ecosystem.

4.1. Seahorse: Python for Solana

Seahorse is a framework that lets developers write Solana smart contracts in Python syntax. Under the hood, Seahorse compiles to Rust and generates Anchor-compatible artifacts, meaning you can write in Python but still tap into Anchor’s safety and structure.

This lowers the barrier for non-systems developers, especially those from data science, scripting, or full-stack backgrounds. It’s particularly useful for hackathons and rapid prototyping where speed matters more than low-level control.

Demo of a Seahorse dApp project file on Solana Playground

However, Seahorse has some limitations:

The GitHub repo has seen low maintenance lately
Compatibility issues can arise with newer Anchor or Solana runtime updates
It’s not always suited for production-grade deployments without review or refactoring into Rust

4.2. Solang: Solidity on Solana

Solang is a Solidity compiler for Solana, allowing EVM developers to deploy smart contracts using a familiar language. It supports a large subset of Solidity syntax and maps it to Solana’s Sealevel runtime.

Use cases for Solang include:

Porting existing Solidity contracts (e.g., from Ethereum or BSC)
Onboarding Solidity-native devs without forcing them into Rust
Experiments in EVM–non-EVM cross-deployment patterns

That said, Solang’s cross-language support is still evolving:

Runtime differences between EVM and Solana require cautious design
Integration with Solana-native SDKs (e.g., Umi) is limited

Despite this, Solang is actively maintained and backed by the Solana Foundation as a long-term bridge between ecosystems.

5. Frontend SDKs and Wallet Integration

Solana’s on-chain logic is only half the story… the other half lives in the frontend!
Over the past two years, the ecosystem has seen major improvements in how developers connect users to programs through SDKs, wallet libraries, and client tooling.

5.1. @solana/kit (the successor to web3.js)

Solana’s original TypeScript SDK @solana/web3.js was widely used.
But it started to get outdated with heavy bundles, inconsistent typings, and clunky crypto support.

In 2024, Solana started migrating to a modern replacement: @solana/kit. It’s modular, tree-shakable, and way faster.

Reduces bundle size from ~90 KB to ~17–33 KB
10× faster crypto ops using browser-native BigInt and Web Crypto
Cleaner TypeScript interfaces + async iterator support
Fully extensible, supports custom transports and serialization logic

As of 2025, @solana/kit is the recommended SDK for all new dApps. The legacy web3.js v1.x is still stable, but it’s no longer being actively improved.

5.2. Wallet Adapter SDKs

Solana apps rely on external wallets like Phantom, Solflare, Backpack, and Ledger. To simplify integration, developers use Wallet Adapter, a modular TypeScript library that standardizes how wallets are detected, connected, and used across apps.

It supports:

Multiple wallets out of the box
Mobile and desktop compatibility
Custom signing workflows

Newer adapters (e.g., by Anza and Backpack) also support xNFTs and session-based interactions.

5.3. Kinobi & Umi

Kinobi helps developers serialize and deserialize instructions, accounts, and types. This reduces the chance of runtime errors from misaligned client-program logic.
Umi, built by Metaplex, is a lightweight JavaScript library designed for NFT transactions, custom signing flows, and simplified account setup. It’s especially useful for consumer-facing apps and minting flows.

Together, these tools reduce dev friction, improve wallet UX, and make Solana apps feel more like Web2 products (fast, reactive, and easy to use).

6. RPCs, Indexers, and Dev Infra

Behind every fast wallet connect, NFT mint, or token swap, there’s a layer of infrastructure moving data to and from the chain. And on Solana, that layer has gotten a lot more reliable.

6.1. RPC Providers

Every dApp talks to Solana through RPC nodes.

Remote Procedure Call (RPC) nodes are entry points that allow dApps to communicate with the Solana blockchain by submitting transactions and querying on-chain data. They’re essential for reading account state, sending transactions, and subscribing to events in real-time by forming the backbone of any live application.

In the early days, most devs used public RPCs, but they were slow, rate-limited, and failed often under load.

By 2025, that’s changed.

Helius leads the pack with fast RPCs, Solana-native APIs, real-time webhooks, and support for compressed NFTs and xNFTs. Teams like Backpack and Phantom rely on it.
QuickNode, Triton One, Alchemy, and Ankr offer managed Solana RPCs with globally distributed nodes, SLAs, and analytics dashboards.
Solana Foundation RPCs are still around, but mostly for devnet/testnet traffic.

On Solana, blocks finalize every 400ms, and programs run in parallel, so infra needs to handle thousands of txs per second. This isn’t just about speed, but about keeping your app reliable. If your RPC layer lags or drops txs, users bounce.

Most modern RPC providers now also offer real-time monitoring dashboards to track dropped txs, error rates, and performance spikes which is critical for debugging and uptime in production.

6.2. Indexers and APIs

Indexers extract and organize raw on-chain data into queryable formats by tracking accounts, logs, and transactions. They enable features like analytics, dashboards, bots, and complex data views without having to manually parse low-level Solana account structures.

APIs (Application Programming Interfaces) expose simplified endpoints for developers to interact with on-chain data or perform predefined queries without handling RPCs or indexers directly. They reduce dev overhead by offering ready-made access to tokens, NFTs, swap data, and event history by speeding up frontend and backend builds.

Solana stores program state in binary. That’s great for performance, but hard to work with directly. This is where indexers and APIs come in.

Dune decodes over 150 Solana programs, making it perfect for dashboards, bots, and metrics.
The Graph added Solana support in 2024 with Firehose integration and subgraph templates. Used heavily in DePIN and RWA projects for live state views.
Geyser Plugins stream logs and account diffs straight from validators. They’re used by explorers (e.g., SolanaFM), bots, and even games for real-time state triggers.
Moralis and Helius APIs provide plug-and-play access to token metadata, swap prices, NFT state, and more — no indexing setup needed.

These tools let you answer real product questions fast:
“What tokens did this user just mint?”
“What’s the historical price of this pool?”
“Which NFTs were transferred in the last hour?”

Infrastructure has quietly become one of Solana’s strengths. With stable RPCs, fast indexers, and production-ready APIs, devs can ship faster and sleep better.

7. Local Testing and Simulation Tools

Testing on Solana used to be chaotic. It involved devnet pushes, wasting hours on figuring out why transactions failed & debugging with raw logs. But by 2025, local testing will have caught up. You can now fork mainnet, simulate real accounts, and even test complex sponsored tx flows directly.

7.1. Solana Test Validator

Still, the first tool in every Solana dev’s setup. It spins up a single-node local cluster where you can deploy programs, reset state, and run basic integration tests. It’s perfect for fast iteration and isolated unit testing.

7.2. Surfpool

This is what you reach for when things get serious. Surfpool lets you fork mainnet on your machine by pulling in live accounts, token balances, and programs into a local simulation environment.

It matters as it lets you:

Test real-world conditions (e.g., interacting with a live DEX, DAO, or NFT mint)
Catch state-specific bugs before mainnet deployment
Run fast without needing high-end hardware
CI-friendly and can be integrated with pre-deploy pipelines

7.3. Pinocchio

Pinocchio is a zero-dependency Rust library designed for account abstraction flows — session keys, delegated signers, sponsored transactions, and more. It’s lightweight, no_std, and doesn't rely on the full Solana runtime.

It’s perfect for:

Simulating alternative signing models
Reducing binary size in custom program builds
Safe prototyping of new auth or account delegation patterns

By July 2025, over 1,200 active Solana devs have added Pinocchio into their CI test flows, especially for wallet apps, DAO frameworks, and multisig infrastructure.

7.4. Other Tools

Program-Test → Anchor-native testing framework
BankRun.js → JS-based runner for end-to-end tx testing
Bokken → Experimental Anchor debugger (under active dev)

8. Account Abstraction and Smart Accounts

Solana embraced account abstraction from the beginning, using Program Derived Addresses (PDAs). Instead of relying on private key–key-controlled accounts, PDAs allow program-driven account logic for custom behavior.

Account abstraction decouples signature checks from transaction logic. With PDAs, programs can define who can do what and when without the need for private keys to hold authority. It’s all contained in program logic, enabling smart wallets, delegated accounts, and flexible governance models.

8.1. PDAs: Core Building Blocks

PDAs are deterministic, program-owned addresses generated from seeds and a program ID. They can’t be signed by a key pair, and hence, only the owning program can authorize them.

This makes them perfect for:

Creating upgradeable program-controlled accounts
Implementing multisigs, spending rules, or access control
Building DAOs, smart wallets, and composable on-chain infra

8.2. Squads v4: Powerful Smart Account Framework

Squads v4 transformed multisig on Solana into a full-featured smart account suite.

It supports:

Time-locked execution, granular signer roles, and sub-accounts
Spending limits and program fee relayer for gasless flows
ALTs (Address Lookup Tables) for transaction size reduction

Plus, SquadsX, their multisig browser extension, makes dApps treat multisigs like any other keypair. It’s both secure and user-friendly.

8.3. Pinocchio: Lightweight Abstraction Testing

Pinocchio is a zero-dependency Rust library focused on simulating account abstraction flows, such as:

Gasless (sponsored) transactions
Session keys and delegated signers

By July 2025, 1,200+ active devs were integrating Pinocchio into their CI pipelines for robust testing. And importantly, Pinocchio remains minimal and decoupled — no declare_program! macro bindings, keeping builds lean and flexible.

9. Real-World Adoption

How Solana dev tools are powering live apps across verticals

I have noticed a pattern across ecosystems that dev tools only matter if real teams are actually using them. Solana has always been fast, but the difference in 2025 is this: projects are no longer building despite the tooling. They’re building because it exists.

The stack has matured, and real apps are now depending on it.

9.1. Gaming: GameShift API + Custom SDKs

Game devs don’t care about L1s or blockchain trilemma; they only care about UX, speed, and user retention. Solana’s fee structure helps, sure. But it’s the tooling that actually gets things built.

GameShift API strips out wallet pain and lets Unity/Unreal teams plug into onchain assets like it’s just another SDK.
Devs use Helius for real-time account state, and Umi for smooth NFT workflows.
Pinocchio handles gasless loot drops, power-ups, and off-chain-auth actions

Over 30+ live games use this today. AI-native games like Neural and fast-paced titles like Aurory and Ev.io, are built on this exact stack. Two years ago, that wasn’t possible.

9.2. DePIN: High-volume, live-data use cases

Solana might be the only chain right now that’s truly ready for DePIN-scale data through capabilities like sub-second updates, micro-txns, and millions of devices.

Helium runs entirely on Solana using Squads v4 for secure validator coordination.
Hivemapper pushes real-time GPS streams using Geyser plugins + Helius webhooks.
And most of them rely on Surfpool to test these flows against the forked mainnet state before rolling out.

9.3. Consumer Apps

Here’s where things have really clicked.

DRiP distributes millions of NFTs using compressed mints and Umi. Minting what would cost $200k on Ethereum costs less than $100 on Solana.
Their frontend stack uses Wallet Adapter, Kinobi, and a mobile-native Umi setup.
Backpack / xNFT pushes it even further by combining Anchor, Squads, and Pinocchio for app-level permissions inside wallets.

Teams like TipLink, Dialect, Gari, and dozens more are building production-ready experiences that feel invisible.

10. Tooling Ecosystem Map

Here’s how everything we’ve covered fits together, layer by layer:

Smart Contract Layer

Anchor framework for Rust is most common for powering most programs.
Seahorse (Python) compiles to Anchor-compatible Rust, preferred for prototypes/hackathons.
Solang (Solidity) lets EVM devs compile Solidity to Solana bytecode.

Language & SDK Layer

@solana/kit offers the modern, tree-shakable TypeScript SDK replacing web3.js
Umi is the JavaScript SDK optimized for NFTs and consumer flows
Kinobi offers auto-generated serializers, keeping client logic aligned with programs

Wallet Integration

Wallet Adapter offers a standardized SDK for Phantom, Solflare, Backpack, and Ledger.
Session/gasless support is driven by Pinocchio and custom logic
SquadsX offers a browser multisig signer for smart account flows

Local Dev & Testing

Solana CLI + Test Validator is a foundational local cluster
Surfpool is forked mainnet simulation tool
Program-Test, BankRun.js, and Bokken are used for unit/integration testing

Account Abstraction / Smart Accounts

PDAs are native to Solana, enabling program-owned accounts
Squads v4 offer multisig, treasuries, DAO infra, etc
Pinocchio is a zero-dependency Rust tool for session keys, sponsored txns

RPCs, Indexers & Data APIs

Helius, QuickNode, Ankr, Triton One are performant RPC providers
Dune, The Graph, Geyser Plugins for structured on-chain data
Moralis, Helius APIs for token, NFT & event metadata

Web2 Integration & Enterprise

GameShift API for plug-and-play for Unity/Unreal game studios
AWS Solana Blueprints for fast node deployment via AWS
Mobile SDKs offer Solana Mobile Stack and xNFT extensions

Community-Led Tooling & Grants

One of Solana’s biggest advantages is a builder culture that actually funds and supports developers working on the hard problems. A lot of the tools we’ve covered so far (like Mucho CLI, Surfpool, and Pinocchio) came from the community.

11.1. LamportDAO

LamportDAO is a decentralized, open developer collective focused on funding public goods in the Solana ecosystem.

Offers microgrants up to $5,000 for developer tooling, public infra, educational content, and protocol improvements
Acts as a signal amplifier, where projects often get recommended to the Solana Foundation for larger milestone-based grants
Runs a community-maintained IDE, hosts hackathons, and coordinates contributor bounties via Discord and GitHub

11.2. Superteam

Superteam is another key player with a network of regional DAOs (India, Vietnam, Germany, Nigeria, etc.) offering:

Quick grants (< $10k) for early-stage ideas
Bounties and workshops on wallets, Solana CLI, and dev onboarding
Local events that connect builders to mentors, capital, and fellow contributors

11.3. Solana Foundation

The Solana Foundation runs a structured grant program focused on:

Milestone-based funding for core tools, infrastructure, and dev onboarding
Convertible grants for commercial projects working on open dev infra
RFPs (Requests for Proposals) for things like:
I. Formal verification tools
ii. Mobile-first SDKs
iii. Native ZK integration
iv. Secure dependency managers and CI tooling

12. Limitations and Pain Points

The ecosystem is growing, tools are shipping, and teams are getting funded. But under all the progress, there are still real gaps in the developer experience, especially when things don’t go right.

Here’s where the cracks still show up for many builders.

12.1 Debugging remains a pain point

Building on Solana has become smoother, but debugging is still one of the weakest links.

Anchor macro errors can be opaque and hard to trace
When CPI (cross-program invocations) fail, logs aren’t always clear
There’s no visual debugger or instruction-level trace explorer

12.2. Language support is uneven

Solana has taken big steps toward multi-language access, but only Rust feels truly production-ready.

Seahorse (Python) isn’t actively maintained and breaks with recent Anchor upgrades.
Solang (Solidity) is improving but lacks mature tooling and ecosystem integrations.
Devs using these tools often hit compatibility walls when deploying to mainnet or integrating with clients.

12.3. Documentation is still fragmented

Solana’s rapid development pace has outgrown its docs in several areas.

Token Extensions, Kinobi, Surfpool, and newer SDKs often have incomplete or outdated guides
Best practices are buried in GitHub issues, Discord, or private gists
Developers have to piece together usage patterns from scattered sources

12.4. Dev UX

Even with solid infra, building a full product on Solana often requires assembling pieces manually.

No first-party CLI to scaffold programs + frontend + Surfpool + CI
Limited visual tools for contract simulation or account layout
CI/CD best practices are still being figured out, team by team

13. Future Roadmap and RFP Opportunities

By now, Solana’s dev stack covers most of what a team needs to ship. But under the surface, there are still meaningful gap,s especially around dev experience, multi-language support, CI testing, and mobile workflows.

Here’s what’s next for builders looking to make an impact.

13.1. Debugging Tools

Debugging Solana programs, especially CPI-heavy flows, still lacks dedicated tooling.

Anchor error logs are opaque and difficult to trace
CPI failures often show just the failed instruction, not the full path
Local environments like Surfpool help simulate, but don’t explain

Hence, there’s a need for Instruction-level CPI debuggers, log visualizers for Anchor, and tools that track account diffs across transactions.

13.2. Python Tooling Revival

Seahorse (Python-to-Solana transpiler) gave non-Rust devs a solid entry point, but it’s currently unmaintained and incompatible with modern Anchor versions. Solang (Solidity) exists but is still underused due to a lack of deep tooling integration.

There’s a need for a stable Seahorse 2.0, with Anchor macro compatibility, client IDL generation, and test runner integration, or a Python-native toolchain from scratch.

13.3. Formal Testing and CI Tooling

Most Solana teams still patch together CI pipelines manually.

No standard templates for Surfpool-based tests
Formal verification workflows (e.g., RiscZero-style provable correctness) are absent.
Hard to simulate real user flows end-to-end.

Hence, CI templates with Surfpool forks, snapshot testing for account state, and portable security testing pipelines for Solana programsares needed.

13.4. Mobile-First SDKs + Dev Infra

Saga and xNFTs have moved Solana ahead in mobile adoption. But from a dev tooling perspective, there’s friction.

Wallet adapters exist, but no mobile-specific CI or test flows
No SDKs for mobile-native minting, compressed NFTs, or smart account flows
Few reusable templates for launching mobile dApps

Hence, there’s a possible need for React Native modules for Solana actions, mobile dev CI support, and AppKit tooling to test txns in local simulators.

14. Conclusion

Building on Solana in 2021 meant learning Rust, writing boilerplate manually, and debugging CPI errors with println! statements and Discord threads. There were no structured testing environments, no proper client-side serializers, and no local mainnet forks.

That’s no longer the case.

By mid-2025, Solana’s dev tooling has matured into a layered stack. Anchor remains the dominant contract framework, but now sits alongside tools like Kinobi, Umi, Surfpool, and Pinocchio. These purpose-built tools were designed to handle the specific complexities of Solana’s runtime model.

On the client side, Wallet Adapter and @solana/kit provide standardized flows. For testing, Surfpool and Program-Test offer real environments with better fidelity. Smart accounts are being built using Squads, PDAs, and custom auth logic that’s live in production.

If you’re looking to contribute meaningfully to Solana’s ecosystem, this is where the impact is:

Better abstraction and dev ergonomics
Testing and formal assurance
Multi-language support and onboarding
Mobile-native development environments

The foundation is solid. What’s needed now is refinement.

15. References

Deep Dive of the State of Mobile Apps on Solana

Manish — Wed, 20 Aug 2025 05:30:35 GMT

You unlock your phone roughly 150 times a day. Now imagine if every third unlock could pay you. I'm not talking about pennies from ads. I mean real money for real things you're already doing, like walking to work, sharing a photo on Insta, commenting on a Twitter post, or playing a game during your commute to work.

Sounds impossible, right?

That was my first reaction too. But then I found out that 150,000 people have already preordered something called the Solana Seeker, a phone that turns this "impossible" scenario into a reality. It turns out, they're not just buying hardware, they're buying a citizenship in what Balaji Srinivasan calls a Network State.

We're witnessing the emergence of the first digital economy where human attention directly converts to money being flown into the ecosystem.

These early adopters aren't just users; they're the founding citizens of an economy that operates by entirely different rules than the one we grew up in.

And here's what really fascinates me: this isn't some distant future we're speculating about. It's happening right now, in real-time, with people making real money from interactions we used to think of as worthless digital noise.

Your likes on Twitter are way more valuable than you think.

What Makes the Solana Seeker Different?

Let's be honest: using crypto today is a nightmare.

Want to send someone $20 in USDC? Hope you enjoy copying wallet addresses, calculating gas fees, waiting for confirmations, and praying you didn't mess up a single character.

But here's what most people miss: the problem isn't just the software, it's that we've been trying to force desktop crypto patterns onto mobile devices.

The Seeker attacks this from a completely different angle. While previous "crypto phones" like the HTC Exodus or Samsung's blockchain features bolted crypto functionality onto existing experiences, Solana Mobile rebuilt the entire stack around a simple question: What if crypto felt as natural as texting?

Here's the thing: the Seeker isn't just running crypto apps. It's built on something called TEEPIN (Trusted Execution Environment Platform Infrastructure Network), which creates hardware-level security for your private keys. Think of it like having a hardware wallet permanently integrated into your phone, but one that apps can communicate with seamlessly.

The magic happens through the Mobile Wallet Adapter (MWA) and the Seed Vault. Instead of manually copying addresses and signing transactions, apps can securely request payments in the background. Your private keys never leave the hardware security module, but transactions feel as smooth as Apple Pay.

But here's where it gets interesting: the phone runs on SKR tokens, creating what they call an "SKR Flywheel."

=> Developers earn SKR for building quality apps.

=> Users earn SKR for engaging with those apps.

=> Hardware manufacturers get rewarded for expanding the ecosystem.

That way, everyone has skin in the game.

The result? You can walk into a coffee shop, scan a QR code, and pay with USDC as easily as you'd tap your credit card. You can earn tokens from a fitness app and immediately spend them in a game. You can tip a content creator and have the transaction settle instantly.

The Seeker ships in August 2025 with 100+ apps already live in the dApp Store. These aren't just crypto experiments, they're full applications that happen to have crypto superpowers.

The question isn't whether this will work. With 150,000 preorders, it's already working. The question is: what happens to digital behavior when financial transactions become as frictionless as scrolling through TikTok?

The Apps That Make It Possible

But the Seeker is just the hardware. The real magic happens in the apps that turn this vision into reality. When those 150,000 Seeker owners power on their phones in August 2025, they'll find an app ecosystem unlike anything that has existed before, one where every interaction has the potential to generate value.

These aren't the crypto apps you know from desktop. They're mobile-native experiences built from the ground up around the question: What if your phone could pay you for living your life?

Want to get fit? STEPN has already proven that >3 million people will walk for tokens. Want to discover art? DRiP has distributed over 10 million free NFTs to collectors who think they're just browsing cool content. Need phone service? Helium Mobile pays you for helping build network coverage.

The pattern is becoming clear: the most successful mobile Web3 apps don't feel like crypto apps at all. They feel like better versions of things you already want to do.

Mapping the Mobile Apps Ecosystem on Solana

This brings us to a fascinating question: what does this new app ecosystem actually look like? And more importantly, which approaches are winning?

Solana Apps Ecosystem

Here's where things get more concrete. The current hackathon has almost 500 registrations with $1M+ in prizes. SendAI's AppKit has been downloaded 100,000+ times. These aren't vanity metrics; they represent real developer interest in building mobile-first Web3 experiences.

But developer interest and user adoption are different beasts entirely. The ecosystem currently has 100+ apps in the dApp Store, but how many of these represent genuine utility versus speculative experiments? The honest answer is: we don't know yet, and that's precisely what makes it interesting.

The Four Quadrants of Mobile Apps on Solana

Market Penetration (Top-Left): This quadrant houses the familiar faces, Phantom, Squads, and Magic Eden, serving existing crypto users with proven Web3 functionality. Growth here is steady but limited by the ceiling of crypto adoption itself.

Market Development (Top-Right): Here we see simplified versions of DeFi protocols like Jupiter Mobile (100K+ downloads, 4.6 star rating), Kamino lending, and SendAI's AppKit with pre-built modules for 18+ protocols. These apps successfully translate complex crypto operations into familiar mobile patterns, proving there's an appetite for accessible DeFi.

Product Development (Bottom-Left): The infrastructure layer powering everything else, Dialect's Web3 messaging, Helius's mobile-optimized RPC, and developer tools like those from the broader ecosystem. Essential but invisible to end users.

The Sweet Spot (Bottom-Right): This is where the magic happens. STEPN doesn't call itself a "blockchain fitness app". It's a fitness app that pays you. With 2-3 million monthly active users, it proves that people will use crypto when it solves real problems without crypto friction.

Star Atlas, Aurory, and Mad Lads represent the gaming frontier where virtual economies feel natural because gaming has always had virtual economies.

The Winning Pattern

Look at the apps that are winning: none of them lead with crypto.

Instead, they solve real problems first and use blockchain as invisible infrastructure. It's like the best magic trick ever; users get all the benefits without realizing what's powering the experience.

This tells us something important about where mobile Web3 is heading. The future isn't about "bringing crypto to mobile." It's about making mobile apps so good that they're impossible without crypto, while keeping the crypto completely invisible.

The Infrastructure Behind the Magic

But here's the question that matters: how did we get here so fast?

Just two years ago, mobile crypto was basically unusable. Gas fees killed microtransactions. Wallet connections were clunky. Most "blockchain games" felt like spreadsheets with graphics.

Today, we have fitness apps with millions of users, art platforms distributing millions of NFTs for free, and mobile carriers that actually pay you. That kind of leap doesn't happen by accident.

Something fundamental changed in the infrastructure layer that made all of this possible. The apps in our Sweet Spot aren't just good ideas; they're good ideas built on entirely new technical foundations that didn't exist before.

The breakthrough came down to one key innovation: the Mobile Wallet Adapter (MWA) protocol. This isn't just another technical standard; it's an attempt to solve the fundamental user experience problem that has plagued crypto since its inception.

Think about it: every crypto interaction requires managing private keys, understanding gas fees, and navigating complex interfaces. The average person finds this about as intuitive as performing brain surgery. Solana Mobile's approach is to hide this complexity behind familiar mobile patterns.

Technical Architecture: A Deeper Look

The MWA protocol represents a fundamental departure from traditional mobile app development patterns. Where conventional apps communicate with centralized servers, mobile dApps must establish secure connections with wallet applications while maintaining state across multiple applications.

This creates unique technical challenges:

State Management: Unlike web apps, where wallet connections persist in browser sessions, mobile apps must re-establish authorization with each interaction
Security Models: The Seed Vault leverages Android's hardware security module, creating a self-custody experience that feels familiar to users accustomed to biometric authentication
Cross-App Communication: The WebSocket-based protocol enables seamless value transfer between applications. Imagine paying for a ride-share with tokens earned in a fitness app.

The Technical Magic: How MWA Works

But here's where it gets really interesting from a technical standpoint. The Mobile Wallet Adapter isn't just a clever abstraction—it's solving fundamental problems that have plagued mobile crypto for years.

The WebSocket Revolution

Traditional mobile apps can't maintain persistent connections the way web browsers can. When you switch between apps on your phone, connections typically die. The MWA protocol solves this through a sophisticated WebSocket architecture that persists even when apps are backgrounded.

Here's how it actually works: When you tap "Connect Wallet" in a mobile dApp, your phone broadcasts an solana-wallet:// intent. Any compatible wallet app listening for this intent responds by opening a WebSocket connection. This creates a secure communication channel that survives app switching—something impossible with traditional HTTP requests.

The Three-Step Dance

The technical flow is elegantly simple:

Authorization: The dApp sends an authorize(dapp_identity) request through the WebSocket
Session Management: The wallet responds with an authToken and authorized accounts
Transaction Signing: All subsequent transactions use sign_transaction(tx) calls within this established session

Hardware-Level Security

What makes the Seeker phone special isn't just software—it's the Seed Vault. This isn't another app storing your keys; it's a hardware security module that operates at the Android system level. Think of it like Apple's Secure Enclave, but specifically designed for crypto operations.

Your private keys never leave this hardware vault. When apps need signatures, they communicate with the Seed Vault through the MWA protocol, which validates requests and returns signed transactions without ever exposing the actual keys.

The Developer Experience

For developers, this complexity disappears behind simple React Native hooks:

javascript

const { authorizeSession } = useAuthorization();
await transact(async (wallet) => {
  const authResult = await authorizeSession(wallet);
  const signature = await wallet.signAndSendTransactions({
    transactions: [transaction]
  });
});

The transact function handles all the WebSocket management, connection persistence, and error handling. What used to require dozens of lines of boilerplate now happens in a single async callback.

This technical foundation is what enables the seamless experiences you see in apps like Jupiter and Vector—transactions that feel as natural as tapping "like" on a social media post.

The iOS limitation reveals deeper architectural constraints. Apple's aggressive background process management breaks WebSocket connections, forcing developers to fall back to traditional wallet adapters. This technical reality means Android becomes the proving ground for truly native mobile web3 experiences.

The Seed Vault technology is particularly interesting from a systems perspective. By storing private keys in hardware-backed security, they're essentially trying to make self-custody feel as simple as unlocking your phone. Whether this actually achieves its goal is debatable, but the attempt reveals an important insight about technology adoption.

People don't want to understand the underlying technology; they want the technology to understand them. The challenge isn't building better crypto tools; it's building tools where the crypto becomes invisible.

Emerging Design Patterns in Mobile Web3

What if I told you the best crypto apps don't look like crypto apps at all? After studying the interfaces of Jupiter, Vector, Time.fun, and Kast, a fascinating pattern emerges: the winners are systematically hiding blockchain complexity behind familiar mental models.

Jupiter: The Venmo-ization of DeFi

Jupiter Mobile

Jupiter's onboarding reads "Welcome to Jupiter" with a simple promise: "Buy or receive SOL to get started." Notice what's missing? No mention of automated market makers, liquidity pools, or slippage tolerance. The "Instant Buy SOL" flow feels identical to buying Starbucks credits - $30 USD becomes 0.178 SOL through Google Pay, with a calculator interface users understand from banking apps. Jupiter took the most complex financial primitives ever built and made them feel like sending money to friends.

Vector: Memecoins as Entertainment

Vector

Vector's genius lies in framing speculation as social discovery. "Ape memes with frens" transforms degenerate trading into entertainment. Users scroll through token feeds like TikTok videos, seeing "$32.12 bought" with profit percentages instead of complex charts. The "demon mode" toggle gamifies intensity without explaining leverage or derivatives. By borrowing from social media rather than financial software, Vector makes trading feel like content consumption.

Time.fun: Commoditizing Access

time.fun

"Time Is The New Currency" reframes creator monetization entirely. Instead of "purchase utility tokens for platform governance," users simply "Buy 30 mins" with verified creators. Toly's profile shows "$90/min +174%" like Uber surge pricing—familiar, understandable, valuable. The interface treats time as a purchasable commodity, making complex tokenomics invisible while enabling entirely new economic relationships.

Kast: Premium Banking Psychology

Kast

Kast transforms crypto spending into status signaling. The sleek black interface promises "SPEND WITHOUT BORDERS" while hiding cross-chain infrastructure. Users see "KAST Points" and reward tiers (Standard, Premium, Luxe) borrowed from credit card marketing, not DeFi protocols. The "Claim Gift" button treats airdrops like loyalty rewards, making blockchain benefits feel earned rather than extracted.

The Unifying Principle

Each app succeeds by choosing the right metaphor. Jupiter = digital banking. Vector = social discovery. Time.fun = premium booking. Kast = luxury credit cards. They didn't try to educate users about blockchain; they made blockchain invisible by wrapping it in behaviors users already understood and desired.

The infrastructure works. The remaining challenge is psychology, not technology.

What to Watch: Key Inflection Points

The next 18 months will tell us everything we need to know about mobile Web3's future.

Q3 2025: Seeker shipments begin. Success metric: >50% of recipients actively use Web3 features within 30 days.

Q4 2025: Developer ecosystem maturity test. Success metric: 10+ applications with >100K monthly active users and sustainable revenue models.

2026: Mainstream integration indicators. Success metric: Partnership announcements with major consumer brands or integration into traditional mobile services.

Three simple tests. The infrastructure is ready. Now we find out if anyone outside crypto actually wants this.

Why This Experiment Matters

So here we are, watching 150,000 people bet real money that their phones should pay them for living their lives. The infrastructure is ready. The apps work. The user experience finally makes sense.

But stepping back, what we're witnessing isn't just a technological shift, it's a fundamental renegotiation of the relationship between human attention and economic value. For the first time in history, the tools exist to make every digital interaction potentially profitable for the person having it, not just the platform hosting it.

This raises uncomfortable questions we're only beginning to grapple with. What happens to human behavior when every swipe, every step, every social interaction has financial implications? Are we building tools that empower users, or sophisticated mechanisms for turning human existence into extractable data?

The Solana Mobile experiment will teach us something important regardless of whether it succeeds or fails. If it works, we'll learn how quickly people adapt to living in a fully financialized digital world. If it doesn't, we'll discover which aspects of human psychology resist commodification.

Either way, the lessons will matter far beyond mobile apps or blockchain technology. We're not just building better phones, we're running a real-time experiment on what happens when the boundary between living and earning disappears entirely.

Your next 150 phone unlocks are going to happen anyway. The question is whether you want them to pay you or not.

Resources

Official Documentation & Platforms

Key Apps & Platforms

News & Analysis

Technical Resources & Hackathons

Historical Context & Theory

Deep Dive of the State of RWAs on Solana

Aditya Khetarpal — Sun, 17 Aug 2025 14:12:42 GMT

For years, the crypto narrative painted TradFi and DeFi as bitter rivals. One centralized and slow, the other open and unstoppable. But that story is evolving. Rather than a clash of systems, we’re witnessing a convergence: traditional finance is moving onchain, and decentralized finance is maturing to meet it.

Nowhere is this shift more evident than in the rise of Real-World Assets (RWAs), and no chain is leaning into this future harder than Solana. This isn’t TradFi vs DeFi. It’s TradFi plus DeFi, and it’s unlocking a new era of global finance.

What are Real World Assets (RWAs)?

Real-world assets (RWAs) are traditional financial assets brought onchain through tokenization and represented as digital tokens on the blockchain. These can include tangible assets like real estate, as well as intangible ones such as government bonds, stocks, and carbon credits. Backed by real-world value, RWAs offer a sustainable and reliable digital asset class that bridges the gap between decentralized finance (DeFi) and traditional finance.

Okay, but why do they matter?

To understand the significance of RWA tokenization, picture a large pizza you want to share with friends. Instead of giving each friend the whole pizza, you slice it into pieces, with each slice representing part of the whole.

Tokenization works similarly with assets. When an asset is tokenized, it’s divided into smaller parts called “tokens,” each representing a share of the asset. These tokens can represent anything valuable, from real estate to intellectual property. Managed and traded using blockchain technology, these tokens ensure secure and transparent ownership records, making assets more accessible, liquid, and tradable globally.

And why on Solana?

Solana is uniquely positioned to drive the growth of real-world assets (RWAs) due to its high throughput, low fees, and scalable infrastructure, all essential for supporting high-volume, real-world financial activity onchain. With lightning-fast finality and a rapidly expanding ecosystem of RWA-native protocols, Solana delivers the speed and efficiency needed for institutional-grade asset tokenization.

In this essay, we'll explore how Solana is emerging as a leading platform for real-world assets (RWAs), combining the speed and scalability of blockchain with the stability of traditional finance. We'll break down the key metrics that highlight Solana’s RWA momentum, examine the most important players and institutional partnerships, and map out the broader RWA ecosystem taking shape onchain. We'll also compare global regulatory approaches, spotlight new opportunities being unlocked by RWAs, and offer a perspective on what the future holds for this fast-growing intersection of TradFi and DeFi.

The Rise of RWAs: A New Financial Primitive

From $5B to $24B: Mapping the growth of RWAs (2022–2025)

RWA tokenization has surged from $5 billion in 2022 to over $24 billion by June 2025. That’s an impressive 380% growth, making it crypto’s second fastest-growing sector after stablecoins. While stablecoins are technically tokenized fiat currencies, they are excluded from this analysis, as a separate in-depth report is being developed.

Source: rwa.xyz

This rapid rise isn’t just hype anymore. We are experiencing a shift from early experimentation to real-world adoption at scale. By December 2024, the tokenized RWA market (excluding stablecoins) had reached $15.2 billion, and just six months later, it expanded another 85% year-over-year, exceeding $24 billion.

This momentum is the result of years of infrastructure development converging with institutional interest. Major players like BlackRock, JPMorgan, Franklin Templeton, and Apollo have moved beyond testing and into production deployments. Governments are also beginning to treat blockchain as critical infrastructure, particularly for modernizing outdated financial systems and addressing broader economic inefficiencies.

Looking ahead, industry projections estimate that 10 to 30% of global assets could be tokenized by 2030 to 2034. That positions RWAs as a key bridge between traditional finance’s $400 trillion in assets and crypto, which still sits below a $3 trillion total market cap.

The integration of RWAs into DeFi is now accelerating through regulated, composable frameworks. Platforms like Ethena, Maple, Morpho, Pendle, Kamino, and Securitize are enabling tokenized assets to access decentralized liquidity while remaining compliant. This is creating new opportunities for yield generation, broader asset distribution, and active secondary markets.

Private credit has emerged as the largest RWA category, with $14 billion tokenized as of June 2025. It shows strong institutional demand for blockchain-based credit markets. Tokenization helps lower operational costs, improve accessibility, and create liquidity in ways that were not possible in traditional finance. These products still meet institutional underwriting standards but are now more open and efficient.

At the infrastructure level, RWA oracles represent a breakthrough. Providers like RedStone are developing new pricing systems that combine traditional finance metrics like Net Asset Value, regulatory data, and adjustments for illiquidity. Unlike typical DeFi oracles, these systems are tailored for institutional adoption and form the foundation for integrating real-world assets into DeFi at scale.

RWAs have evolved from a concept to the main thing. The growth from $5 billion to $24 billion is just the beginning of a much larger transformation in how financial assets move, trade, and generate value onchain.

Why are tokenized treasuries leading the charge?

Among all real-world assets, tokenized U.S. Treasuries have emerged as the breakout product, and for good reason. In a high-interest-rate environment, Treasuries offer a low-risk, yield-generating instrument that is both familiar to traditional investors and attractive to crypto-native users seeking stability, which, in crypto terms, means not losing half your portfolio in a weekend. By bringing these government-backed assets onchain, protocols can offer DeFi users access to 4–5% annualized yields, denominated in tokenized dollars, without the volatility of typical crypto assets.

What makes Treasuries especially well-suited for tokenization is their liquidity, transparency, and regulatory clarity. These are instruments already digitized and actively traded in traditional markets, making the leap to blockchain more operationally feasible than more complex assets like real estate or private equity. Tokenized Treasuries are also relatively straightforward from a compliance standpoint, especially when issued by regulated entities and backed 1:1 by off-chain custodians.

Platforms like Ondo Finance, Matrixdock, and Backed have capitalized on this opportunity, allowing both individuals and institutions to access U.S. Treasuries directly through tokenized wrappers. These products are not only attracting stablecoin users and DAOs seeking safer yields but also setting the foundation for an entire class of tokenized fixed-income products in DeFi.

Ultimately, tokenized Treasuries serve as a gateway. They’re building trust with traditional investors, proving the viability of RWAs onchain, and opening the door for broader experimentation with more complex financial instruments in the future.

What does this signal for onchain finance?

This explosive growth of tokenized real-world assets (RWAs), particularly U.S. Treasuries, marks a turning point for the evolution of onchain finance. It signals a shift from speculative, volatility-driven activity to a more mature financial ecosystem rooted in utility, yield, and real-world value. For years, DeFi has thrived on native crypto assets but lacked meaningful integration with the trillions of dollars in traditional financial instruments. RWAs change that dynamic completely.

The onchain presence of assets like Treasuries introduces new layers of capital efficiency and trust. DAOs and protocols can now allocate reserves to yield-generating, low-risk assets without ever leaving the blockchain. Stablecoin issuers can back their tokens with tokenized government bonds, creating more transparent and auditable systems. Even lending markets can evolve, offering collateralized loans backed by tokenized Treasuries rather than volatile crypto.

This shift also opens the door to new participants. Institutional investors, family offices, and fintechs that were previously cautious about engaging with crypto are finding comfort in familiar financial products delivered through blockchain rails. It’s no longer just about yield farming or meme tokens; it's now about building the foundation for a parallel financial system that is faster, cheaper, and more inclusive.

In short, RWAs signal that DeFi is growing up. The future of onchain finance will not replace traditional finance but rather absorb and enhance it, offering a programmable, global, and transparent layer that traditional systems simply cannot match.

Why Solana? The technical and economic case

Solana currently leads all blockchains in transaction volume per holder, averaging around 40 million dollars. While this metric might seem niche at first glance, it reveals something important. Solana is not just fast; it is being actively and efficiently used at scale. A high transaction volume per holder means users are not only active but also moving significant value across the network. This reflects real engagement in areas like trading, payments, DeFi, NFTs, and increasingly, real-world assets.

For the RWA space, this is a strong signal. Institutions and asset issuers prioritize cost-efficiency, speed, and user activity when selecting a blockchain to support tokenized financial products. Solana’s ability to process thousands of transactions per second at extremely low fees makes it well-suited for assets that require frequent settlement, interest distributions, redemptions, or rebalancing. These features are especially important for tokenized Treasuries, bonds, and equities.

In short, the 40 million dollar transaction volume per holder highlights Solana’s readiness for serious financial applications. It demonstrates not only the network’s capacity but also meaningful real-world usage. For RWAs to scale, they need more than just tokenization. They need infrastructure that can support high-volume, high-value financial activity. Solana is already delivering on that.

Speed, Cost-Efficiency, and Parallel Transaction Processing

One of the main reasons Solana stands out for real-world asset adoption is its unique technical architecture. Unlike most blockchains that process transactions sequentially, Solana uses a system called Proof of History, which allows for parallel transaction processing. This means thousands of transactions can be verified and finalized simultaneously, resulting in unmatched speed and scalability.

Combined with transaction fees that typically cost a fraction of a cent, this makes Solana ideal for financial products that require high-frequency settlement or constant updates. Whether it’s paying out interest on tokenized Treasuries, issuing dividends on tokenized stocks, or updating ownership records in real-time, Solana’s low-latency environment supports these use cases with ease.

For RWAs, this is more than just a technical detail. It directly impacts usability and cost-efficiency. Institutions need infrastructure that performs at scale without introducing friction. Users want real-time interactions with their assets, not delays or high gas fees. Solana delivers on both fronts, offering a blockchain experience that feels closer to the expectations of traditional finance, but with the added benefits of transparency, programmability, and composability.

In combination with strong metrics like transaction volume per holder, Solana’s technical edge further reinforces its position as a natural home for tokenized real-world assets.

Now beyond speed and cost-efficiency, Solana’s thriving developer ecosystem plays a major role in driving real-world asset adoption. The network has attracted thousands of builders who are creating tools, protocols, and infrastructure that make it easier to launch, integrate, and scale tokenized financial products. From smart contract frameworks like Anchor to real-time indexing tools like Helius and RPC providers such as Triton, the developer stack on Solana is maturing quickly.

This growing ecosystem pushes composability, one of the defining features of onchain finance. In Solana’s context, composability means different protocols can easily interact with one another. For RWAs, this creates an environment where tokenized assets can plug directly into DeFi primitives such as lending markets, liquidity pools, yield aggregators, and more without needing complex workarounds or bridges.

For example, a tokenized U.S. Treasury issued by a protocol like Ondo can be deposited into a lending protocol, used as collateral, or traded instantly on a decentralized exchange. These kinds of interactions are possible because of Solana’s unified runtime and high transaction throughput, which keep the system fluid and efficient even under heavy demand.

In traditional finance, combining services from multiple institutions involves slow settlement layers and manual coordination. On Solana, composability makes it easy to build financial products as simple and fast as brewing a cup of chai. Fast, seamless, and programmable. This is a major advantage for the RWA sector, which requires flexible infrastructure to support innovation across issuance, settlement, custody, and trading.

With developers building openly interoperable tools and protocols on a high-performance chain, Solana provides the kind of ecosystem that RWAs need to reach a global scale.

All of these technical and ecosystem-level advantages would mean little without demand, and that demand is now coming from some of the biggest players in traditional finance. Over the past year, major institutions have not only taken notice of real-world assets but have started deploying capital into tokenized products directly on blockchain networks. Solana, in particular, is emerging as a key destination for this institutional activity.

Institutional validation: Big names, Big moves

BlackRock’s BUIDL USD Institutional Digital Liquidity Fund has become a standout example. Launched in March 2024 via Securitize, BUIDL has since expanded to Solana and six other chains and surpassed $1.7 billion in assets under management by March 2025. That includes an impressive 240% growth from $500 million in July 2024 to $1.7 billion in under seven months. Today, it holds nearly $3 billion, showcasing huge capital inflows and rapid scaling. BUIDL’s launch marks the moment institutional DeFi got real, offering peer-to-peer share transfers, daily dividend accruals, and institutional-grade custody via Anchorage, Copper, Fireblocks, and BNY Mellon.

Franklin Templeton’s OnChain U.S. Government Money Fund (FOBXX), live since April 2021, added Solana in February 2025. Now at around $594 million in AUM, it ranks as the third-largest tokenized money market fund. It invests nearly 100% in U.S. government securities and repurchase agreements, offering a 4.2% seven-day yield as of January 2025. Its expansion to Solana shows increased confidence in the network’s performance by one of the world’s largest asset managers, which oversees $1.6 trillion in total assets.

This Institutional Adoption Unlocks:

1. Market-wide validation:

When institutions like BlackRock and Franklin Templeton issue tokenized funds, they offer clear legitimacy, building confidence among regulators, enterprises, and institutional investors that blockchain-based financial products can meet high standards of compliance and oversight.

2. Infrastructure maturity:

Institutional demands for custody, auditability, and regulatory compliance force protocols to upgrade. Securitize’s platform, which serves as a transfer agent, custodian, and fund administrator across multiple chains, now supports more than $2.8 billion in tokenized Treasuries and manages the majority of top tokenized assets.

3. Enhanced liquidity and integration:

Institutional tokenized assets become collateral in DeFi, collateral-backed lending pools, and even secondary trading markets. Smart contracts allow daily yield distributions and programmable fund logic, representing a quantum step over traditional T+1 settlement cycles.

4. Fueling composability and ecosystem growth:

Institutional-grade RWAs bring new traffic to Solana; these assets can be composably used in lending, trading, and automated execution. As BUIDL and FOBXX flow into DeFi applications, they kick-start a broader ecosystem of yield networks and financial engineering.

In summary, BlackRock and Franklin Templeton have elevated Solana’s RWA narrative from hopeful potential to a working reality. Their onchain presence not only validates the space but it accelerates institutional capital, upgrades infrastructure, deepens liquidity, and amplifies composability. This marks an important moment in the evolution of onchain finance.

Key players and protocols driving RWAs on Solana

As Solana becomes a preferred destination for real-world assets, a growing number of projects are leading the charge. These protocols are not just building isolated products but forming the foundation of a fully interoperable financial system onchain. Each focuses on a unique part of the RWA stack, from token issuance and lending to infrastructure and institutional connectivity.

Ondo Finance:

Ondo Finance has emerged as one of the most influential RWA platforms on Solana. It offers tokenized U.S. Treasuries through products like OUSG, allowing both institutions and individuals to access short-term government debt onchain. Ondo is also expanding globally through partnerships with centralized exchanges, fintech platforms, and cross-border issuers. Its expansion into Solana reflects a commitment to low-cost, high-speed infrastructure, making its products more accessible and scalable.

Maple Finance:

Originally built on Ethereum, Maple Finance has expanded to Solana to power a new model of undercollateralized onchain lending. By working with institutional borrowers and whitelisted credit professionals, Maple enables capital to flow into real-world lending markets such as corporate credit and private credit. Its move to Solana enhances capital efficiency through faster settlement and lower transaction costs while preserving regulatory alignment and transparency.

VNX:

VNX is building tokenization infrastructure in Europe, with a focus on regulated digital securities backed by assets like precious metals and fixed-income products. The platform is aligned with Luxembourg’s financial licensing framework and aims to offer European investors seamless access to tokenized assets. VNX’s integration with Solana brings these products into a high-performance environment that supports cross-border issuance and secondary trading.

R3’s Corda and Solana Integration:

R3’s Corda, an enterprise-grade blockchain used by major financial institutions including HSBC, Euroclear, and SIX Digital Exchange, is integrating with Solana to bridge institutional finance with DeFi. This connection allows assets issued on Corda to move onto Solana’s public blockchain, unlocking liquidity and programmability for traditional financial instruments. The collaboration combines the regulatory rigor of enterprise blockchains with the speed and composability of Solana.

Together, these protocols demonstrate the diversity and strength of Solana’s RWA ecosystem. They are not only onboarding assets, but also building the infrastructure needed for them to be traded, lent, and used in complex financial strategies. This growing network of builders reflects Solana’s emergence as a serious home for tokenized finance.

Tokenized equities arrive Onchain.

In 2025, the launch of xStocks marked a major step for RWAs on Solana. Backed Finance, Kraken, Bybit, and the Solana Foundation introduced 55 tokenized equities and ETFs like Apple and Tesla as SPL tokens. These are fully collateralized, legally redeemable 1:1, and tradable on both centralized exchanges and Solana-native DeFi platforms.

Source: X

Users can now self-custody stocks in wallets like Phantom or Solflare. Fractional ownership from $1 makes global access easier, especially for users in restricted regions. However, liquidity is still thin for most tokens outside blue chips. Weekend price discovery is also limited. Despite these challenges, support from institutions and growing demand suggest a fast evolution ahead.

Ecosystem highlights: Collaborations and Integrations

Solana’s RWA growth is accelerated by powerful infrastructure partnerships that link traditional finance with blockchain rails.

Jupiter and the Kazakhstan Stock Exchange:

Jupiter’s partnership with the Kazakhstan Stock Exchange (KASE) explores dual listings. The goal is to allow companies to IPO on KASE and issue tokenized shares on Solana. This would make Kazakhstan a pioneer in hybrid capital markets and signal rising global trust in public blockchain finance.

Source: X

Stablecoins: Circle and Paxos:

USDC and USDP play a vital role in RWA settlements. Their integration on Solana enables instant, low-cost settlements and cross-border transfers for tokenized instruments like Treasuries and bonds. These stablecoins improve liquidity and usability for financial operations.

Source: X

Wallets, Custodians, and Compliance Infrastructure:

For institutions, secure custody and regulatory compliance are essential. Fireblocks, Anchorage, and Copper offer institutional-grade custody. Fractal and Civic handle identity verification. Wallets like Backpack and Phantom are adapting to support financial tokens, improving the user experience for both retail and institutional investors.

Huma Finance and the Rise of Income-Backed Lending:

Huma Finance introduces income-based lending on Solana through its PayFi protocol. It enables users to pledge income streams like payroll or invoices as collateral. Huma’s PST token allows these streams to plug into DeFi strategies using Jupiter, Kamino, and RateX. This introduces a new credit layer to the RWA ecosystem, blending DeFi composability with real-world financial data.

Source: X

xStocks on Jupiter:

Jupiter has integrated xStocks, allowing users to trade U.S. equities onchain with low fees and self-custody. The collaboration between Kraken, Backed Finance, and Solana aligns with Jupiter’s mission to enable global, permissionless access to traditional markets.

Source: X

Mapping the RWA Ecosystem on Solana

As RWAs grow on Solana, protocols are organized into functional categories.

Tokenized Treasuries

Ondo Finance: Offers OUSG, a tokenized short-term Treasury.
Superstate: Institutional-grade yield assets.
Franklin Templeton: The FOBXX fund is now available on Solana.
BlackRock BUIDL Fund: Issued via Securitize and bridged to Solana.

Lending and Underwriting

Maple Finance: Under-collateralized loans for institutions.
Huma Finance: Income-backed lending onchain.
Credix: Financing from off-chain income (potential Solana integration).

Infrastructure and Compliance

Custodians: Fireblocks, Copper, Anchorage.
KYC/AML: Fractal, Civic.
Securitize: Legal transfer and compliance for tokenized funds.

Institutional Integrations

R3’s Corda: Bridges financial giants to Solana.
Kazakhstan Stock Exchange: Exploring tokenized dual listings.
BlackRock and Franklin Templeton: Actively distributing tokenized funds.

Exchanges and Secondary Markets

Jupiter: Aggregates RWA liquidity.
Phoenix, Orca, Meteora: Support RWA token listings.
Wormhole and DLN: Cross-chain asset settlement.

Solana’s RWA stack is not siloed. It's an interconnected financial infrastructure spanning issuance, custody, trading, and compliance.

Global Regulatory Outlook: Harmonizing TradFi and DeFi

Regulators are slowly catching up to the RWA trend.

United States:

The U.S. remains fragmented. The SEC and CFTC often conflict, but recent legislative efforts aim to clarify the status of stablecoins. BlackRock and Franklin Templeton’s activity shows that regulated paths forward do exist, despite slow rulemaking.

European Union:

The EU’s MiCA regulation, arriving in 2025, brings clarity to stablecoins and tokenized assets. With pilot programs underway for digital bonds and tokenized funds, the EU is creating a structured yet open environment for blockchain finance.

Asia:

Singapore supports tokenized finance through MAS-backed initiatives like Project Guardian. Hong Kong has licensed crypto service providers. Kazakhstan is emerging as a frontier market with Solana-native IPO experiments.

Across regions, regulators are accepting tokenized Treasuries and distinguishing between consumer DeFi and institutional-grade tools. Jurisdictions offering clarity and sandbox support will attract more RWA builders. Solana’s compliance tooling positions it as a leader.

Opportunities and the Future of RWA on Solana

RWAs are just beginning. Solana’s architecture is enabling new asset classes and more accessible financial services.

Beyond Treasuries: Real Estate, Private Credit, and Equities:

Tokenized real estate and private credit are next. Properties can be fractionalized for liquidity, while private credit can be serviced through transparent, programmable smart contracts. xStocks and Kazakhstan’s dual listing pilot show how tokenized equities will evolve globally.

Composable RWA DeFi:

Solana’s composability allows RWAs to be used across protocols. Tokenized Treasuries or property tokens can be collateralized, traded, or staked. This turns assets into programmable financial primitives.

Retail-Friendly Products and Yield-On-Ramps

Apps will emerge to help users allocate savings to tokenized asset baskets. Solana’s low fees and fast confirmations make retail-grade, user-friendly tools viable. Buying U.S. stocks, earning yield, or taking loans against tokenized ETFs is now possible through crypto-native interfaces.

Emerging Markets: LATAM, Africa, and Beyond:

In inflation-hit or underbanked regions, tokenized dollars or equities are a lifeline. Solana’s speed and affordability make it ideal for deploying RWAs at scale in these markets. Mobile access, local stablecoins, and community participation are key enablers.

Personal Opinions

The RWA movement is strong, but challenges like:

Liquidity Fragmentation:

Different platforms issue assets under different standards, making interoperability hard. Jupiter helps at the aggregation layer, but deeper cross-protocol integration is needed. Slippage and pricing mismatches also persist, especially during weekends.

Legal Enforceability:

Tokenizing an asset doesn’t guarantee enforceable rights. Legal agreements and clarity are crucial for global adoption. Cross-border jurisdictional variation complicates asset validity and investor protections.

Custody and Compliance Risks:

Smart contract risks, wallet mismanagement, and lack of insurance are barriers. Institutions need bulletproof custody and compliance frameworks. Even KYC and AML hurdles can slow down onboarding.

Bridging Traditional Investor Trust:

Institutions expect clarity, control, and reliability. Blockchain UX must evolve to match traditional platforms. Education, transparency, and trust will be as important as performance or innovation.

Conclusion: Solana’s RWA Advantage

Solana is no longer just a fast chain. It’s a financial platform actively hosting RWAs at scale. With support from BlackRock, Franklin Templeton, Kraken, and others, it has matured into a legitimate base layer for global finance.

RWAs bring familiarity and regulation to DeFi. Their presence shows that DeFi is shifting from speculative hype to productive capital markets. And Solana’s combination of speed, composability, and infrastructure makes it uniquely capable of leading this new wave.

Robinhood’s tokenized equity rollout on Arbitrum and Solana’s growing institutional support indicate that this is only the beginning. Tokenized stocks, private equity, and 24/7 trading will become standard. The wealth effect will spread into DeFi, stablecoins, and even memes.

This is the time for builders to create useful tools. For institutions to modernize their offerings. And for regulators to help shape frameworks that work.

TradFi and DeFi are converging now. And Solana is where that future is being built.

References

What's the actual point of cNFTs?

Cza Maru — Wed, 10 Jan 2024 08:00:35 GMT

NOTE: This article was written as a Superteam bounty submission and subsequently won the top prize as announced here. It has been slightly edited to adjust for Substack viewership.

You’ve heard of NFTs. They’re the Bored Yacht Apes, the Cryptopunks, the DeGods, the SMBs. We’ve seen experimentations of NFTs unfold, from non-profit fundraising to token-gated access, from empowering agriculture supply chains to providing fun and access to events/communities, and we’ve seen them cut through the music industry and the traditional art houses (Sotheby’s, Christie’s, MOCO, etc.). NFTs are important to the blockchain space because they’re the second major use case that found product market fit within blockchain technologies after crypto.(1)

By now, it’s dumb to think NFTs are all scams–– especially when we’re now in an era of ‘compressed NFTs’, or cNFTs. Throughout this article, I’ll explore the state of cNFT adoption in the Solana ecosystem with you because what they mean for the culture of creation on-chain and possibly real-world assets (RWA) is something we cannot ignore as we work towards mainstream web3 adoption.

But first, what is a cNFT & who created them? 🤔

Here’s the definition of cNFTs presented by Will Smith:

cNFTs are basically the love child of two gigabrains in Solana: Solana Labs and Metaplex.👨‍👨‍👦 Through the combined creation of Solana Labs’s Merkle tree program (aka account-compression) and Metaplex’s compressed NFTs program (called Bubblegum), cNFTs were born. 💕

Long story short, the Merkle tree program (why does this sound so festive lol?! 🎄) enables compressed NFTs created via Metaplex to be encoded into the Solana blockchain. They store metadata and other info (like who the owner is) in a Merkle tree, which is different from normal NFTs, which store their data on-chain. FYI- a Merkle tree is basically just a data structure that allows you to verify large amounts of data quickly and efficiently. It breaks data down into smaller pieces called 🍃 “leaves” 🍃, then it gets more technical after that, so ask Mert.

Why were cNFTs created?

This is why cNFTs matter, compiled from at least 7 sources and compressed into the top 3 reasons:

CHEAPER :– Makes enterprise-level activity cheaper to help serve web2 and web3 enterprise customers who want to activate millions or even billions of users. In fact, many cNFTs are free, and this removes entry barriers for newbies.
This dramatic improvement in cost will reshape the industry by widening use cases across the board (more on this later; keep reading! 📌).
EFFICIENT ORGANISATION :– cNFTs are specifically associated with Metaplex Certified Collection (MCC), meaning cNFTs adhere to a set of standards/certifications provided by the Metaplex platform. This gives a standardized and organized way in which cNFTs are managed and intricately linked through the ecosystem.
SCALE ➡️ :- Because it’s cost-effective, it means that it’s easier to scale the content creation. cNFTs harness Solana’s state compression, facilitating the minting of up to 1 MILLION NFTs for hella cheap prices. In the words of Jay Z, “Ball so hard, this shit crazy.”

Here’s the math so far:

It allows founders, operators, and creators to experiment with their products, services, and/or art. This leads to better chances of succeeding and capturing user attention, and this level of attraction organically brings in people who want to build more products, tools, and use cases to service potential users and intrigued hyped communities.

What can cNFTs be used for?

This brings us to the use cases of cNFTs right now.

1. Starting with Drip Haus💧🏠
A project that allows creators to mint and airdrop NFTs, providing collectibles every week from Solana’s favorite creators. FOR FREE!

Drip leverages cNFTs by rewarding loyal users and talented creatives at a minimal cost. By joining DRiP, you’ll get all kinds of NFTs, access to rich collections, art with utilities, and maybe some phygitals too. The platform has minted over 36 million collectibles, witnessed 1.2 million sales on secondary markets, and +500,000 members/users. Through cNFTs, Drip Haus has shown us how to mint and distribute in vast quantities at a large scale– all in the name of access, frictionless onboarding, and community.

2. The other is a rather unique and daring use case: Solarplex. 🌞🔗 It’s a social app for the Solana ecosystem, connecting builders, creators, users, and other community members to discover and develop one another. In it, you can:

Discover cutting-edge projects, news, and resources in the Web3 ecosystem
Test products with real users and get high-quality user feedback
Transform ideas into NFTs in a flash

With Solarplex, creating an NFT is as simple as tweeting and collecting one is as simple as hitting the like button!

This wouldn’t have been doable before with normal NFTs because the cost would’ve been hiiiiiiiiiigh! But with compressed NFTs, they’re able to drop/send NFTs to daily active users. This is actually pretty cool because then you’re kinda bringing your “tweets” on-chain and curating your own community via the cNFT content/”tweets” you’ve ~~l̶i̶k̶e̶d̶~~ minted.

3. Dialect is another. 📲 💬

A first-of-its-kind chat experience, Dialect is a blockchain-based mobile messaging tool leaning hard into compression NFTs to power its interactive messaging functionality. They’re showcasing the innate social nature of NFTs.

Do you know how we’re able to preview rich media or open other texts through links?

Dialect’s ‘smart messaging’ does that for web3 so you can interact and engage with other users directly. Most recently, they introduced the feature of minting and sharing stickers directly within the messaging platform.

Before compression NFTs, Dialect would’ve had to either:

Bear the full cost of transactions to enable in-platform NFT mints or
Transfer those costs to the user.

Both of those options are huge Ls. 👎🏾

More importantly, they’re huge barriers for builders attempting to make NFTs available on a massive scale and definitely not something artists/creators would appreciate.

Now, cNFTs make this possible. Their compressed state dramatically lowers minting costs, and users can– pretty much freely– share NFT stickers on a mass scale with one another in a fun and engaging way.

4. Helium has been a prominent test/use case as well. 🎈🤝🏽

Dubbed #The PeoplesNetwork, Helium migrated to Solana earlier in the year (~April), and they were able to mint 1M hotspots as NFTs. 🤯 This means that each hotspot on the crypto wireless network is now represented by an NFT.

Minting that many NFTs on Solana would’ve typically cost approx. $250,000+ worth of SOL. But because of the state compression of cNFTs, Helium was able to mint 1,000,000 NFTs; the process cut the minting cost to about $113 worth of SOL.

BRUUUH, how?!

5. Picoplay is super fun. 🔳♟️

…And powered by cNFTs. You can play Chess daily to win fun rewards, and you can collect an NFT that has a timestamp and the number of attempts you made before winning. Can’t fake that I’m a grandmaster anymore! 😅

By combining exclusive weekly collectible drops and incentivizing players to keep daily streaks, Picoplay is a great way to utilize the technology of cNFTs while engaging a community through creative play.

6. And of course, MOB Studios. 💪🏼🔌

They’ve grown from an NFT project that has continued to evolve over the years, and they’ve chosen to leverage the functionality of cNFTs through Redeemable. Redeemables allow you to buy digital items linked to physical counterparts (phygitals), which can be traded or ‘burned’ to redeem the physical item directly from the brand or manufacturer. When I asked @Uzy100x why they decided to use cNFTs for Redeemables even though their PFP collection is legacy NFTs, he shared the following reasons:

Low cost and fast speed of creation and distribution at scale makes this perfect for larger audiences and making these available to the masses
The ability to enforce royalties means businesses/partners know they’ll share royalties from secondary transactions (incentivizes them towards SOL and cNFTs over other chains as it protects their interest and allows monetization)
The carbon footprint of each transaction is equivalent to that of 2 Google searches, so mass adoption can really make a positive environmental impact, especially where Redeemable changes the supply chain process

Who is powering all of these dope use cases?

All of these super cool things I listed are just the beginning, fam. There are so many different ways to engage people through cNFTs that won’t be possible if there aren’t any tooling platforms/services making all of this happen. cNFT tooling in the Solana ecosystem makes it easy to enable frictionless minting and distribution of compressed NFTs.

TipLink seems to be a favorite. Making a huge feature in this year’s (2023) Breakpoint, where they showcased how to transfer digital assets as easily as sending a link (the link is the wallet!), programmed to generate and hold tokens and NFTs at scale with their API.

Underdog Protocol is also providing promising ways to seamlessly integrate compressed (and all type of Solana NFTs) using their API and no-code tools.

This platform offers a suite of tools for managing cNFTs, including mass airdrops with no code and creating storefronts to help with claiming, distribution, and buying of digital goods.

And of course an honourable mention for Metaplex. The open-source framework of Metaplex and the Bubblegum programme have continued to expand more ways for cNFT-based applications. By empowering devs to leverage the benefits of cNFTs, Metaplex’s API further unleashes the power of compression across several areas:

Improves the reliability of data by standardizing NFT data
Improves speed and lowers costs of NFT data queries by not relying on resource-intensive methods
Reduces hardware costs over time

The state of cNFTs tooling across Solana is positive and growing. As more of these platforms continue to provide creative approaches to tools, the more beneficial it will be for the Solana ecosystem holistically. We’re already starting to see more engagements and user-friendly involvement across digital assets as the innovative solution to large-scale distribution and creation of NFTs continues to evolve through cNFT-powered applications and services.

Can we quantify the state of cNFT adoption?

The quick answer is:

Let’s break down the numbers.

⭐ Weekly cNFTs minted:

~3,000,000 a week!
Almost 45 million cNFTs were minted in Q3, a 316% QoQ increase. Drip Haus accounted for 87.5% of these mints, followed by Dialect and Helium. (7)

⭐ Unique users who hold cNFTs:

Drip Haus facilitated the minting of over 40 million cNFTs across diverse collections, reaching more than 1.2 million unique wallets.
The dialect has minted over 2.15 million units, spread across 100 distinct sticker packs.
During early Q2 of 2023, there were more than 332,000 unique holders of Helium’s cNFTs (claimed from over 991,000 NFTs on offer), according to data compiled by Flipside Crypto. (8)

⭐ Associated costs:

On Solana (with compression), it will cost around 0.0000005 SOL per NFT, so about $11,000 USD for a billion NFTs. That is ~50 million dollars or about three orders of magnitude cheaper.
According to this tweet, between Drip, Dialect, and Helium, the minting cost only reached $30,000 USD!
There are tools like this that can help calculate the costs of how many compressed NFTs would cost to store, as well.
There are some discrepancies on how much cNFTs are reducing costs. There’s no argument that they are reducing them dramatically, but perhaps some numbers are not as accurate as they could be. Here’s an example: when @redacted_noah disputed cNFTs minted with Metaplex crossed 6.9M but only cost ~$1,000 USD to mint.

⭐ Marketplace volume:

Here are more insights into legacy NFTs traded volume in the last 24 hours across 6 platforms (as shown via Tensor’s comparative table on the bottom left corner):

How do cNFTs compare to legacy NFTs?

It seems like the state of cNFT adoption in Solana is increasing more and more. While legacy NFTs still continue to dominate in popularity amongst pop collections, trading activities on marketplaces like Tensor, the technology driving the cheap costs of cNFTs, and their ability to mint in such massive numbers are definitely catching the attention of certain communities in Solana.

Here are some stats on how the Top 10 trending NFT collections on Tensor compare to the Top 10 trending cNFT collections in the last 24 hours (December 17 2023):

And here are some deeper technical numbers of NFTs vs cNFTs sales over time:

Of course, compressed NFTs were only introduced early this year, and there’s still room for them to grow against legacy NFTs (they’ve had a head start in the last couple of years, anyway). But with the likes of @vibhu from Drip pushing hard on the use case and argument for cNFTs as “Trad NFTs as a format are dying fast”, a pretty drastic comparison in numbers can’t be ignored:

In August 2023, 98.5k NFTs were minted vs. 15.68 million cNFTs.

With these numbers and rate of adoption and application, I present these types of communities that have merged since the creation of cNFTs. They all have different interests and goals and so it’s important to note that subcategory, or subcommunity, will view the impact and effects of compressed NFTs in their own way.

The future of cNFTs looks high-key interesting 👀

People are now looking to build beyond the use cases of legacy NFTs that creators, builders, and founders have found a barrier with. Different types of things are now being built on compression through art, memes, gaming, etc.

For example:

Games want to distribute 1,000 digital game assets to X amount of users, and they want to do it monthly for free.

Trad NFTs simply can’t do that.

The future of NFTs on Solana, in my opinion, is not through the impact of 10k pfp collections– it’s through the power of state compression.

Here are some of my real-world suggestions– not limited to just art– that take into consideration the possibility of large-scale, cheap distribution of NFTs that weren’t possible before:

Digital Ticketing and Event Loyalty Programs 🎟️
Event organizers, concert venues, and entertainment companies can issue cNFTs as digital tickets for concerts, shows, or events. Either as POAPs or a way to create loyalty and rewards programs by associating specific benefits or perks with the cNFTs.

✅ This won’t limit NFTs being available to just a few hundred people who can afford it. Compressed NFTs enable a cost-effective way to manage digital ticketing systems at scale and allow accessibility. They can be easily distributed, verified, and redeemed, providing a seamless experience for event attendees.
Educational Certificates and Credentials 👩🏽‍🎓
Universities and schools can issue cNFTs as digital certificates and credentials to students upon completion of courses or degrees, making it easier to access their grades when filling out job forms through a wallet instead of physical papers or via emails that get lost.

✅ These cNFTs also ensure that grades and credentials can’t be forged. The reduced cost of using compressed NFTs makes this a viable solution for educational institutions of all sizes and for thousands of students.
Medical Supply Chain and Product Authenticity 💊
Brands can use compressed cNFTs to track and verify the authenticity of products within the supply chain. Each product can be associated with a unique compressed NFT that contains information about its origin, manufacturing details, and distribution history.
✅ It’s feasible to implement this solution across a wide range of products because of cNFTs, and by doing so, it enhances transparency in the supply chain, reduces the risk of counterfeit meds, and provides patients with a trustworthy way to verify the authenticity of their medicines.
Podcasts and audio distribution 🎧
Personally, I’d also like to see podcasts and audio distributed as cNFTs throughout the ecosystem. Podcasters can leverage cNFTs to transform the distribution landscape for audio content (see the likes of Ohr experimenting with audio for social media).

✅ Each podcast episode can be represented by a unique cNFT, offering several advantages for creators and listeners. Reducing overall distribution costs compared to traditional methods is obvious, but cNFTs can also unlock new community engagement, e.g., create limited-edition cNFTs tied to specific episodes, creating a tangible and collectible element for listeners.

So, what does this all mean as far as the adoption and impact of cNFTs in Solana? 🤩

The emergence of cNFTs on the Solana stands out as a revolutionary development, tbh. As we’ve explored together through this overview, cNFTs aren’t just a fleeting trend– it’s low key become a significant evolution in the Solana NFT space.

The state of cNFT adoption on Solana reflects a growing and dynamic ecosystem that has embraced the efficiency and cost-effectiveness of compressed NFTs while allowing floods of new opportunities for creators, devs, collectors, founders, and the entire community. This innovation is reshaping the way we think about how digital assets can be created, distributed, and experienced.

As cNFTs continue to gain traction and demonstrate their potential across use cases, the Solana ecosystem is witnessing a paradigm shift in not just how different communities are being formed through cNFTs, but also in how we’re approaching and exploring ways the technology can be tested and trialed.

The impact of cNFTs extends beyond the blockchain, influencing real-world scenarios and opening up new possibilities for– dare I say– mass adoption…like actually, this time.

The future of cNFTs on Solana appears promising, and it’s redefining the narrative around Solana NFTs in contrast to ETH ones. Lol. Especially since now other-chain maxis are clocking onto the great things SOL is doing in the broader context of digital culture and web3 enterprises, the state compression has paved a new path for others to be bullish on Solana. #OPOS 🧬

References

(1) https://www.helius.dev/blog/solana-nft-compression#compression-background

(2) https://flagship.fyi/outposts/dapps/a-drip-haus-deep-dive-the-future-of-nfts-with-innovation-of-inclusivity/

(3) https://solana.com/news/case-study-dialect

(4) https://decrypt.co/137257/helium-completes-solana-migration-minting-nearly-1m-nfts-in-the-process

(5) https://www.metaplex.com/posts/expanding-digital-assets-with-compression-for-nfts

(6) https://coinmarketcap.com/community/articles/651e189ea15b5f6d81eaf7a2/

(7) https://messari.io/report/state-of-solana-q3-2023

(8) https://nftplazas.com/helium-migrates-to-solana/

Deep Dive: Reviewing Parcl, an On-chain RWA Investing Platform for Everyone

Long "Leo" Pham — Tue, 27 Jun 2023 05:31:00 GMT

NOTE: This article was written as a Superteam bounty submission and subsequently won the top prize as announced by Parcl here. I have made some edits to adjust for Substack viewership.

Parcl is a Web3 real estate investing platform that allows anyone to invest in real estate assets for as low as $1, by offering a platform for users to get exposure to entire real estate markets in US cities through REIT-like indexes.

In this article, I will attempt to explore the market context & viability of Parcl’s business model, the Parcl v2 product, and some of my own opinion & feedback.

Market Context

REITs

Real estate investment trusts (“REITs”) have been around for a long time. According to Investopedia, a REIT is a company that owns, operates, or finances income-generating real estate. Similar to mutual funds, REITs pool the capital of numerous investors, making it possible for individual investors to invest in real estate — without having to buy, manage, or finance any properties themselves.

REITs can be invested in through public or private channels, through equity and/or mortgage. However, for retail investors, public equity REITs would be the most common way to get exposure to the real estate sector.

Fractional Ownership

Zooming out further from REITs, retail investors can also get access to real estate asset via fractional real estate investing. This is when many different investors split the cost of property among them. Fractional ownership gives them a stake in the real estate and makes them part-owners.

Fractional real estate investing comes in different formats. Sometimes the investor receives a deed and equity in the property; other times one can buy shares in a property, which is then operated by a management firm. In some cases, the fractional ownership interest entitles its investor to stay in the property for vacation, for a portion of the year. In other cases, you can invest in the properties with no intent to actually stay in them, but to rent out via platforms like Airbnb.

On-chain Investing

Expanding from the concepts of REITs and Fraction Ownership, a number of web3 firms have attempted to offer access to real-world assets (RWAs), particularly real estate, by leveraging blockchain technology.

Here’s a basic use case for blockchain in Real Estate investing:

Source: LeewayHertz.

Propy is one of the earliest companies attempting to leverage blockchain for property auctioning. In 2021, Michael Arrington, the cofounder of TechCrunch and Arrington XRP Capital, tokenized his apartment near Kyiv, Ukraine, as an NFT and sold it on an auction for 36 ETH.

Michael Arrington’s apartment NFT. Source: Arrington Capital.

Fraction is an example, in which the company allows retail investors to buy partial ownership of a particular property for a price. The categories of offering RWAs can range from beachfront pool villas, penthouses, EV charging stations, to luxury yachts, which means it is not limited to real estate. Currently, the company only operates in Thailand and does not allow US citizens to access its products.

Then there is HomebaseDAO, a property deed tokenization platform on Solana that allows individuals to buy partial deed ownership as NFTs by tokenizing properties on Solana using a smart contract that was tied to an NFT. It has managed to tokenize its first NFT title deeds for a house in south Texas. The property was valued at $235,000, but Homebase was able to raise $246,800 (in USDC) for the property.

Above are some of the most recent and relevant examples of Web3 Real Estate companies and their practices. A more detailed mapping of the landscape can be found here:

2022 Web3 Real Estate Landscape. Source: Zofuku.

Entering Parcl

About Parcl

Parcl is a Web3 real estate investing platform that leverages blockchain to address the current bottlenecks facing property investing, by bringing the world’s most desirable RWAs to the blockchain.

In May 2022, Parcl announced a $7.5 million funding round with participation from the likes of Archetype, Dragonfly Capital, Shima Capital, Solana Ventures, Not Boring Capital, and FJ Labs.

An Intro video about Parcl can be watched here:

Parcl’s Model

Parcl is quite different from other models. Most importantly, Parcl allows users to invest in neighborhoods and cities instead of specific buildings. Its indexes act as a REIT-like index system, representing a city’s residential real estate market.

The protocol developed by Parcl “allows users to invest in a digital square foot of real estate in neighborhoods worldwide. It does so by allowing for the creation of synthetic “Parcls” which are tied to a price feed that is representative of the average price per square foot/meter within a given neighborhood.” In layman’s terms, each Parcl index represents the median price per square foot/meter in a given geographical location and is freely tradable within the platform’s liquidity pools. The precision can be improved as Parcl collects 10+ million data points daily for precision pricing.

In theory, this concept works well for retail investors that seek out highly liquid assets and broad diversification in the same sector, or in this case, real estate & more broadly RWAs. It eliminates the particular risks of owning a real estate property within a distinctive region, which can be troublesome in market downturns like the post-COVID slum era. It also lowers the entry and exit timeline significantly and allows users to proactively manage their portfolios.

Parcl also suits investors seeking opportunities globally. It focuses on entire neighborhoods inside the world’s best-performing cities, including New York, Miami, and Los Angeles, with international markets like Paris, London, and Singapore, to be available in the near future. Retail investors can invest in multiple cities at once by forecasting market movement in a bullish (long) or bearish (short) direction.

Parcl Protocol v2

To understand how Parcl works, one must first understand the protocol driving it. The full Whitepaper for Parcl v2 can be found here. I’ll simply go through some of the key aspects of its foundation.

Definition

Parcl v2 is considered an automated market maker (”AMM”) for perpetual synthetic assets, by combining the best features of both traditional AMMs and synthetic asset protocols to produce an efficient and simple synthetic asset AMM.

“Automated market maker” is a type of decentralized exchange (DEX) that use algorithmic “money robots” to make it easy for individual traders to buy and sell crypto assets. Instead of trading directly with other people as with a traditional order book, users trade directly through the AMM exchange smart contract protocols that use mathematical functions for price discovery.

“Synthetic assets”, or tokenized derivatives, are records of the relationship between the underlying asset and the purchaser. In the traditional financial world, derivatives are representations of stocks or bonds that a trader does not own but wants to buy or sell. Synthetic assets, or tokenized derivatives, take this process one step further by adding the record for the derivative on the blockchain and essentially creating a cryptocurrency token for it. Synthetic asset protocols generate smart contracts that govern this record and token system.

Key Features

Isolated Pools
Solvency
Price Execution
Zero Credit Risk
Optional Liquidity Provision
Skew Management
Delayed Settlement

The details of these features can be found in the whitepaper and are applied to operate the Parcl app that we will dive in later.

Advantages

Some benefits of using Parcl v2 for synthetic asset trading include solvency, zero credit risk, capital efficiency, and price execution at oracle prices. Additionally, Parcl v2 ensures solvency and zero credit risk for users through its unique liquidity token accounting model. This model accounts for pool ownership and position PnL accounting, and all closed positions are paid out in liquidity tokens. This means that all traders become implicit LPs at position open and become explicit LPs at position close. This mechanism forces solvency because traders are not paid out dollar for dollar in collateral.

Parcl v2 protocol also minimizes governance as much as possible, mainly because there are fewer risk parameters than other competitors. Pool management can be configured to be permissionless and liquidity provision is always permissionless.

Limitations

Parcl v2 at the moment only supports price feeds for assets that cannot support liquid trading markets. Future development on slippage among other protocol features would allow the protocol to be used for any price feed.

For governance, there are some areas where non-permissionless configuration is involved. For instance, when pool creation is not set to permissionless, then only the protocol admin can create a new pool.

Diving into the platform

The Parcl DApp is built on Parcl v2 protocol and open to public access here. I will attempt to go through the features of Parcl DApp in this section.

Solana Wallets

One does not need to connect a Solana wallet to view around the DApp, in particular Explore & Trade views. Only when you want to start investing that you need to connect your Solana wallet to Parcl DApp.

Currently, Parcl DApp supports Backpack, Phantom, Solflare, and Ledger.

Explore

This is by default the landing page of the App.

At the time of writing, Parcl provides access to most of the top US real estate markets, including New York, Boston, Philadelphia, San Francisco, Los Angeles, Washington, Chicago, Atlanta, Seattle, Denver, Las Vegas, Miami Beach, and Phoenix.

Users can sort the indexes by Top Gainers/Losers, New Indexes, and geography (East Coast, West Coast, Midwest). “View All” allows users to see all the indexes, not just the top ones.

Each index has been provided with detailed statistics, including Open Interest price, Total Deposits, Market Sentiment (% of Long vs. Short), and Price. There is also a Trade button, which will redirect users to the trading page of that particular index.

Trade

Upon clicking on the “Trade” button for any index, user is navigated to the Trade page for that index. For instance, here’s my view for Atlanta:

I set the time period to 1 year, so the chart is showing Atlanta index movement for the last year. Other options are 7-day, 1-month, 3- month, and 6-month. The floating Trade widget on the right allows users to put their Buy/Long or Short order, which we will come back to later.

As we scroll down, we can view more data about this index:

Parcl DApp provides users with all the relevant data about this index, including key Trading Stats (just like when one buys a REIT stock on stock exchanges) plus Market Sentiment. This Market Sentiment feature is quite interesting because it allows users to read the arguments from both bullish and bearish directions.

Further down, there is a map of the Atlanta metropolitan area, showing all the housing units as well as basic Facts & Stats about this city.

There is a heat map for all the units, which users can filter by categories: Single Family, Townhome, Condos, or Show All. The heat map would change accordingly to the applied filter.

Facts & Stats appear to be standard for the entire city and not affected by the filter. Key stats include Total Population, Median Age, Median Household Income, Total Area, and even 90-day Temperature High/Low (this data item can be important if you’re looking at the livability factor of a city).

At the bottom section, users can also refer to other relevant markets:

This doesn’t appear relevant for geographical reasons, but rather due to the indexes being in the same Top Gainers category.

The “Explore More” button would take us back to the Explore page.

Going back to the floating Trade widget, as users attempt to make a trade, connecting wallet is required:

Other data like Leverage, Entry Funding Rate, Exchange Rate (USDC-USD) and Estimated Fee are also available for review. The Estimated Investment Value is calculated based on these data.

Upon submitting the order (in this case, I’m buying a Long order), users will be prompted to accept the transaction in their wallet and pay some gas fees in SOL (Solana’s native token). After that, the confirmation window looks like this:

Users can go to SolScan to view the on-chain transaction (mine is here), or just Dismiss this window.

The floating widget now looks like this:

Clicking on “Open Position” would allow users to trade again. On the other hand, clicking on the Position under “My Positions” would expand a panel allowing users to close that position:

Liquidity Pools

After successfully connecting a Wallet and opening a Position, users can navigate to Liquidity Pools tab in the navigation bar to access the Pool products. For this example, once again I select Atlanta:

After reviewing the order, clicking Submit, and approving the transaction in your Solana wallet, users can see this confirmation widget:

Similarly with the Trade feature above, after clicking Dismiss, users will see the updated view to add/remove Liquidity to/from Pools:

The +/- toggle buttons will allow users to alternate between Deposit/Withdraw their liquidity from Pools.

Portfolio

After opening a Position and adding some LP, let us go to check out the Portfolio page:

On the left side, users can check their total positions for both Long/Short trade and LP. Clicking on the “Total LP Positions” block would take users back to the Liquidity Pools page, whereas doing so on any index’s Long/Short Position block would take users back to the Trade page for that index.

On the right side, users can view their Buying Power, which means the amount of USDC in their connected wallet, as well as their SOL balance (for transactional gas fees).

Other Tools

Wallet Management

Aside from the Portfolio page, users can also access their balances by clicking the Wallet icon on the top right corner of any page:

Upon clicking on the Wallet button, this widget drops down:

Here you can see your Buying Power just as on the Portfolio page. There are also other features, including Transaction Settings (only for Advanced Features users), Copy Wallet Address, Change Wallet, and Disconnect Wallet. Change/Disconnect Wallet should only be used if you need to replace the currently connected wallet with a new wallet or log out of this wallet.

USDC On-ramp

If you want to add more USDC to your Buying Power, Parcl DApp allows you to buy USDC seamlessly from within the DApp, by clicking on the Balance on the right of the Wallet icon. Upon clicking, a window popup would appear:

This feature is powered by MoonPay, a Web3 payment gateway that supports dozens of currencies. Users will need to enter their email address and verify it with a one-time password sent to that email address, then enter personal details such as name, date of birth, residential address, and finally payment details (debit/credit card). After completion, they can buy USDC easily without having to re-enter this information.

Notifications

Should users wish to receive updates on their personal social accounts, they can also register for notifications. Clicking on the Bell icon on the right of the Wallet icon would open a dropdown window. Users would be asked to approve in their wallet before they can access this:

Users can opt to receive notifications to email/phone number/Telegram. Upon completion, users can always come back and manage notification settings. (For Telegram, an extra step of ID verification is required.)

Chat (Beta)

This beta feature is basically an AI assistant powered by ChatGPT, allowing users to query about Parcl products, features, and general market insights. It currently supports multiple languages such as English, Chinese, Indian, etc.

Trading Contests

Users also can access Contests to view and/or participate in trading campaigns in Parcl. One can compete with other Parcl users in order to win prizes, including cash (USDC) prizes, NFTs, badges, etc. One can also check the listed prizes, time period of the contest, rules, weekly stats, and leaderboards. “Maximize Your Potential” however is only available to Advanced users. At the time of writing this article, the Real Estate Royale Season 3 campaign is live:

(bonus) Advanced Features

This set of features applies only to advanced users, meaning that one must possess a sufficient understanding of how leverage trading works in order to opt in.

Users can join the Advanced Features program on Parcl DApp through the Wallet window as shown above. Upon confirming to join, users will be prompted to answer this form:

After clicking “Enable Features”, users can now access the Transaction Settings panel within Wallet window. Here, users can set their Default Leverage for trading. Close & Burn is On by default, meaning that the Long/Short positions will be automatically liquidated once down 75% and beyond.

After saving the changes and going back to the Trade page of any index, users can notice a new feature when opening a position. This leverage rate can be adjusted manually.

Furthermore, users can place simultaneous Long/Short positions, i.e. Long Atlanta, Short San Francisco.

Parcl’s Benefits

Having gone through the theoretical whitepaper of Parcl v2 and the actual Parcl DApp, I can see several benefits that Parcl can bring to both Web2 and Web3.

Benefiting Crypto/Web3 Users

Crypto users, in particular traders, probably are quite familiar with concepts of leverage, Long/Short trading, Liquidity Pools, etc, so the Advanced Features of Parcl would be quite easy for them to understand and use. With both the Basic and Advanced Features, traders can explore a whole new asset class with very minimal initial capital required, for as low as 1 USDC plus a few cents of gas fees in SOL. They can access all these real estate markets and their yields, as well as entire cities via indexes to minimize single-site risk.

Other Advanced Features like Leverage, Pair Trading as well as basic features like Liquidity Pools, Shorting, and Research Data would also allow traders to better prepare and hedge risks from market downturns, hence develop better strategies for changing market conditions to maximize returns on investment.

Benefiting the Mass a.k.a. Web2 Users

For the average retail user, Parcl opens the door to a new alternative when it comes to real estate and, in a broader sense, real-world asset investing. By accessing transparent datasets, RWA risk hedging, and improving liquidity through dynamic Liquidity Pools, retail users can easily tap into the on-chain RWA indexes and pools with very minimal initial costs and a seamlessly usable user interface.

Benefitting Web2⇒Web3 Onboarding

Assumingly, after using Parcl, these retail investors can get a taste of Web3 products and how easy it is to leverage blockchain technology in seemingly traditional investing practices, hence onboarding them into other Web3 RWAs and products. This opens a huge window of opportunity for other DApps to be built on Parcl Protocol with regard to other RWAs beyond just real estate indexes.

Final Thoughts

Having spent the last 24 hours reviewing Parcl Protocol v2 whitepaper and the Parcl DApp itself, I can confidently say that this has been one of the best Web3 consumer DApps I have ever interacted with, in terms of both functionality and user-friendliness. While I have to admit that I can’t fully comprehend the whitepaper, especially the mathematics behind the calculations of Impact Fees and Funding Rates, the DApp itself was straightforward, well-designed, and quite easy to navigate, even for Web2 users. There are certainly areas for improvements, but for a Consumer DApp not only on Solana but on any chain, this by far well exceeded my expectation for Web3 applications. I look forward to continuing to use Parcl for my investing needs and will be looking out for future features from the Parcl team.

BetDex and The Web3 Betting Ecosystem

Grahil Khandelwal — Tue, 13 Jun 2023 05:30:58 GMT

Overview of the Sports Betting

The sports betting market is booming, with a global value of USD 83.65 billion in 2022 and an expected compound annual growth rate of 10.3% from 2023 to 2030. It's no surprise considering the recent changes in the global gambling sector regulations, the growing use of connected devices, and the development of digital infrastructure.

Every year more than 2 Trillion dollars worth of assets are betted by individuals on different occasions. It is more than the GDP of some of the biggest major countries like Italy and Germany. Let that thought sink in.

Even though the COVID-19 pandemic has affected the sports industry, it's interesting to see that online sports betting gained popularity during the pandemic, with the rise of eSports and similar forms of betting.

What's more, smartphones have made sports betting more widely available and accessible, with mobile devices contributing to around 70% of online betting revenue in 2020, according to a recent survey by Uplatform, a sports betting and casino operating platform.

Today, We are gonna deep dive into Betting markets and how Web3 is revolutionising the traditional betting industry taking BetDEX as an Example. BetDEX is a Web3 betting app that let you bet on your favourite sports like Cricket, Football and basketball.

So, let’s start with government regulations on betting.

Regulations on Betting

Governments worldwide are easing regulations on betting and gambling activities, creating new opportunities for both operators and consumers. For example, the American Gaming Association reports that as of January 2023, sports betting is now legal in 36 U.S. states, up from 32 in 2021.

In the first ten months of 2022 alone, users legally wagered an incredible USD 73 billion on sports in the U.S. This trend suggests that the betting industry is thriving and that we can expect to see continued growth in the years ahead. As more countries legalize sports betting, the market is likely to expand even further, creating exciting new opportunities for industry players and sports enthusiasts alike.

Due to this high increase in participation in Betting, many new forms of betting have evolved in recent times, one example is e-sports betting. Increase of the internet and technology the whole sector is developed, and become one of the biggest betting sectors.

Types of Betting.

In 2022, the fixed odds wagering segment dominated the sports betting industry, accounting for over 26% of the revenue share. However, the fastest-growing segment is predicted to be eSports betting, with a projected CAGR of over 14% during the forecast period.

Interestingly, according to DataReportal, around 60% of the world's population has access to the internet, making online sports betting more accessible than ever before. With such a large percentage of the population online, it's no wonder that the betting industry is seeing a surge in growth.

It's important to note that behind these numbers and statistics are real people who are passionate about sports and betting. As technology continues to evolve and betting becomes more accessible, sports enthusiasts worldwide can easily place bets on their favourite teams and players. Whether you're a die-hard fan or just enjoy the thrill of the game, the sports betting industry offers a range of exciting opportunities for both operators and consumers alike.

Major Sports Betting Markets

Europe is currently the largest market for sports betting, with a market share of over 35% in 2022. As the industry continues to grow, the region is expected to expand at a CAGR of almost 10% during the forecast period.

One of the reasons for Europe's dominance in the sports betting industry is the favourable regulations in place across European countries. This has allowed for a thriving and competitive market that benefits the population.

The United Kingdom has been at the forefront of legalizing sports betting, with laws permitting the activity since 1960. These well-established regulations have led to a thriving market for sports betting in the country. The online sports betting segment has seen remarkable growth across Europe, with offline/retail betting activities facing restrictions. Consequently, the online sports betting market in Europe is projected to surpass USD 40 billion by the end of the forecast period.

In contrast, the Asia Pacific region is expected to see the highest compound annual growth rate (CAGR) of over 11% during the forecast period. One of the significant drivers behind the growth of the sports betting industry in this region is the rising percentage of the population participating in various forms of sports betting activities. As several countries in the region legalize the gambling industry, overseas market players are also attracted.

Gambling is a popular pastime in China and India, with around 80% of Indians reportedly gambling at least once a year, according to the India Internet Player Society (IIPS). As sports betting continues to gain popularity in the Asia Pacific, the region is poised to become a significant player in the global sports betting market in the years ahead.

As most of the betting happens online it has been a good boost for the betting industry but there are also some big problems with traditional betting websites like restrictions on betting, funds lock up, high fees and many more. In fact, many companies are often not regulated by any governing body, due to which many people lose their money in scams and rug pull.

Traditional Problems with Online Betting:

There are several problems in the online betting industry. Some of the major problems are as follows:

Fragmented Market: There are currently thousands of sports betting sites to choose from, but the problem lies in the underinvestment in their products. Most of these sites still use basic HTML technology, which is not even up to web2 standards, let alone web3. This results in subpar products that are not mobile-friendly and do not function properly.
High Fees: Moreover, these sites often have a small liquidity pool, which means that you cannot stake your bet above a certain amount. In addition to this, the fees and commissions charged by these sites can be as high as 40%, which is a significant amount.
Lock Up Funds: Another issue with these sites is that they often lock up your money and require you to play multiple times before you can withdraw your earnings. This can be frustrating for users who want to withdraw their winnings promptly.
Counterparty Risk: To make matters worse, some of these sites are unreliable and can disappear overnight, leaving their customers in the lurch. Winning customers is also not welcomed and may be restricted, which can be disheartening for users who are looking to make some profits.
Winners aren’t welcome: BetDex recognizes that all these issues are major problems for users and strives to offer a better betting experience by addressing these concerns. They were committed to providing a reliable, user-friendly platform with competitive fees and commissions, and we welcome winning customers with open arms.

These are some of the problems that regularly occur in the traditional betting industry. Many of the regular bettors face huge losses due to these problems. These all problems can be easily tackled by the integration of blockchain infrastructure and decentralisation.

In the world of sports betting, there are two options for bettors: traditional sportsbooks and decentralized sports betting platforms. Traditional sportsbooks are run by bookmakers who act as intermediaries between the bettors and the sports events they are betting on. They take a commission on each bet and can limit the amount that bettors can wager, particularly if the bettor has a history of winning big. Additionally, the payout process can be slow, and there is always the risk that the sportsbook will go bankrupt or run off with the bettor's money.

Decentralized sports betting platforms allow users to place bets directly with each other through a blockchain-based system, without the need for intermediaries such as bookmakers.

The use of blockchain technology ensures the transparency and security of the betting process, as all transactions are recorded on a public ledger that cannot be tampered with. This makes it harder for hackers or fraudsters to manipulate the system or steal funds.

Additionally, decentralized sports betting platforms often have lower fees compared to traditional sportsbooks, as there is no need to pay commissions to bookmakers or other intermediaries. Overall, decentralized sports betting offers several advantages for users, including faster and more secure betting, greater control over their funds, and lower costs.

Let’s understand with an example: Mani is a frequent bettor who enjoys placing bets on his favourite sports teams. He has been using a traditional sportsbook platform to place his bets, but he's become frustrated with the high fees and restrictions imposed by the platform.

One day, a friend tells Mani about a decentralized sports betting platform that operates on the blockchain. Intrigued, Mani decides to give it a try.

He creates an account on the platform and is pleased to discover that he can place bets on any sports event he wants without any restrictions. The platform uses smart contracts to automatically execute the terms of his bets, and since the platform is decentralized, there is no need for intermediaries such as banks or payment processors.

Mani also enjoys the fact that the transaction fees on the platform are negligible compared to the traditional sportsbook he used before. He can withdraw his funds anytime he wants without any delay, as there are no restrictions on his account.

Moreover, since the platform operates on the blockchain, all transactions are recorded in a public ledger that is tamper-proof and transparent. This means that Mani can be sure that his bets are being placed fairly and that the outcomes are not being manipulated in any way.

Overall, Mani is very pleased with his experience on the decentralized sports betting platform. He can place bets on any sports event he wants without any restrictions, and the platform operates with transparency, security, and low transaction fees.

Now we know what are the advantages of the Decentralised betting protocols, let’s take a look at BitDEX, which is the most seamless betting protocol on Solana.

BETDEX

BetDEX Exchange officially launched on Solana's main-net on November 17, 2022. to coincide with the beginning of the 2022 FIFA World Cup.

BetDEX Exchange is a platform that seeks to revolutionize sports betting by leveraging the Monaco Protocol and Solana to create a decentralized sports betting exchange.

The exchange provides a peer-to-peer (P2P) marketplace where traders can come together and trade their opinions on different outcomes in sports using cryptocurrency.

Non-Custodial

Decentralized exchanges (DEXs) differ from centralized exchanges (CEXs) in that they provide a non-custodial platform where users retain control over their funds while trading. This provides users with greater security and trustworthiness since they have complete control over their funds, and can make transactions without intermediaries.

No Stake Limits

On BetDEX, there are no limitations on the size of bets that can be placed. This is a significant advantage for high rollers who want to place large bets without being constrained by limits. BetDEX allows users to place bets of any size, from $10 to $10,000, without any restrictions.

Low Fees

BetDEX Exchange enables users to conduct transactions securely and transparently while minimizing the fees that would have been charged by intermediaries on centralized exchanges. Currently, BetDEX charges two types of fees:

Solana Transaction Fees: These fees are charged by the Solana blockchain network for processing transactions. Although BetDEX has no control over these fees, they are typically very low.
Operator Commission: This commission is charged by the exchange on winning trades. The commission rate is currently set to 0%, ensuring that users keep the entirety of their winnings.

Immediate Withdrawals

When you win a bet on BetDEX, you can withdraw your winnings instantly from your wallet. Unlike traditional exchanges, where you may have to wait days or weeks to withdraw your funds, BetDEX allows you to access your winnings immediately. This means you can use your winnings to place more bets or withdraw them from your bank account.

In addition to these benefits, the BetDEX Exchange also ensures that users have access to the latest information and updates on their favourite sports.

By leveraging the Monaco Protocol and Solana, the exchange can provide quick and efficient transactions, making it the go-to platform for sports betting enthusiasts.

Overall, the BetDEX Exchange is poised to disrupt the traditional sports betting industry by providing a decentralized platform that is secure, transparent, and efficient.

Risk-Free First Bet

BetDEX is providing a risk-free initial wager of up to $50 to newcomer. This presents an excellent chance to get familiar with the platform and enjoy the excitement of decentralized sports prediction

Founder’s Profile

Varun Sudhakar - CEO and Co-Founder of BetDEX. Previously VP of Finance & Strategy at Hive and VP of Finance at Simplifeye. Senior Manager at FanDuel prior to that.

Nigel Eccles - Chairman and Co-Founder of BetDEX. Co-Founder of FanDuel and Flick. Helped create StarStock.

Stuart Tonner - CTO and Co-Founder of BetDEX. The first engineer hired at FanDuel, served as Head of Engineering and Chief Technology Officer at LeaseLoco before joining BetDEX.

The Monaco Protocol

The Monaco Protocol is the underlying infrastructure powering the BetDEX exchange. It is a decentralized liquidity network for exchange-based applications and is built on the Solana blockchain. It is fully open source meaning other applications can be developed and benefit from the shared liquidity pool that the protocol provides.

Benefits of The Monaco Protocol

This trading platform is fully non-custodial. Funds are held in escrow and paid out to the trader's wallet upon settlement. It streamlines the wagering process by allowing traders to specify the highest price they are willing to take on a particular market outcome.

The platform incorporates the concept of smart matching/exposure in directly correlated outcomes. This ensures that the smart contract only takes the minimum amount necessary from a given trader's wallet to safely cover that trader's maximum exposure across all of the trades they have placed in a set of directly correlated outcomes. Traders can cancel unmatched or partially matched orders at any time.

The platform helps provide greater liquidity for participants, reduces spreads, and offers lower prices. It also lowers the take rates of institutions and intermediaries. Furthermore, it reduces settlement times, increases transparency, and improves capital efficiency. The platform incorporates the ability to determine the outcome of events in a decentralized fashion based on third-party oracles.

Functioning of Monaco Protocol

The Monaco Protocol offers the ability to wager on the binary-outcome events, it is agnostic to the nature of these events. Orders can be placed either FOR the outcome (it will happen) or to AGAINST it (it won't happen) at a specific price (odds) and stake (wager).

Architecture

The concept of a market is comprised of three primary accounts:

Market Account This contains core market information such as the title, type, status, lock time, outcome, and linked event.
Outcome Account There is one such account for each possible outcome on the market, with each containing a price ladder.
Outcome Matching Pools There is one such pool for each possible resolution and price of a market (for example: price of 10 FOR, price of 10 AGAINST, price of 2 FOR). These pools contain matching queues to facilitate the matching of orders.

If you wish to learn more about Monaco protocol you can visit:

https://docs.monacoprotocol.xyz/

Solana

Solana is a decentralized blockchain that has been designed to enable scalable and user-friendly apps. It is a blockchain that runs on a unique consensus algorithm that enables fast transaction speeds while maintaining security.

This makes it a perfect fit for the BetDEX Exchange, which has been built on the Solana blockchain network due to its speed, high transaction throughput, and low transaction cost.
Solana's speed and low costs are crucial elements for any exchange-based mechanism. They serve as the foundation for building amazing user experiences. With Solana's theoretical TPS speeds of up to 50,000/s, BetDEX Exchange can easily handle a large number of transactions with minimal delays and at a fraction of a cent per transaction.

Moreover, Solana's fully-audited protocol program eliminates counter-party risk, ensuring that user funds are secure and free from any potential loss.

Overall, using Solana's blockchain network for the BetDEX Exchange is a wise choice that ensures a seamless user experience, while also providing a high level of security and reliability.

So keep in mind that you're not dealing with a regular bookmaker the next time you place a wager on BetDEX. Instead, you're making use of cutting-edge technology that enables efficient, safe, and direct trading with other users.

BetDEX User Guide✨

Here is the step-by-step user guide to bet on Betdex 👇

Open Betdex.com to access their landing page. Then, click on the "Launch App" button.

2. If you are a new user, click on the "Join" button. Alternatively, log in directly if you have already registered.

Fill out all necessary details and click "Continue" to verify your email.

4. Verify your email with an OTP.

Select your preferred compatible wallet. In this case, I have chosen Phantom Wallet.

6. Provide your personal details such as name, username, and date of birth. Then, click on the "Continue" button.

Congratulations 🎉🎉!!

You have successfully registered on BetDex! Now, you can start your betting journey with BetDex.

How do decimal odds work?

Understanding Decimal Odds

In sports betting, odds can be presented in various formats. At BetDEX, they have opted to use decimals to express the odds or prices.

The decimal odds indicate the winnings one would receive for each $1 bet. Unlike other odds, the decimal number represents the entire payout rather than just the profit. This means that the stake is already included in the decimal figure, so there's no need to add it back in, simplifying the calculation of the total payout.

To calculate the potential return, you can use the following formula:

where: S is the Stake D is the Decimal Odds Tp is the Total Profit/Total Loss

So, with a stake of $10 and with odds of 12.5, the total return to the user would be $125.

The greater the odds, the higher the potential returns but also, the less likely the bet will be successful.

Relation between Decimal odd and Probability

Decimal odds can be easily converted into probabilities by using the following formula

                          1/D=P

where:

D is the decimal odd P is the probability

                        1 / 12.5 = 0.08

To express this as a percentage we can multiply the probability by 100: 0.08 * 100 = 8% In other words, at the current prices, Rajasthan Royals have an 8% chance of beating Royal Challengers Banglore.

To understand more about odds you can visit here or can even refer to this video 👇

Understanding 'Back' and 'Lay' Betting on BetDEX 📚

In sports betting, BetDEX offers two different types of bets: Backing and Laying. When you "Back" a team, you are placing a wager with the hopes of them winning. Conversely, "Laying" entails betting against something, such as your favourite team winning the championship.

At BetDEX, you have the option to do both while also being able to choose the odds at which you place your bet. This feature comes in handy if you believe your team will win, but the odds offered by other sportsbooks are too low. With BetDEX, you can select your preferred odds and wait for someone to accept your wager.

It's like having your own personal bookmaker since you have the power to establish your own markets and odds. As BetDEX is a betting exchange rather than a traditional sportsbook, you can bet against other individuals rather than a faceless company. You can buy and sell bets, much like buying and selling stocks, making it a market-based system.

The best part is that you have complete control over your bets and can change your mind at any time. This adds a level of engagement and competition that you won't find with conventional sportsbooks, making BetDEX a thrilling and innovative way to place sports bets.

BetDex's Current Sports Betting Markets 💹

BetDEX has made significant progress since its launch in November 2022. Initially, the platform offered betting markets for the English Premier League and the FIFA World Cup. However, since then, it has made tremendous strides by enhancing and diversifying its offerings, providing users with an extensive selection of sports betting options.

Presently, BetDEX provides markets for cricket, basketball, and football, with football enthusiasts having the luxury to select from a broad range of leagues, including the highly regarded Bundesliga, Series A, and English Premier League. Similarly, basketball fans can revel in betting on the NBA and NCAA basketball, making BetDEX a platform that caters to the interests of various sports lovers.

New Addition: Cricket 🏏

BetDEX has great news for cricket enthusiasts, as the platform now offers markets for the sport, beginning with the much-anticipated Indian Premier League (IPL). As one of the most-watched sporting events worldwide, with over 200 million TV viewers, the IPL is a platform for the world's top cricket players. BetDEX's inclusion of the IPL to its expanding range of markets is an excellent addition due to the sport's massive fan base and passion.

For IPL betting, BetDEX is the ideal betting platform, catering to the needs of cricket lovers.

BetDEX is continuously expanding its markets and has plans to offer sports bettors even more choices in the future. The platform intends to introduce markets for other sports, becoming the go-to choice for all sports betting enthusiasts.How to bet on BetDEX

Now let’s get into step-by-step how you can place your bet on BetDEX 🗒️

But, before placing your bet, you need to add SOL or USDT to your Phantom or any other wallet connected to BetDEX. Indian users can conveniently fund their wallets with USDT and SOL for transaction fees, enabling them to participate in the platform seamlessly. To do this, you can buy $SOL or $USDT on a crypto exchange like Binance and transfer it to your preferred wallet, such as Phantom.

If you don't have a crypto wallet yet, you can easily create one. Here's 👈 a complete guide on how to create a Phantom wallet.

How to launch the BetDEX app.

The connected wallet is displayed in the top right corner of the screen.
Choose the sport you want to bet on, such as football, basketball, or cricket. (In this case, I have chosen Cricket)
You will see all current and future matches available for betting.
Select the match you want to bet on. (In this example, we have chosen a match between Royal Challengers Bangalore and Rajasthan Royals.
The following interface will appear, allowing you to bet on either team by backing (in support) or laying (against) them.
Choose your preferred team to back or lay. In this case, we have decided to back the Rajasthan Royals.
The odds in blue represent backing the team will win), while the odds in red represent laying the team (will lose). You can choose your own odds at BetDEX and wait for someone to accept your wager.
Stake the amount you want to bet and choose the odds, then click "Place the order."
Approve the transaction from your wallet.
And done, your order will be placed.
You can see your active orders by clicking on the active order button.

Order Book

Orders at the top of the order book are unmatched back orders represented in pink. These orders require a lay order to be matched in order to become a trade.

Orders at the bottom of the order book are lay orders represented in blue. These orders require a back order to be matched in order to become a trade.

KYC and Isle of Man License

At BetDEX, a licensed betting exchange, customers are required to comply with KYC, which is short for "Know Your Customer." The main goal of this requirement is to minimize the risk of fraudulent activities, including money laundering and terrorist funding, that could occur in online betting.

To comply with KYC, customers must provide official identification documents, such as passports or driver's licenses, as well as their address information. In some cases, bank statements or other proof of wealth documentation may also be requested. BetDEX sets specific thresholds for KYC requirements.

BetDEX adheres to the following KYC levels based on your activity:

KYC Level 1 - A user has provided basic details, including name, DOB, and address (through Onfido).
KYC Level 2 - A user has proved their identity and address with documents (through Onfido).
KYC Level 3 - A user has proved their source of wealth with documents (through BetDEX).

BetDEX is licensed by the 🛡️ Isle of Man, which is a well-respected authority that regulates online gambling. This license allows BetDEX to operate legally in certain markets and ensures that the platform meets specific standards for providing a secure and reliable betting experience. By holding this license, BetDEX can offer users peace of mind and a sense of trust in the platform's legitimacy.

Competitive Landscape in the sports betting market.

BC.GAME

BC.game is an online gaming platform that offers casino games like slot machines, dice, and blackjack. Users can also place bets on sports events such as football, basketball, and tennis using various cryptocurrencies like Bitcoin and Ethereum.

The platform promises a transparent and fair gaming experience with provably fair mechanism. Users can also receive bonuses, promotions, and awards. However, users should exercise caution when using the website since it is not regulated by any official body. The platform's user experience and design may not be as polished.

bookmakers.xyz

Bookmaker.xyz is a decentralised betting site that uses the Azuro Protocol. Unlike traditional bookmakers, it does not place bets against customers or holds onto user cash. Instead, users' money is locked into predetermined blockchain smart contract outcomes.

It offers a variety of betting options without requiring users to create an account or go through document verification. The site runs on the Polygon (MATIC) and Gnosis Chain (xDAI) blockchain networks and offers weekly promotions.

Divy.bet

Divvy.bet is a decentralized betting protocol that lets anyone act as the house, share profits, and enjoy features such as guaranteed payouts, instant settlements, and compatibility with various wallets.

The platform operates through immutable smart contracts built on the blockchain for 100% anonymous and guaranteed betting, with no deposit requirements.

Dexsport

Dexsport is a decentralised betting system that lets everyone share a pool of liquidity. You can bet on sports, predict markets, do peer-to-peer betting, and collect NFT art.

The platform's decentralised structure means no one company dominates. However, some users may worry about security and regulatory compliance because KYC and ID verification are not required. The platform looks good, but there may be occasional latencies. Some users think the creators didn't pay enough attention to detail because the same response is given to different inquiries in the manual. Plus, one of the consultants has a questionable reputation.

Conclusion

Decentralized betting is the future of the betting industry, as it not only provides a seamless betting experience but also offers various benefits compared to traditional betting sites. Some of these advantages include low fees, no lock-up period, easy withdrawal, and many more.

With the help of Solana, BetDEX is one of the fastest and most cost-effective betting sites available today. You can easily bet on your favorite team and potentially win big. There is no limit to any kind of funds, and it has all the benefits of a decentralized betting protocol, such as low fees and easy withdrawals.

Moreover, the community of BetDEX is highly active and supportive. I personally had a great time interacting with other bettors on Discord. The community fosters a positive environment where individuals can discuss their betting strategies and learn from each other.

Overall, the future for BetDEX looks bright, and it is set to become one of the most prominent players in the betting industry. Its focus on decentralized betting and community building sets it apart from traditional betting sites.

Furthermore, currently, there is a contest going on in which you have no loss cover on your first bet up to $50 dollars. Additionally, there is another contest with a prize pool of $500, which you can check out on the website.

In conclusion, BetDEX offers an excellent platform for decentralized betting with its low fees, easy withdrawals, and active community. With its focus on innovation and customer satisfaction, it is poised to become a major player in the betting industry. So, if you want to experience the future of betting, head over to BetDEX today and join the community!

Acknowledgement:

This research about the BetDEX deep-dive has been conducted by Mani Bajpai and Grahil Khandelwal.

If you have any doubts/queries feel free to reach out to us over Twitter, Would love to connect!

References

https://www.betdex.com/
https://solana.com/
https://docs.monacoprotocol.xyz
https://betdex.gitbook.io/betdex-exchange/overview/welcome-to-the-betdex-exchange
https://betdex.zendesk.com/hc/en-gb/articles/10775080866449-What-is-an-order-book-
https://medium.com/@varun.sudhakar13
https://superteam.fun/bounties/betdex-deep-dive
https://www.researchandmarkets.com/reports/5450206/sports-betting-market-size-share-and-trends
https://twitter.com/BetDEXLabs

Push Protocol: A Validation of Fat App Thesis

pandatechie.sol — Sat, 20 May 2023 08:13:04 GMT

Facebook? Nope. I am more of a ‘Meta’ person. Rebranding is one of the oldest tricks in the book to signal a strategic shift in focus. For example, Dunkin Donuts changed to Dunkin’ to showcase that they’re equally good in other segments. But this one is NOT about food.

It is about a web3 protocol. Yes. EPNS or Ethereum Push Notification Service has evolved to Push Protocol.

What does this change signify though? More importantly, what is the future of this protocol given this change? How does it work and stands against its competitors? And finally, I would touch upon a debated theory I have been chasing for a while: Fat App Thesis and how this move by Push Protocol, just proves my point. But first, let me bring you onboard on what is (was) EPNS after all.

What is EPNS?

What is the one thing that drives you toward your phone? Something so inevitable that its absence might render a lot of apps plain useless? I am sure you would have been taking it for granted so far. Yes. It’s the notifications. The plain old on your phone that craves your attention.

A typical notification storm

Try to imagine your life without notifications. You post a photo on Instagram in a bid to get social validation (read likes).

What if you’d only know about it when you open the app? I am sure a lot of you would have been stuck on the app forever.

A more serious use case? What if you take a trade and your target price is hit? If there were no notifications, you’d probably never know!

From reminding you to drink water to driving your engagement, notifications have changed the world that we live in.

But as there’s a yin to a yang, these notifications are centralized. This means Apple or Android takes a call on what kind of notifications can be delivered to you. To top it all, they are purely a mobile play. Have you ever got notifications from a ‘desktop-only’ app?

When was the last time your Windows reminded you to restart for updates on your phone?

And the current state of web3 is hovering around laptops alone. There are little to no decentralized platforms that live on your cellphone.

Enter EPNS:

To solve this legitimate problem, we have EPNS. EPNS is a decentralized communication protocol for Web3! Using which any dApps, smart contracts, backends or protocols can send comm (starting with on-chain / off-chain / gasless notifs) tied to user wallet in an open, gasless, multichain and platform-agnostic fashion. The open comm layer allows any crypto wallet/frontend to tap into the network and get the comm across.

Too jargony? Think of EPNS as a one-stop application that ties the web2 mobile interface with the web3 decentralized world. Any dapp can now integrate with EPNS and send notifications to you on your phone via EPNS app so that you stay informed.

What’s worse than getting rekt? Not knowing that you got rekt!
- Yours Truly

What is Push Protocol then?

Now that explanation is out of the way, let us move to the new Avatar of EPNS aka Push Protocol. Why do brands change their name anyway? Well, it is often when they outgrow their previous proposition. And this is best defined by Push Protocol. The Push protocol stands out from the former EPNS in two ways:

A. Moving beyond Ethereum to other L1s and L2s

B. Moving beyond push notifications to other forms of communication.

Communication has always been the backbone of human evolution. We as a society have yearned for novel ways to connect with each other. Push protocol believes that this evolution will continue until the existence of mankind and they are preparing themselves to be ready for this.

Push protocol enables flexible and decentralized middleware that serves as a public good to solve the communication problem of web3 protocols.

Key Features of Push Protocol:

Yeah. We just discussed how EPNS has decided to go cross-chain. But what does it mean for the protocol and general audience? What features can you expect?

1. Cross-Chain:

Get it? Why isn’t it ETHEREUM push notification system anymore? This is because you can now expect Push Ecosystem to be leveraged by all Blockchains alike. Interested in getting price feeds from Mango Markets on Solana? Or wanted to know if there are any bids on your Rarible NFT on BSC? What about getting the best opportunities to yield from Yield Yak on Avalanche? You get the drift.

We are definitely heading towards a multi-chain universe and it is prudent for a protocol to cater to audience across the bandwagon.

2. Different Modes of Communication:

Ever transferred funds to the wrong address? While there is no guarantee of retrieving them, a fair opportunity to at least talk to the receiver might be a game changer. Currently, web3 has no user-friendly way of doing this.

So, with this shift, Push protocol should be able to add a lot more tools to enable communication in web3. This is not restricted to push notifications alone.

In fact, this version will encapsulate an entire stack of communication which will enable decentralized brands to interact with their users in ways that never existed before. Think chat, streaming and instant messaging etc.

Let us talk about each of these elements in detail:

2.1 Push Notification

Push Notifications directly connect applications to individual users, enabling secure and personalized communication in response to customized on- and off-chain activity.

We have talked about the key benefits of this use case above. Let us see it in action now.

Pre-requisites include the following:

- Metamask Wallet (I believe Phantom integration for Solana will be out shortly)

- Push Protocol application for iOS or Android.

If you are not aware of the process of setting up a Metamask wallet, this guide can help. Once you are done, do not take a break yet. To truly leverage the core functionality of push protocol, you need to install Metamask for your mobile as well. (Android or iOS).

Do not forget to set it up the exact same way you did for your browser.

With Push Protocol and Metamask installed on your phone, we are good to start.

Step 1:

Open the Push Protocol app to find a UI like this 👇

Let us quickly go through the three options mentioned here:

Wallet connect will allow you to connect with multiple wallets out there. Metamask being one of them.

Wallets supported in Wallet Connect (wen phantom?)

It is going to give you multiple options as shown above. Since we started off with installing Metamask, let us go with that for now.

On a side note, you can also login through push chat (more on it in the next section) and scanning your wallet address (which is the OG way of sharing your address). In either case, you would have to go through Metamask application to sign these transactions. Your efforts of setting up Metamask mobile didn't go to waste.

Step 2:

Once you have selected Metamask in the screen shown above, you will be switched to the Metamask app wherein you will sign a transaction. It should look something like this:

Signing Metamask Transaction for Connecting with Push Protocol

Step 3:

Viola. Give yourself a pat on the back. You have successfully connected the app with your wallet. All that is left now is to choose what notifications you would like to receive.

You can do this by browsing the 'channels' section as shown below:

Channels to subscribe on Push Protocol

You can always search for your favourite dApp from the search bar.

Once you pick a dApp and decide to opt-in for notifications, you need to sign a simple transaction and that is it. Now you can be well aware of getting rekt.

Sample Aave notification on Push Protocol

In my opinion, one should still use desktop to opt-in to their favourite channels through app.push.org. It is much faster and snappy through that route considering there will be multiple channels and hence multiple transactions that need to be signed.

2.2 Push Chat

Now that you have established a communication channel with the other side (web3). Why stop at information only? Why not talk to people in a similar pseudonymous fashion?

Enter Push Chat.

To enable push chat, you need to have an access to a desktop. That is where you will find the QR code this screen is asking for 👇

Link Push Chat with web.

Simply tap on the link push chat button and you will be asked to scan a QR code.

In parallel, head over to the chat section of app.push.org and tap on the link mobile app as shown in the image below 👇

Linking Mobile App

You will shown a QR code, scan it from the app and let the games begin.

QR code for linking mobile app

I tested it with two different wallets and the chat looks pretty smooth. Although the features are limited to chat and GIFs as of now, I am hoping this will improve in the future.

A sad conversation with myself

To avoid spam, the receiver needs to approve your chat request before you could slide into their DMs aimlessly. Pretty good eh?

2.3 Push Group Chat

And if we can have a 1-to-1 conversation, what stops us to have a many-to-many conversation right? The process of setting up a group chat is pretty simple.

You need a desktop to setup a group chat currently. Tapping on the 'new chat' icon on application only allows you to enter a single address only.

In the chat section on desktop, you will find a cute little button that says create a group 👇

After this, it is a pretty standard process of entering the group details and selecting the members. Once again, only the members who have accepted the request to join the group will be added.

WhatsApp was launched in 2009 and they introduced encryption in 2016. However push protocol gives users the ability to encrypt their conversation from day zero. The downside of encrypting the conversation is a that late comers will not be able to see the past conversations. Not a deal breaker right?

What did I miss?

Well, it is still early in the day in the crypto wild west but it seems like Push Protocol is slightly late to the party. Given the community built around dialect, a similar competitor, Push Protocol has some ground to cover.

Two key features that are missing right now from Push Protocol and killing it for Dialect are:

1. Actionables:

At best, Push Protocol is a read-only-ish kind of application. There is no interaction within the chat or notifications. This makes it a hyper-basic version of early days of messaging.

On the other hand, Dialect allows you to drive actions through messages like sending crypto to your peers.

Sending Crypto Via Dialect

At the same time, you could also take actions on your positions through dialect and not only 'learn' about them.

Changing bids via dialect notifications

2. Gamification:

This may be the law of diminishing marginal utility at play here.

From a novelty, NFTs are soon becoming a hygiene factor. Just like web2 had loyalty programs, NFTs are an evolved version of it.

Dialect recognized this early on and enable NFT stickers on the platform.

Push Chat on the other hand, feels vanilla right now!

Non-Fungible Stickers on Dialect

Fat App Thesis:

So what is happening in the industry? We are witnessing a trend play out yet again.

You see, the internet is built on protocols like SMTP, HTTPS etc. These protocols are a set of rules or standards on which apps like Facebook/Gmail are build. If you look closely, these protocols haven’t accrued much value for the investors. It is rather these apps which are extremely valuable.

They say that web3 or Blockchains can flip this completely. Why? Two main reasons:

A. Shared data

You cannot move your assets from Zerodha to Groww because both these apps work in siloes with their walled data sets. Same goes between Facebook and say Snapchat.

However, since Blockchain enables ownership, it is easy to move your assets between WazirX and CoinDCX.

Therefore, building on the same protocol (Blockchain) has its own merits and makes the protocol layer valuable.

B. Tokens

Conventional protocols were boring. Most of us didn’t even know that the web is running on them. However, web3 protocols have a native token attached to them. This gives them a speculatory significance. If more dApps are built on a protocol, higher the value of a network. Higher the value, it attracts even more dApps.

Therefore, the value of an app can never exceed that of a protocol.

Fat Protocol Theory Depiction (R) and Fat App Theory (L)

Now there are some contrarian views to this theory as well.

In fact, a bang opposite of this is called the fat app thesis where people believe that the application layer >>> the protocol layer.

Since Push Protocol now starts to go cross-chain, it is definitely an opportunity for them to generate more revenue, appreciate $PUSH and extract the most out of web3. Hence validating the belief that Fat App Thesis will have the final laugh.

Resources:

1. Push Protocol Website

2. Push Protocol Whitepaper

3. Push Protocol Features

4. Fat Protocol thesis

5. Dialect Deep Dive

A Comprehensive Deep Dive into Elusiv

Rohit Kumar Varma — Tue, 09 May 2023 06:00:41 GMT

As we go into the future, web3 transactions will be the mainstream medium to transfer money and any form of digital value. And this mainstream adoption of payments and transactions would be on chains like Solana, which enable almost instant transaction speeds, with decentralized, secure, and scalable solutions.

But all the public blockchains store this data in a public ledger that can be queried and indexed at any time. This creates a goldmine of publicly available transaction data and as it gets accumulated over time, there will be a massive boom in web3 social graphs to link and analyze the wallets with high-value transactions and eventually will pinpoint a wallet to an identity.

These social graphs and analyses of transactions can be easily queried on on-chain explorers, to understand how easy it is, let us take an example here. Search any public mainnet wallet address on Solana on an explorer-like Bitquery, this allows users to search the historical transaction data of any wallet with specialized filters like inflow, outflow, and list of all the transactions, as follows:

Representative image showing the Transaction Graph, Inflow, Outflow, and Transaction history of a wallet using Bitquery Explorer

This explorer also allows users to create transaction graphs by adjusting the depth of the graph to interact with all the wallets which are associated with a transaction and its corresponding public wallet, as seen in the above representative image.

Imagine Alice and Bob are neighbors, who purchase their daily essentials from the same supermarket down the lane, with crypto. And as they are neighbors they frequently share crypto with each other for regular transactions, this allows Alice to search for Bob’s supermarket purchase using Bob’s public wallet address, and Bob can do the same with Alice’s wallet address.

This breaks the privacy that web3 is promising to offer, they can create secondary wallets, but with tools like Explorers, one can easily query all the linked secondary wallets by tracing the transfer records!

This is where Elusiv comes in! Elusiv as a platform provides users with:

Encrypted Transactions
Fully Private Transactions
Gated Transactions where you can choose whom to share the transaction details with!
Decentralized compliance (Finally something with no KYC 😌)
Warden Network to protect users from transaction tracing!

And many more such features! These features bring the privacy that web3 users really deserve!

In this Deep Dive, let us start exploring the ins and outs of the technical design of Elusiv, before that let us understand why this technology is ground-breaking in consumer web3!

Deep Dive Overview

Privacy: Web2 vs Web3

Both web2 and the current version of web3 constitute their own set of privacy concerns, varying on factors taken into consideration. In this section let us begin with an analysis of the current privacy properties on web2 and web3.

To understand these properties let us take a classic financial example, a Bank statement. A bank statement is a historical collection of financial transactions associated with an account. This is analogous to public wallet transaction data in web3 terms.

Privacy in a web2 POV

In the web2 world, financial transactions go through intermediaries like Banks, to settle funds between the sender and receiver. In our example, when we consider a Bank Statement, it is the collective history of transactions done by the account holder, which include debiting or sending the money or crediting, receiving the money from another account holder.

But the point of discussion regarding this example is around the privacy properties of a Bank statement, and these logs of financial transactions are:

Centralized: Because these transactions can be accessed and have a probability of being tampered with by the central authority that controls the storage of these details, the Bank.
Private: Bank statements are generally private in nature, as they can be accessed only by the account holders and these logs are not readily available for public display, until the account holder decides to share.

These properties conclude a positive and a negative side of web2-based financial transactions. Although they are private and can be only accessed by the account holder, they are under the control of a central authority, thus making them unfavorable compared to what modern blockchain and web3 solutions have to offer.

Privacy in the current web3 POV

Coming to the web3 world, Blockchains are analogous to Banks, Wallets are analogous to Accounts, And explorer data as we saw with the Bitquery Explorer, are analogous to a Bank statement. So, when we explore the privacy properties of a web3 public wallet account’s explorer data, they are:

Decentralized: Firstly, the transaction data associated with a web3 public wallet address is decentralized, thus these records are stored on a decentralized network of systems, which constitute the blockchain itself. Thus these records cannot be tampered, with by any single entity, like a bank in the web2 scenario.
Pseudonymous: Blockchain data from public blockchains like Solana, and Ethereum, are inherently pseudonymous, this results in a public view of the transaction logs, but avoids pinpointing the user identity itself. But as we saw in the introduction, with modern explorers, better data mining algorithms, and as more data gets accumulated over time as web3 goes mainstream, this pseudonymity can be overcome by data analyzers leading to an easily predictable user identity linked to a wallet address.

But web3 needs a platform for users to be able to conduct private transactions, to avoid linking these transactions to a user’s identity.
This requires the best of the both web2 and current web3 scenario of transaction record handling, and Elusiv brings us just that!

Elusiv: Privacy Redefined

The above discussion points to the importance of privacy in regard to blockchain transactional data, and how Elusiv is bringing all the following required elements to this mix:

Elusiv is Decentralized: Elusiv does all the transactions on-chain via Solana, thus Elusiv doesn’t compromise on the decentralization that one of the most popular blockchains in the world provides, thus no one including the user can change the historical transaction logs, as they are permanently etched into the blockchain.
Elusiv Transactions are encrypted: All Elusiv transactions are encrypted with ground-breaking cryptography algorithms like ZKP (Zero Knowledge Proofs), and one-of-a-kind ZKP, zkSNARKS (sounds cool right)!
Elusiv Transactions are completely Private and Gated: All Elusiv transactions are private in nature, thus allowing only the sender and receiver to acknowledge the transaction while preventing anyone from tracing the tracks of the transaction to the associated wallets. Elusiv also provides a feature to enable gated privacy, where certain users can view the transaction details, based on the keys generated by the users who perform the transaction!

But, as every field does, there are pioneers in this space, and some spectacular crashes as well. Most of us have learned atomic models in chemistry, right? We went from J.J Thompson’s Plum Pudding model to the advanced Rutherford-Bhor Model of an atom, and there is an important thing to understand here:

“Every Mistake is a stepping stone to success”

So let us see what is one of the biggest mistake done by an early pioneer in this space and how Elusiv is not repeating the same mistake, instead setting the bar high for others to follow!

Lessons Learnt: Understanding the innovation, The Chemistry way!

One of the biggest names which come to a crypto-native’s mind when we discuss Private Transactions on Public Blockchains is: Tornado Cash

It introduced some ground-breaking technology built upon the base set by another amazing name in the field. Zcash’s open-source code. Tornado Cash took the crypto ecosystem by storm and became quite popular in no time! But the way in which it handled the compliance issues early on, lead to a massive breakdown of this decentralized Token mixer by the Federal agencies, which accused this platform of being a base for money laundering and a hideout for other digital crimes.

Tornado Cash Merits and Demerits

Tornado Cash is a decentralized, non-custodial, open-sourced Token mixer, to provide anonymity to users who transact with Ethereum or any ERC-20 tokens. This application was built to run on top of the networks supporting the Ethereum Virtual Machine. Tornado Cash provided absolute privacy, encryption and a decentralized transaction environment, similar to the ideal envisions of Elusiv, but they lacked any measures to prevent malicious actors from transacting on their platform with other normal users.

US Department of the Treasury's Office of Foreign Assets Control (OFAC) sanctioned Tornado Cash on August 08, 2022, for giving a chance for cybercrime organizations to transact via the platform and provide digital anonymity to these malicious actors.

Although Tornado Cash is an amazing tool for legitimate users to achieve financial privacy, it can be misused by politicians, hacking organizations and cybercrime blackmails to prevent getting caught by the OFAC and other federal agencies.

These factors allowed the bad actors to money launder approximately 7 billion USD on Tornado Cash since 2019.

So how can future privacy-preserving solutions like Elusiv, prevent bad actors from interacting with Regular users, and prevent any money laundering on a large scale as we saw in the case of Tornado Cash? Elusiv came up with a solution for this called, Decentralized Compliance.

Elusiv’s fundamental features

Decentralized Compliance is a set of compliance measures introduced by Elusiv to prevent and allow users to do the following:

Allow users to share the transaction details with absolute control over who can view the details, by assigning a key to each view. This allows them to prove these transactions to the authorities if needed.
A community-driven blocklist to prevent interactions with malicious actors is similar to spam prevention measures taken by Google and telecom companies.
Elusiv also allows users to share just the parts of the transaction that authorities or their associated tax firms need to see, nothing more, nothing less!
As shown in the above image now Elusiv can be called a full-fledged privacy layer on top of the blockchain with encrypted, private, and compliance-ensured privacy layer for the users. From the next section let us deep dive into the core working functionalities of Elusiv!

Elusiv into the act: Privacy Redefined

To sum up the discussion in the previous sections, Elusiv is a platform that envisions a fully private, encrypted, and decentralized layer to perform transactions on top of Blockchains, with end-to-end decentralized compliance for users and authorities to maintain the integrity of the platform. Elusiv wants to redefine the privacy layer of the future web3!

Team behind Elusiv

Elusiv was co-founded by 4 young entrepreneurs Yannik Schrade, Nicolas Schaperlere, Lukas Steiner, and Julian Deschler, envisioning to empower the next generation of privacy on Solana. Elusiv also got an honorable mention for their amazing work during the Solana Riptide Hackathon and also got a seed round funding of 3.5 Million Dollars, led by some of the biggest names in the Solana and Crypto industry. Currently, Elusiv runs on top of the Solana blockchain, and the team chose Solana for all the right reasons:

Solana is currently operating at the highest TPS (transactions per second) among all the blockchains out there, with an average mainnet TPS of over 4000, a True TPS of 400, and a practically proven theoretical maximum TPS of over 400k.
Solana operates at a sub-millisecond latency, which is the closest contemporary to the web2 real-time applications while maintaining decentralization.

These factors along with an ever-growing decentralization (Nakamoto coefficient of 34 being one the highest among L1s) and being the only L1 ecosystem with instant to real-time transaction speeds make Solana destined to be a mainstream user-loved ecosystem. And the need for privacy on this amazing chain is more than ever!

In the next section let us get started with the basics of ZKPs (Zero Knowledge Proofs) and zkSNARKS before diving into the intricacies of the technology behind Elusiv!

What are Zero Knowledge Proofs and zkSNARKs

Let us not go into the complex mathematical proofs of Zero Knowledge Proofs yet. Instead, Let us first try to understand this concept using a simple story with our all-time best frens Alice and Bob (yes they are back!) 🥳

Representative Image of Alice, Bob and the Map from the story

Once upon a time in China, there lived Alice a Local Guide, and Bob a Treasure hunter. They both set on an expedition to find an ancient treasure with lots of cold wallets holding hundreds of Bitcoin, sol, and eth (jff 😂), it was holding tons of gold and other valuable items. So after days of failed guidance under Alice, he wanted to know if she really know the location of the treasure that he knows. Or was she trying to mischief him and take the treasure all alone? So they decided to play a game to prove that:

Alice really knew the location of the treasure? or was she wasting Bob’s time??
Also, this needs to be done without Bob or Alice sharing the details about the location of the treasure.

So Bob the verifier who knows the location of the treasure drew a circle around the current location where both Alice and Bob are situated. And he asked Alice to say him the direction to the treasure’s location (it is marked in red, just for the explanation, it was not marked obviously during this experiment, lol !), but with a condition, just say him the route using these four sentences:

Go Straight
Go Left
Go Right
Go Back

This makes sure of three things:

Alice can use these sentences to pinpoint the route from the current location to the treasure.
At the same time, these sentences can mean to go in any direction North, South, East, and West.
The above point in turn ensures that Bob must know the location himself to verify the directions said by Alice.

Thus as Alice makes the route from the current location to the treasure location based on these sentences, Bob finds out that Alice is genuine and she knows the location of the treasure and verifies the same to her.

In this story, the way in which Alice proved that she knew the direction to the treasure to the verifier Bob, without either of them revealing the location they knew, is known as a Zero Knowledge Proof or a ZKP in cryptography.
They are two kinds of ZKPs, zkSNARKs and zkSTARKs. To be precise, both of them are two differenet implementations of the same concept.
zkSNARKS are ZKP implementations without the need for any user interaction.
zkSTARKS are ZKP implementations allowing the users in the scenario to interact.
Elusiv uses zkSNARKS because interactions involve back and forth proof and verification steps to complete the ZKP which makes it really costly to scale to a large number of users. Let us understand the implementation and use of zkSNARKS, in Elusiv’s technical architecture.

Technical Architecture of Elusiv

Let us understand the technical architecture of Elusiv in two different ways:

The Layman Way: Understanding Elusiv Shared Pool 😎

A High-level Overview of the Elusiv Pool

Elusiv uses the concept of a shared pool. A shared pool is basically like a “Mixture” of similar tokens sent by users across the Elusiv platform. From Figure 1 imagine Alice sent 36.5 tokens to the Elusiv pool, and 36.5 tokens went to the receiver in the name of the Elusiv pool, an outsider can easily understand that Alice is the one who sent the tokens, because she is the only one who sent the tokens to the pool.

But what if there are a large number of users contributing to Elusiv’s pool, with different amounts, different withdrawal amounts, and different withdrawal times, the complexity of guessing who sent to whom increases exponentially to a level that it is impossible to determine the sender and receiver’s associated wallet addresses.

The Nerdy Way 🤓

Elusiv’s ZKP working architecture

So a simplified technical foundation of the overall Elusiv encryption standard can be broken into three phases:

Deposit Phase: A phase where users deposit their funds to top up the Elusiv account balance privately.
Logic Phase: Where Elusiv Computes a hash based on the amount of user deposit, type of user deposit, and a secret value called nullified. A string is generated from the hash value of the above three parameters. This string is called a commitment. Once the logic phase is done the Nullifier is given to the user and recorded on-chain to prevent double-spending and make sure a commitment is valid only once.
Claim Phase: Where a user wants to use the balance in the account to send the money to another wallet address, they need to complete a ZKP to verify that they know the value of the Nullifier to complete the process, this allows the user to spend the commitment they’ve previously made by depositing the tokens.

What does Elusiv offer to empower Privacy?

An extensive list of features offered by Elusiv

In this section let us go through the extensive feature set being offered by Elusiv to empower the privacy layer of the web3 ecosystem.

Encrypted and Private Transactions

Image source: Elusiv’s homepage

Elusiv allows users to encrypt every step of the payment process to stay completely private and prevent any backtracking of payments processed via the Elusiv platform.

The first step of the payment process would be depositing funds into the wallet. Elusiv allows users to top up their private balance with SOL or any other SPL-Token, including the most popular USDC and USDT stablecoins. This allows users to maintain their wallets with stable sources of worth using the stablecoins on Solana.

The next step in the payment process would be the transaction itself, and Elusiv offers a completely private transaction experience, where the user transfers the tokens to the Elusiv pool as discussed in the technical architecture of Elusiv, and the Elusiv platform relays these tokens to the receiver, thus delinking the sender and receiver from the transaction details, thus preventing any backtracking or pinpointing of the identity of the sender or receiver of tokens.

And the final step in the payment process would be the ability to prove that the transaction happened correctly to someone selectively. This can be done by generating the required viewing keys and sharing them with authorized parties.

Gated Privacy

Users need privacy from the public and the community in general who can build data mining models to trace back the sender and receiver which risks the privacy of the transaction. But Elusiv provides a gated privacy model along with the standard complete privacy approach. This gated privacy model allows users to share the transaction details with a TTP (Trusted Third Party), and this gated privacy model consists of two important components:

Spending Key: This key is similar to the private key of your crypto wallet, one who controls the spending key can spend the assets topped up in your Elusiv account. Hence users must never share their spending key with someone.
Root Viewing Key: This is a read only key where users can share this key to other Trusted Third Parties like Tax agencies, and Authorities if asked. This gives them the access to read all the transaction details performed by a wallet on Elusiv.

Warden Network

Image source: Elusiv’s Website

Warden Network consists of units called “Wardens”, which patrol the network to maintain the integrity, compliance, and decentralization of the Elusiv platform.

Another key role the Warden network fulfills is that it relays the requests and responses between the Elusiv Client and the Blockchain, these requests and responses include user fund deposits, fund withdrawals, etc.

Also as we discussed the drawbacks of an application like Tornado Cash, and Warden Netowork prevents this, by blocking Malicious Actors thus preventing interactions between Bad actors and Regular users on the network.

Privacy 🤝 Compliance = Decentralized Compliance

Elusiv maintains the integrity of the platform by building a series of steps and measures to embrace Decentralized Compliance, rather than taking the easy way of embedding a KYC form for the users. KYC is a great way to verify users but it gives away too much about the user to the platform. Thus Decentralized Compliance is the perfect way to maintain the high privacy standards set by Elusiv. These measures include:

Gated Privacy and Viewing Keys for TTP: As discussed above these viewing keys allows users to verify their integrity in case any federal or tax authorities question them, by giving the viewer access to the transactions they performed.
Autonomous Protocol Analysis (APA) and Warden Network: APA is a background tool that runs on top of the Elusiv platform and the Warden network to prevent interactions between regular users and Malicious actors by constantly updating the community-driven blocklist of bad actors in the network.

DEV Delight: Elusiv Web3 SDK

Elusiv as a platform is trying to maintain the transparency of the application by embracing open-source standards. They made their Elusiv Typescript SDK open-sourced for developers to build on top of Elusiv’s amazing privacy layer. This allows other privacy focussed applications to make their presence in the web3 Ecosystem without reinventing the wheel of technology! Here’s a look at a simple use case of this amazing Typescript SDK:

Elusiv’s Typescript SDK

Yes, you guessed it right, Elusiv just didn’t stop there for the devs, they made their complete platform’s Source code, open-sourced, check that out, contribute, and build on top of it:

Elusiv’s Github

Elusiv VM’s

Elusiv VMs are an exciting piece of tech being built by the Elusiv team for the future, when released, it enables other services to integrate the privacy layer built by Elusiv into their applications with ease. This helps someone use these ZK-based privacy solutions in their applications without the knowledge of advanced cryptography.

Potential Use Cases of Elusiv’s Technology

Elusiv’s technology has a vast range of use cases with the currently implemented features and let us explore some of them in this section, to understand the impact of this project in the real-time web3 user experience and the way it empowers the ecosystem.

Elusiv acts as a universal encryption layer on web3 to encrypt transactions, as we know in web3 these transactions can range a wide array of use cases from financial or DeFi transactions to social network transactions on web3, gaming, etc, let us see some of the potential, untapped use cases of Elusiv’s generalized web3 encryption standard:

Financial Transactions: Elusiv’s technology can be used in regular on-chain transactions as we discussed all the way from the beginning, also it can be used to prevent eyes in the market to catch up on the movements of whales, to predict the market and thus making it unstable with a single user’s movement.
Anonymous Voting: Elusiv’s technology can be extended to DAOs to implement anonymous voting by encrypting each transaction in the polling process, thus eliminating the chance of influence of votes on others, leading to a fair polling process.
Legal Transactions: A zero-knowledge proof private transaction platform like Elusiv can be used to securely and anonymously conduct legal transactions such as property transfers, wills, and trusts. This would help to ensure privacy and security in the transfer of legal assets.
Gaming: Elusiv being a secure ZK-Privacy platform, can be used to securely and anonymously conduct transactions in online gaming. This would help to prevent fraud and ensure that players are treated fairly.
Identity Verification: Elusiv can be used to verify the identity of individuals without the need for sharing personal information. This would help to protect personal privacy while still ensuring security.

Integrations and Elusiv’s Competitive Landscape

Elusiv storming into the privacy layer scene of Solana recently made some good frens with some of the best developer communities and platforms out there:

Image Source: Elusiv’s Website

Monstre is a platform that recently integrated the Elusiv SDK into its platform. Being a payment platform that allows users to transact NFT gift cards, Elusiv is a perfect fit for users on Monstre to spend their gift cards privately.

Also, Elusiv partnered with Solana Pay to allow sharing tokens privately using the trusted Solana Pay on-chain payment standard.

Elusiv’s biggest competitor in the Solana ecosystem is Light Protocol, which is aiming to build on a similar vision, a ZK privacy layer on Solana.

Image Source: Light Protocol Website

But Elusiv is uniquely positioned in the space with some major advantages that other competitors are not focussing on or not cracked them yet, they are:
1. Decentralized compliance
2. SDK
3. SPL token support
4. Integration with the Solana Pay standard

These special features give Elusiv a headstart while the Solana ecosystem is going mainstream to bring more users to the web3 ecosystem in the near future!

Beginners guide on how to use Elusiv:

The first step would be to connect your favorite Solana wallet to top up your Elusiv account:

Image source: Elusiv App

Choose from the list of supported SPL tokens and fill in the sender’s wallet address to send the tokens:

Image Source: Elusiv’s App

Check out the Explorer tab to verify the history of your transactions.

Check out the compliance explorer to check the interactions of your transactions, and verify if they are not flagged or blocked by the APA and Elusiv’s warden network.

Image Source: Elusiv’s App

My Thoughts and Conclusion

Private transactions are going to be a big thing for web3 once the threshold of mainstream adoption is breached. And Elusiv is building the privacy infrastructure for future users to welcome them into the web3 ecosystem with all the required privacy-preserving features to maintain the integrity and standards of web3 ideals.

The best thing I loved about Elusiv is their ingenious solution on how they used the existing zkSNARKS technology to extend the idea to something so important to the web3 ecosystem, also the way they open-sourced the complete platform for the future developers is greatly commendable.

Thank you for giving this long technical deep dive a read. Hope I made it a fun and interesting experience for you all, if you liked the article give a like, share it with your friends, and give your feedback as a comment below!

💌

Regards,

Rohit Kumar Varma

Twitter

References:

Elusiv website: https://elusiv.io/

Elusiv Docs: https://docs.elusiv.io/

Elusiv’s App: https://app.elusiv.io/

Elusiv’s SDK: https://elusiv-privacy.github.io/elusiv-sdk/

Elusiv’s Github: https://github.com/elusiv-privacy

Elusiv Twitter: https://twitter.com/elusivprivacy

Light Protocol: https://www.lightprotocol.com

The State of Solana ReFi — A Deep Dive

Sitesh Kumar Sahoo — Fri, 21 Apr 2023 05:10:14 GMT

With global carbon markets surging to a record $851 billion in 2021 as per Refinitiv., it’s clear that carbon removal is on everyone’s minds. Big tech companies like Google, Facebook, and Stripe are leading the way with a $925 million plan to capture carbon pollution. But that’s just the beginning. ReFi is poised to revolutionize and expand the carbon market even further.

Join us as we delve deeper into the state of ReFi in Solana, exploring the key players and trends that shape the ecosystem. This essay offers a comprehensive overview of the Solana ReFi space, providing a deeper into the various projects. By understanding the unique offerings of Solana and comparing it to other ReFi ecosystems, we gain a better understanding of what more can be built in the space.

ReFi — The Intersection

Let’s first understand what ReFi is all about. ReFi, short for Regenerative Finance, is an experimental concept that incentivizes reducing carbon emissions, regenerating the environment, and ultimately reversing climate change. Think of it as the offspring of a marriage between Web3 and Sustainability. 👨‍👩‍👧

Have you ever stopped to think about the different systems that govern our world? There are those that extract resources without regard for the future, leading to eventual depletion and a decrease in overall capacity. Then there are those that are resilient, able to recover from shocks, and maintain stability over time. And of course, there are sustainable systems, in which resource availability remains steady and the system remains stable.

But there is one more type of system that goes beyond sustainability. It is the regenerative system, one that not only maintains stability but continues to grow over time. This is a system that is both durable and non-extractive, constantly replenishing its resources and allowing for long-term growth.

Image Source: CoinMarketCap

Why do we need Web3 or Blockchain here? The same reasons we need DeFi: Open, Transparent, and Composable!

DeFi allows for the creation of permissionless micro-markets, where anyone can launch a token and create their own market. Similarly, ReFi enables the creation of on-chain carbon markets, where companies can simply tokenize their carbon assets and start offsetting carbon immediately, without the need for any brokers and investment bankers. Not only that but also DAOs play a crucial role in ReFi, with the popular ones being ReFi DAO and KlimaDAO moving the ReFi movement forward.

Why ReFi?

Trackability: With traditional carbon offsetting, it’s hard to know if the purchased offsets are actually resulting in real carbon reductions. However, in ReFi with the help of blockchain, every transaction is recorded on the ledger, providing a level of transparency and trackability that is unmatched in traditional carbon markets.

Every time a carbon credit is created, it is assigned a unique identifier that is recorded on the blockchain. This identifier can be used to track the credit’s entire lifecycle, from creation to retirement. Additionally, the use of smart contracts ensures that the credits are used for their intended purpose and are retired once they have been used, preventing double-counting or fraud.
Markets Creation: DeFi allows for the creation of permissionless micro-markets, where anyone can launch a token and create their own market. Suppose you are launching your token; you can simply go to DEXs like Uniswap or Orca, list on these exchanges, add liquidity to the token pairs, and boom, you have created your own market, where thousands can trade your tokens! For example, Toucan Protocol enables tokenized carbon assets to be traded in its protocol.

We have mentioned the word Carbon Credits quite a few times in the last paragraphs, now it’s the time to understand what they really are…

Carbon Credits

Imagine that you and your friends are playing a game where you’re trying to collect as many stickers as possible. But there’s a catch — some of the stickers are worth more points than others, and there are only a limited number of high-value stickers available.

If one of your friends has a bunch of high-value stickers, they might be hesitant to use them all up for fear of running out. You really want to get more points, so you make a deal with your friend — you’ll trade them some of your lower-value stickers in exchange for some of their high-value stickers.

This is kind of like what carbon credits are. Companies that produce a lot of pollution, like carbon dioxide, are like the players trying to collect as many stickers as possible. But instead of points, they’re trying to reduce their carbon footprint. The high-value stickers are like carbon credits — they represent a certain amount of carbon reduction that a company can use to offset its own carbon emissions.

Just like in the sticker game, there are only a limited number of carbon credits available. Companies that want to keep polluting past their limit can buy carbon credits from other companies or organizations that have reduced their carbon emissions below their allocated limit. By purchasing these credits, the company can offset its own emissions and become more environmentally responsible.

The goal of carbon credits is to encourage companies to reduce their carbon footprint by creating a financial incentive to do so. Just like in the sticker game, where you might be willing to trade some of your lower-value stickers for high-value stickers, companies might try to find ways to reduce their carbon footprint in order to access more carbon credits and offset their own emissions.

Why would any institution look to tokenize its carbon credits?

Access to untapped liquidity: Tokenization allows institutions to access untapped liquidity from a vast network of global investors, DAOs, and treasuries looking for yield at a low cost.
Reduce operational costs: Tokenizing real-world assets and collateral on Solana can reduce underwriting and funds’ back office costs significantly. Because tokenization involves automating many of the traditional processes involved in issuing, tracking, and trading assets, institutions can reduce the time and resources required to manage their carbon credits. By leveraging the benefits of blockchain technology, such as smart contracts and automatic settlements, institutions can streamline their operations and reduce their operational costs.
Be future-ready: Be a leader in the revolution of an open, decentralized, and transparent carbon credit market with built-in secondary markets to enhance the liquidity of otherwise illiquid assets.

Why is Solana the perfect blockchain for ReFi?

Performant:
With competitively low fees (<$0.001) and high speed (65k TPS i.e. Transactions Per Second), and a 1–2 second confirmation time, Solana is one of the most performant blockchains with the best user experiences. For reference, the most popular centralized network, VISA, processes 60k trades per second, and Ethereum processes 15–30 TPS. High speed and low cost make it perfect for ReFi use cases. With the launch of a second validator client by Jump Crypto, Firedancer, the performance and reliability of the network will further increase significantly.
Vibrant NFT Ecosystem:
Solana is the second-largest ecosystem for NFTs doing ~14% of all sales volume, with more than 8 Million+ NFT wallets and 23 Million+ NFTs already being minted. Solana is the most technically prepared and battle-tested blockchain for the next wave of adoption, and the primitives needed for most NFT-Fi use cases have already been built. With account compression launching soon, the data storage cost will be reduced significantly, allowing large collections of NFTs to be minted cheaply. Compressed NFTs allow an issuer to mint 1 Million tokenized assets for ~5 SOL, which will be a game-changer for NFTs meant to represent carbon credits.

Solana with state compression compared with other networks (Image source: Solana)

3. DEXs:
DEXs on the Solana network have processed more than $55 Billion in volume, and Solana was the first blockchain to launch an on-chain native central limit orderbook. Openbook, along with the newly launched orderbook DEX, Phoenix by Ellipsis Labs, which can cater to specific use cases like high-frequency carbon markets trading. Further, Solana has one of the most reliable oracles with sub-second price updates like Pyth and Switchboard, which enables the publishing of real-world data.

4. Solana — The Carbon Neutral Chain:
Unlike other Proof-of-Work blockchains, Solana transactions are very efficient, one [non-voting] transaction on Solana uses an average of 3,290 joules, which is 43.78x lower than a transaction on Ethereum. and this makes the entire Solana network carbon-neutral. Solana Foundation is committed to keeping the network carbon neutral through the purchase of annual offsets and by providing the community with tools and resources to help lower their emissions.

Source: Solana.com/environment

5. Growing ReFi community:
While the ReFi community on Solana is still very nascent, but it’s growing fast. For a fact, in Breakpoint 2022, there was a ReFi-focussed meet-up which further sparked the interest in the community.

Now that we’ve delved into the basics of carbon credits and ReFi, let’s explore the incredible projects on Solana that aim to address climate change in diverse ways through their innovative solutions.

ReFi Projects on Solana

The ReFi ecosystem on Solana is still in its early stages but has shown immense potential for growth. Despite being relatively new, there are several ReFi projects on Solana that are quickly gaining traction and building innovative solutions. Let’s dive in…

Nature and Energy ⚡

Gainforest.earth:
GainForest is a platform that uses cutting-edge technology, including satellite imaging, drones, and machine learning, to verify and reward sustainable environment management. With their decentralized fund, they seek to transform donations into investments with impact NFTs by giving contributors a non-fungible and dynamic impact certificate (NFTrees) that gathers real-time data and records their impact over time.

It is powered by auditable internal machine learning that assesses environmental effects and offers nearby communities real-time compensation for their environmental stewardship initiatives. GainForest is multichain and funds are allocated to approved projects and given only when conservation goals are met. They are also working towards allowing anyone to contribute to their research and create transparent projects.

GainForest is a notable player in the ReFi crypto space, having executed numerous pilot projects across three continents and garnered recognition from esteemed organizations such as the World Economic Forum and the XPRIZE Rainforest competition. Their unwavering commitment to safeguarding and revitalizing the environment makes them a promising force to reckon with.

2. Coral Tribe:
The Coral Tribe community has played a vital role in the successful planting of over 1,550 corals, benefiting more than 4,500 individuals through various means such as education, scientific research, job creation, and diving. Coral Tribe is a Web3 impact investment platform that aims to make impact investing accessible to everyone through its NFTs. Through their impact investment initiatives, Coral Tribe has contributed to the growth of one of the biggest Web3 environmental brands globally. Recently Coral Tribe has also partnered with Solana Foundation to move the ReFi community forward which marks a big milestone for the entire community.

With a community of individuals who are passionate about art, technology, and environmental action, Coral Tribe has an expert council that carefully curates impact investments for the Tribe. Investors on the platform can invest in climate projects and receive a return, with a community fund available to match investments made and split profits with owners of Coral Tribe NFTs.

Source: Coral Tribe

3. Eco-Token:
The EcoToken is a utility token that aims to create an open and freely traded market for environmental credits. It serves as a starting point for sustainable projects and fills the financial gap for projects with a localized impact by rewarding people who provide the capital. The platform promotes local organizations seeking to improve the world and lets individuals pre-fund upcoming projects.

Water DAO, an offshoot of Eco-token, is working to address the major issues of resource management and water scarcity. It is based on the Solana and Regen Ledger blockchains and provides a verifiable water credit process that can be given to eligible projects, encouraging sustainable water resource management and rewarding clean water producers.

4. Powerledger:
Powerledger is a company that helps track, trace, and trade renewable energy. They promote a sustainable energy system by creating a trustless system for commercial transactions within the energy sector. Their technology enables households, organizations, and the grid itself to trade energy in real time, promoting a flexible power system. They have clients in 12 countries and have received global recognition for their technology, including winning Sir Richard Branson’s international Extreme Tech Challenge in 2018.

5. Single Earth:
Single Earth is an organization that encourages landowners to safeguard their forests and other natural resources in order to protect the environment. Using satellite data and machine learning, they assess ecological traits and work to safeguard the habitats of 270 species. Through their efforts, over 8 million hectares of forests are now growing and sequestering 130 million tons of CO₂ each year. They have also developed a virtual measurement unit called MERIT to symbolize the importance of environmental preservation, and the token also supports their nature preservation efforts.

Projects with Carbon Initiatives

Orca:
The leading AMM on Solana has committed 20% of fees earned by the treasury to organizations working to protect the environment via the Orca Climate Fund. It has already announced its first donation of $550k to Ocean Conservancy and worked closely with them to determine which of its current initiatives will benefit the most from the additional funds. Read more about the Orca climate fund.

2. Sunrise Stake:
It’s a ReFi staking protocol that directs staking yield to climate-positive projects and is one of the first ReFi projects on the Solana blockchain. It allows users to offset their carbon emissions or donate to regenerative impact projects by staking their SOL tokens. With Sunrise DAO, users can guide their funds to climate projects on Solana and beyond. Sunrise is a non-custodial solution, built on Marinade Finance's audited and trusted staking smart contract.

The yield earned by staking SOL tokens is sent to climate projects, as governed by the Sunrise DAO. Sunrise is on a mission to empower users to make a positive impact on the environment, with a roadmap that includes launching on mainnet, introducing green staking pools, governance, and gSOL integrations.

How Sunrise Stake works (Image modified from their website)

Sunrise Stake also won the Climate award in the Solana Grizzlython Hackathon making it a huge win for the ReFi community going forward!

3. Carbovalent:
Carbovalent (launching soon) is a blockchain infrastructure that aims to unlock scale for the voluntary carbon markets by reimagining carbon assets for a net-zero future. Carbovalent leverages Solana’s capabilities to achieve the Carbon Asset Life Cycle which unlocks ReFi applications of assets while impacting and incentivizing communities.

Carbovalent’s infrastructure works in this way:

Source: Initial screening and review of pre-bridge carbon credits by a Sourcing Standard made by Carbovalent.
Bridge: Migrate immobilized verified carbon credits to the Carbovalent on-chain registry using the Morpheus Carbon Bridge.
Track: The API-backed on-chain registry serves as a data oracle housing all bridged credits and their metadata returning project information and others metrics.
Trade: Buy, sell, and trade carbon assets and derivatives instantly via the Carbovalent DEX powered by the OpenBook.
Retire: Offset carbon by retiring credits on-chain.

4. Atlantis:
Atlantis is a peer-to-peer impact network that helps builders, entrepreneurs, and creators in the fields of environmental and social impact. Their objective is to create and create tools that assist these changemakers in setting up, assessing, and proving the effectiveness of their projects. Atlantis primarily focuses on NGOs, Impact DAOs, and companies in the social impact and climate tech sectors.

They enable climate founders, initiatives, and enterprises to establish a track record of social and environmental impact that can be independently verified. Atlantis believes that combating social injustice and climate change necessitates hyper-collaboration, and its platform intends to make it simpler and more profitable for communities and businesses to work together to create a more resilient and equitable future.

Hydrop is an initiative by Atlantis that decentralizes water access in Urban Bangalore. (Image source: Atlantis)

5. Arbon:
With the use of a computer vision-assisted oracle network to enable trustworthy measurement, reporting, and verification, the Arbon project aims to improve the global carbon market. Arbon’s network generates a value exchange between its carbon offset token and its parcel NFTs (COT). In order to undermine trust-based industries, starting with the $80 billion Forestry COs industry, the project merges Web3 and AI approaches. The platform employs automated consensus data validation and transparently logs outcomes on the blockchain to achieve ground-breaking innovation, including lower costs, more accurate data, and results that are accessible to all audiences, including retail customers.

Source: Arbon

Arbon has won the third prize in the DeFi track of the Grizzlython Hackathon. You can check out their deck to learn more.

6. Project Ark:
Project Ark was developed in collaboration with WWF Panda Labs. The platform provides customized services with the goal of developing carbon-neutral NFT collections, integrating impact, and establishing the necessary framework for the production and independent sale of NFTs.

The platform is made up of three primary parts:

GreenTech Labs — A set of tools and smart contracts to make it easier to create, own, transfer, and fractionalize NFTs. Project Ark collaborates with their team to co-create new NFT features, such as real-world data NFTs, dynamic generation NFTs, geographical NFTs, auditory acoustic NFTs, carbon-neutral NFTs, and others.
Studio — A one-stop shop for autonomously designing, marketing, and selling Green Impact NFTs. Project Ark assists companies, groups, and foundations in utilizing Web3 advances and promoting impact in the real world.
Their accelerator program makes use of its network and technologies to help excellent projects get their impact on NFT concepts off the ground. So that they may concentrate on changing the world, they select the best initiatives and ideas and offer them technical and marketing platforms.

Project Arc

Projects with Indirect Carbon Impact — Focused on Health 🧪

StepN: A web3 lifestyle app, has managed to shrink its users’ carbon footprint by ~12 million tonnes by incentivizing them to walk more. StepN is an innovative platform that encourages people to exercise outside by giving them NFT sneakers as the game currency. This can be spent in-game or exchanged for actual money.

Despite a significant drop in its monthly active users (now less than 100k), StepN reached a phenomenal peak of over 700,000 monthly active users in May 2022, demonstrating how technology can incentivize positive behavior and drive real-world impact on the environment.

STEPN has committed to donating $100,000 every month towards carbon removal in honor of Earth Day. The funds will be used to purchase Carbon Removal Credits on the blockchain through Nori, which helps connect carbon removal suppliers to environmentally conscious companies and individuals.
GenoPets:
Genopets is a mobile RPG (Role Playing Game) that rewards players for physical and mental exercise. By taking care of a digital avatar, players can transform their real-world movement and cognitive effort into in-game progression to upgrade and evolve their Genopet NFT. The game also allows players to customize their Genopet in their likeness, making it unique and valuable.
Biotrip:
BIOCASE, a Latin American biopharmaceutical company, had launched a new utility token called BIO TRIP. The token can only be used to purchase products from BIOCASE, which were aimed to help patients with mental disorders and serious psychiatric issues. Though currently, their twitter has been very inactive for a while showing no such activity on their website.

Digital Infrastructure 🌐

de_plan:
de_plan creates solutions for ReFi builders and products that bridge the gap between Web3 and IRL, enabling the development of apps on top of their infrastructure. Their goal is to enable local solutions to address local challenges, by creating products that bridge the gap between the online world and the physical world. By leveraging geospatial data and focusing on the hyperlocal level, they empower communities to shape their environments and tackle issues like climate change and urban development.
This cooperative of urbanists, environmentalists, and planners created Ostrom, a community-based approach to land regeneration, and Proto, an API for spatial data and proof-of-location. Proto also recently won 4th place in the Mobile track in the Solana Grizzlython Hackathon. A promising project bridging the Web3 and IRL gap on Solana which we love to see!
WiHi:
WiHi is a weather forecasting service that uses a decentralized approach. Instead of providing a direct solution to the weather problem, WiHi incentivizes collaboration to find a comprehensive solution. This involves improving data acquisition, weather modeling, nowcasting, and geographic representation. Here’s how it works: people can set up WiHi-enabled weather stations that send data to WiHi. In exchange for sending data, the stations receive WiHi tokens. The amount of tokens received is based on how much the forecast improves.
WiHi has partnered with weather station manufacturer Intellisense Systems and weather forecast provider Weather2Umbrella to improve weather forecasting using real-time data. They have also been performing scientific outreach and will present their scheme to improve W2U’s forecasts at the European Meteorological Society Annual Meeting in Bonn, Germany.

Read more about WiHi here in this presentation.

Now that we have explored some of the existing projects in the Solana ecosystem, let’s shift our focus to the future and explore what can be built on Solana. Here are some of the most promising ideas that we could think about while trying to build ReFi for good.

What can be built on Solana?

From carbon point tokenization to green bonds and better cities, Solana’s potential for innovation is vast. By tapping into its capabilities, we can not only make significant progress in addressing environmental challenges but also create innovative financial instruments that offer greater transparency, security, and efficiency.

Let’s delve into some of the most promising ideas…

Web2 → Web3:
Many Web2 applications already have carbon off-setting programs, where users are allocated “energy points” based on their carbon footprint. By tokenizing these existing carbon points and bringing them onto the blockchain, we can create a more efficient and transparent system for tracking and managing carbon offsets. This is a viable opportunity to tap into. Think of this as “Carbon Points Tokenization as a Service”
Greater transparency and cooperation in international carbon markets:
Market-based mechanisms, like carbon markets, have the potential to reduce emissions, but only if they are properly regulated. The absence of regulations poses a risk that carbon markets may not be effective and may even worsen the climate crisis by allowing companies to continue emitting carbon dioxide without taking concrete steps to reduce their emissions.

International cooperation is necessary for the success of carbon markets, especially in ensuring that emissions reductions in one country do not result in an increase in emissions in another. It is critical to have greater transparency in international carbon markets to ensure that emissions reductions are accurately measured and verified.

Carbon pricing, which involves putting a price on carbon emissions, can motivate companies to reduce their emissions. However, it is crucial to implement carbon pricing in a way that is fair and equitable, and that does not disproportionately affect low-income households or vulnerable communities.
NFT Badges: NFTs NFT badges to celebrate the highest energy point collectors. Further, brands can also leverage NFTs to raise funds for carbon offsetting via premium carbon credit NFT sales.
Carbon Native Assets: Solana is still missing a native carbon asset like what exists on other blockchains such as Celo. This gap represents an exciting opportunity for developers to create new carbon native assets on Solana.
Green Bonds: Green Bonds are a huge market where bonds are issued by an organization for the purpose of financing or refinancing projects that contribute positively to the environment and/or climate. Bringing green bonds on-chain is the most viable opportunity.

One example is Polygon x GreenRock Energy, GreenRock Energy, a reputed company in the energy space (photovoltaic systems), issued green bonds with a volume of $25 million with the help of a tokenization company, token forge.
Gitcoin-style grants for ReFi:
One potential approach to funding sustainability projects within the ReFi ecosystem is to adopt a Gitcoin-style grants model. Under this model, donation campaigns are launched where anyone can contribute, and donations are matched by a sponsor organization such as Orca Climate Fund. This would not only mobilize on-chain funds towards sustainability causes but also bring fiat capital into the crypto world as the platform gains more traction.

For instance, a Himalayan mountain conservation campaign could be launched on-chain, with all donations being transparently visible to the public, and matched by a climate foundation that was previously off-chain. By prioritizing transparency, this approach could help bring attention to sustainability efforts and promote greater public engagement.

To understand, how gitcoin-style grants work, check out our essay
Better cities: 🌆
A few years down the line, we might see a DAO coming together to raise funds in the form of an SPV (Special Purpose Vehicle) with a target of $10–100 Million. The basic idea would be to pick a barren land and convert that into a green city.

The city can be designed with high-end amenities, promoting sustainable living which is good for the environment and could generate significant returns through the increased value of the land. By combining tokenomics and powering everything via blockchain (payments, governance, financial services, etc.) — you get a better city on steroids!

One inspiring example of a self-sustainable township is Auroville, located in India. Auroville was founded with the objective of creating a universal town where people from different cultures and nationalities could live together in harmony. The township promotes sustainable living, with an emphasis on renewable energy and eco-friendly infrastructure.

The stuff of legends indeed!

Go-To-Market Strategies: How to get ReFi adoption on Solana

1. Tapping into the Web2 Giants

Be it a marketing gimmick or ESG requirements or part of their CSR activities or climate funds, almost every major company has budgets allocated to sustainability space. The ReFi projects on Solana or even Solana Foundation can simply target them as they don’t have high regulatory supervisions or high switching costs to move their operations to Web3, unlike payments or DeFi, where there are stricter regulatory regimes and requires a complete overhaul.

The best part is, once you tap into their climate/sustainability divisions, convincing these organizations to integrate Solana into their products and services would be much easier.

2. Partner with existing FinTechs in the sustainability space

For, e.g., SunFi is a fintech that operates in Lagos, Nigeria. SunFi is a mobile app that allows users to access clean energy products, such as solar panels and home battery storage systems, on a pay-as-you-go basis. This type of partnership could allow ReFi projects on Solana to offer financing solutions to SunFi’s users, creating a win-win scenario for both companies.

Patch: Patch is a platform that connects companies to vetted climate action projects across a range of technologies and geographies. This could help to increase awareness of Solana-based ReFi solutions and drive adoption among environmentally-conscious companies.

3. Bringing green bonds on-chain

Green Bonds are used to fund projects that have positive environmental or climate outcomes, such as renewable energy projects, clean transportation, or sustainable agriculture. Tokenized Green Bonds could offer an innovative and more transparent way of investing in green projects. They are more efficient to issue and trade and offer greater flexibility for investors. They can also provide an additional layer of security as the records are maintained on a blockchain.

Even Tokenized Green Bonds are being issued by governments; The Hong Kong Special Administrative Region Government has issued the world’s first tokenized green bond, which was distributed by a four-bank syndicate and settled on a private blockchain network using cash and securities tokens. (Read more about the HKSAR Government’s Inaugural Tokenised Green Bond Offering.)

Closing Thoughts

While ReFi is about the greater good of the world, the projects should also keep in mind — “financial sustainability” and be profit-oriented as well, instead of simply relying on grants/donations, which will be short-lived.

At the end of the day, these projects should transform into mature billion-dollar businesses with real revenues. That’s why it is crucial for ReFi projects to keep in mind the importance of financial sustainability and profitability while working towards the greater good of the world. By transforming into mature billion-dollar businesses with real revenues, these projects can make a significant impact and ensure their longevity.

ReFi: The intersection of people, profit, and planet! (Image source: Coral Tribe on medium)

The composable nature of tokenized carbon assets means that climate action can be embedded into other protocols and applications. This can unlock new use cases and demand channels, which can help support a robust financing ecosystem for environmental project development in the real world in the years to come…

Cheers for staying with us — are you excited about what’s next in Solana ReFi?!

Found it insightful? Share it with your friends! If you have any suggestions or want us to deep dive into your project, we would love to connect — Sitesh Sahoo and Yash Agarwal

References

A blueprint for scaling voluntary carbon markets (By Mckinsey)
The case for tokenized carbon (The Solana Podcast on YouTube)
Regenerative Finance (CoinMarketCap)
All the information and data about projects were taken from the respective projects’ docs or their websites with due credits. If we left something by mistake please reach out :)

Disclaimer: This essay is completely our personal perspective and thoughts on the Solana ReFi Ecosystem and is for educational purposes only. Given the comprehensive and informal nature of the essay, some amazing projects might have been missed or received lesser attention as compared to other projects. None of this is financial advice or any recommendation towards a particular project.

Deep Dive: Eclipse

Yash Agarwal — Mon, 06 Feb 2023 05:30:21 GMT

2022 was the year many ‘popular’ dApps announced to move from a general-purpose chain to an app-specific chain. It began with Defi Kingdoms, a popular game that saw $130 Million in daily volume and 400K daily transactions at peak, which decided to move from Harmony, a Layer 1, to have its own appchain on Avalanche subnet. Yuga labs also intended to move from Ethereum when its highly anticipated NFT sale faced scalability issues. The appchain market saw its breakthrough when one of the biggest decentralized derivatives exchanges on Ethereum announced that the next version would be built on its own appchain with its own set of validators using the Cosmos SDK. Think of dYdX as Binance of decentralized derivatives.

But why are they moving to their appchain?🧐

Let’s start with a simple analogy:
Assume chains like Ethereum to be very old buildings in the heart of the city, with pros like the lively neighborhoods (liquidity), access to shopping malls and transportation (composability), and cons of clunky old infra (congestion).

Someone like dYdX has been staying in this old building for a long time but is now doing well in life and wants to design their own house. They don’t have a very good social life (less composability), so they will obviously look to move to the city outskirts, where they can build their very own customized villa (appchain) as per their needs using a nice builder (Cosmos SDK).

Similarly, apps like dYdX also have a basic need — customization. dYdX, being a trading platform, is running with an orderbook model. To scale further, they needed more scalable systems, which wasn’t possible in their existing chain (Arbitrum) and required higher throughput, i.e., Transactions per Second (TPS). While they could have moved to more performant monolithic chains like Solana, however, they have a clear vision to bring a centralized exchange-like trading experience without comprising any decentralization. Hence they decided to have their own chain to maximize customizations while leveraging the composability and interoperability of Cosmos SDKs.

But what if dYdX had the option of leveraging the speed and low gas fees of Solana all to themselves while enjoying all the customizations they needed in their design of the orderbook experience?

Would they have opted? Probably, Yes! This article is primed to help you decide that.

The project we are diving into — exactly solves this problem, so that apps like dYdX can spin off their own modular chains while leveraging virtual Machines like Solana VM or Move VM. The article will also help you understand what appchains are, why someone will launch their own appchain, Eclipse competitor’s landscape, different appchains possible on eclipse, and many more.

Ready? Let’s go🚀

Before we begin with Eclipse, it’s important to understand the existing blockchain architectures and what are the different layers in brief.

Monolithic Blockchains and their drawbacks:

At the end of the 19th century, industries had processes set up such that a single worker used to work end-to-end on a product such as a car, but it was inefficient as one worker had to learn various skills, leading to lesser quality too. However, setting up “assembly lines,” i.e., breaking down manufacturing of goods into pre-defined sequences, brought up a paradigm shift. The time required to manufacture a car was reduced significantly as these processes ran parallel.

Similarly, blockchains like Ethereum and Solana are monolithic in nature, and they do everything from start to finish, like the creation of blocks, consensus and storage, and smart contract execution. What if we applied the same ‘assembly line’ technique here as well, i.e., break down blockchains into different modules? That’s just the modular blockchain!

Blockchains such as Bitcoin, Ethereum, and Solana have a monolithic structure and four primary functions:

Data availability
Consensus
Settlement
Execution

An illustrative representation of how Eclipse can fit into the Modular Blockchain story

As we see mass adoption coming up, transaction volumes will continue to increase, putting ever-higher pressure on validators. It can also lead to data-overload issues and throughput issues, particularly high-load periods like NFT mints, which are short but very demanding on blockchain throughput events. For instance, the Bored Ape Yacht Club NFT launch on Ethereum caused huge network congestion, which also led to Yuga Labs subsequently intending to migrate to its own high-throughput chain.

Rollups to the Rescue:

The Ethereum ecosystem has been focussing on Rollups as the way to solve these. It delivers speed by running a separate chain, saving only zipped archives of its transactions to an L1. Primarily, there are two types of rollups:

Optimistic rollups: They assume that all transactions are valid, and they can submit batches of transactions without any computation. However, they also feature a challenging period during which anyone could challenge the authenticity of the transaction batch.
Zk-rollups: They create cryptographic proofs, helping in proving transaction validity. Every transaction batch would feature their personal ‘validity proof,’ which must be submitted on the main chain.
Optimistic rollups have been here for a while, with projects like Arbitrum and Optimism running well for almost a year now, serving a huge chunk of users. zk-rollups are yet to be battle-tested. However, these rollups are weak as they aren’t upgradable and can only be upgraded by hard forking the L1, as they aren’t sovereign.

How zk rollups work

How Eclipse would work

Enter Eclipse: The Customisable Rollups on Solana VM

Eclipse is a unique project building the first Sealevel VM rollup, which will give a Rollup-as-a-Service with a customizable base layer. It will be an IBC-enabled rollup on Celestia, the data availability layer. Eclipse is simply a fork of Solana’s existing codebase, redesigned in the modular vision. The way it works is simple — instead of fitting all apps on the same chain, Eclipse lets you spin up your own modular rollup with the powerful Sealevel virtual machine. This allows anyone to run programs written for Solana, but Eclipse isn’t using Solana for security. The base layer instead can be customized as per the needs; it can be either CelestiaOrg, Polygon Avail, or Eigen Layer.

Eclipse provides a settlement layer, which acts as a bridging hub and a dispute resolution board for fraud-proof. This settlement layer is IBC-enabled, which allows anyone to pass IBC messages.

Representation of Eclipse layers by the team

But you might be wondering why they aren’t simply using EVM (Ethereum Virtual Machine) for this?🤔

Why start with Solana VM?

Simple answer — Speed! The Solana (Sealevel) virtual machine has a highly parallelized runtime compared to EVM chains such as Ethereum, where only a single program is running (single-threaded). The Solana VM has multiple cores, enabling it to run several programs simultaneously, substantially increasing throughput. The Execution layer is continuously improving as:

Seahorse Lang lets you write Solana VM programs in Python.
Soon, Solana VM will support Move, a rising programming language
Solana VM has successfully implemented a local fee market.

@solanalabs' VM team is building a Move compiler for Solana. \nYesterday, devs were able to compile and link Move code into a Solana VM binary. ","username":"fd_ripatel","name":"Richard Patel","profile_image_url":"","date":"Fri Jan 27 23:31:53 +0000 2023","photos":[{"img_url":"https://pbs.substack.com/media/FnhBbe2WAAAeSf2.jpg","link_url":"https://t.co/AwupcshIR6","alt_text":null}],"quoted_tweet":{},"reply_count":0,"retweet_count":38,"like_count":187,"impression_count":0,"expanded_url":{},"video_url":null,"belowTheFold":true}" data-component-name="Twitter2ToDOM">

The best part is they get a ready-made Solana developer community and supported token standards. Eclipse can also leverage Solana’s current TPS, which counts both voting and non-voting transactions, and make it all the TPS an actual TPS, which has no voting transactions.

Benefits of Solana VM

Although the Eclipse team is right now betting big on Solana VM, the plan is to support other VM as well. One of the most exciting ones is Move VM, used by shiny projects like Aptos and Sui, which can support high performance as well.

Okay, now we get Solana VM, but why are they being IBC-enabled?

IBC-enabled: Solving for Interoperability

Launched in April 2021, IBC or Inter-Blockchain Communication is the cosmos standard for blockchain interoperability, which enables independent blockchains to connect, transact, exchange tokens and other data, scale, and thrive in an interconnected network. This is similar to a cross-chain bridge, where you can communicate arbitrary data between arbitrary state machines, but much more decentralized than bridges.

By enabling IBC, Eclipse can make use of the IBC application layer to build a wide range of cross-chain applications, including but not limited to asset token transfers, interchain accounts (delegate calls between two chains), NFT transfers, and price oracle data feeds. IBC is already connected to 50+ cosmos appchains. Being IBC-enabled will help appchains on Eclipse to leverage the interoperability of the cosmos ecosystem as well.

Okay, enough of understanding the tech and architecture of Eclipse, let’s now dive deeper into “What’s possible”

Why would anyone launch using Eclipse?

The concept of launching an “appchain” will be more clear in later parts, but particularly, Eclipse has the following advantages:

Maximum customizability: Any dApp can adjust its block times, subsidize gas, or restrict who can use your blockchain.
Shared security: dApps don’t have to worry about managing infrastructure or bootstrapping validators because it borrows security from the underlying Layer 1.
Scale horizontally: This means that dApps can always spin up another execution layer, giving the power of Solana all to themselves.
Cheaper running costs: The data availability layer doesn’t need to support execution, and therefore the cost of running a node is cheaper, promoting decentralization.

User Experience: On-boarding and taking Appchain Cross-chain

Let’s suppose some Decentralised Exchange like dYdX, which plans to make its own appchain, comes and asks Eclipse Foundation on what the user experience could look like. Be it trading use-case or any other, a user shouldn’t feel like migrating to an appchain; the user experience should be superior.

Here are a few infrastructure pieces which the Eclipse Foundation should keep in mind for enabling the best user experience for appchains:

On-Ramps and Off-ramps: This is the most critical need for any first-time web3 user — how will they convert their fiat into crypto to use the dApp? While listing on exchanges like Binance or Coinbase can solve this problem, it isn’t easy for a new chain. Integrating solutions like Stripe, Moonpay, Wyre, and Kado can be another way to solve this problem. However, it all requires working with partners to make them support your chain and assets.
Gas fees: While some chains may launch their own token and accept that as gas fees to make transactions and few might accept more universal assets like USDC as gas fees. To enhance user experience, appchains can also make the entire chain gasless by either subsidizing gas fees for the user or just taking in-app transaction fees, which also include gas fees.
Wallets: One of the reasons why many dApps choose to launch on EVM-compatible chains is that the network can be added to a popular wallet like Metamask and be used by the user. To ensure an optimal user experience, Eclipse appchain can either create its own wallet, if it’s geared towards first-time web3 users, or integrate with existing popular wallets like Phantom. The UX should be similar to switching between networks in metamask, where a user will select the eclipse network.
Cross-chain Bridges: This is the most critical piece for any dApp, which is primarily targeting crypto-native users. If, let’s say, your user is using Solana, they should easily bridge an asset from Solana to your chain. Beyond assets, bridges can also be used to send arbitrary messages to and from the appchain. For instance, someone can stake their collateral assets on Ethereum and borrow assets from the appchain, and the appchain needs to make sure the messages are passed securely from the source chain. Integrating with existing bridge solutions like Nomad, Axelar, and LayerZero will be the smoothest way to achieve bridging to ensure maximum coverage of target chains.

Interestingly, Eclipse is integrating Hyperlane, which is relatively a newer bridge as the messaging infra.
@thepavantej @mryalamanchi @solana @EclipseFND Thanks for the tag, yep we're integrating @Hyperlane_xyz with the Solana VM","username":"neelsalami","name":"neel","profile_image_url":"","date":"Sun Jan 29 17:21:49 +0000 2023","photos":[],"quoted_tweet":{},"reply_count":0,"retweet_count":0,"like_count":3,"impression_count":0,"expanded_url":{},"video_url":null,"belowTheFold":true}" data-component-name="Twitter2ToDOM">
Base asset: Just like Ethereum has ETH, Solana has SOL, and all chains have a native asset that is independent of any external entity and is native to the chain. For an appchain, this will be a critical challenge as having a wrapped asset pose many external risks. To understand this, Polygon, one of the fastest-growing chains, still doesn’t have a native USDC! The USDC that’s being used on Polygon is just the wrapped version of USDC by Polygon PoS bridge. This means this isn’t the official USDC, and Circle has no liability to ensure redemption of them.

While these are major nuances, there can be others as well, like blockexplorer, exchange of assets, and much more. It’s necessary for the Eclipse Foundation to provide these appchains with ready-to-integration solutions of these or partner with relevant bridges, wallets, and on/off-ramps to ensure smooth integration with each appchain.

Few recommendations for Eclipse to build:

To build an ecosystem around Eclipse, the foundation can build several projects to catalyze faster deployments:

Easy-to-use, low-code framework: This will attract numerous Web2 enterprises to spin off their own application-dedicated execution layers that remain highly customizable. This can be achieved via an intuitive dashboard, which any company can use to customize its blockchain and deploy via simple clicks or minimal coding.
Embedded Orderbook integrated into the settlement hub for concentrated and easy liquidity access for the applications.

Use-cases: Applications possible on Eclipse

Just like any dApps, application-specific rollups can be of any type, be it, gaming, DeFi, or payments. Recently, Zebec, which is one of the biggest multi-sig and token streaming platforms on Solana, also announced that they would be launching their own app chain using Eclipse’s modular rollups.

The way, Zebec will work is as follows:

It will be a payment chain capable of verifying the user’s payment information, authorizing transactions, transferring funds between accounts, updating account balances, etc.
The eclipse will power its rollout to the Cosmos network as well, where the payment chain can be used for payment streaming, trading of real-world assets (RWAs), and real-time messaging, among other things.

But why would Zebec make its own chain using Eclipse?

Payment is a use-case that requires high throughput to process more transactions than Visa; deploying their own roll-up gives them a much higher transaction per second and also allows other dApps to build on them by deploying their own roll-up. Another reason is interoperability, as the modular chain setup will allow it to tap into numerous ecosystems.

Yama Finance, an omnichannel stablecoin, has also announced that they will launch on eclipse.

Payment is one such use case. There can be numerous other applications that can be built using Eclipse, but not limited to:

DeFi:

Each DeFi on Solana can potentially be its own appchain. Let’s understand this with an example: Serum, which was built by FTX, was the backbone of Solana DeFi, as many DeFi protocols used Serum’s central limit orderbook (CLOB) to tap into aggregate liquidity and match their trades. After the FTX collapse, it was forked by the community, and now everyone has pointed out limitations on them, which also included relying on Solana’s execution layer. A simple solution can be to move to Eclipse, where the orderbook can be customized further per DeFi community needs while also leveraging the speed of Solana.

Sei, which is a cosmos-based appchain, has already done somewhat similar, where they have a native orderbook for their blockchains, allowing other DeFi apps to build on.

Building a Binance-like Decentralised Exchange: After the FTX crash, Decentralised Exchanges have been hot, but they have very limited features as compared to a centralized exchange like Binance. A promising idea can be to spin off a DEX-chain on Solana, just like dYdX, which offers all advanced features. The best part is the users can not just have complete proof of reserves/assets but also proof of liabilities, as everything is on-chain and completely non-custodial. To enable KYC for on-ramps and off-ramps, they can also turn on permissioned rollups, which only allow verified users to use the DEX. dApps such as Drift can potentially spin off their own appchain.

@buffalu__ Build a full featured cex as a dex on solana","username":"aeyakovenko","name":"toly 🇺🇸","profile_image_url":"","date":"Thu Dec 15 04:29:21 +0000 2022","photos":[],"quoted_tweet":{},"reply_count":0,"retweet_count":63,"like_count":656,"impression_count":0,"expanded_url":{},"video_url":null,"belowTheFold":true}" data-component-name="Twitter2ToDOM">

Oracles:

Pyth is one of the top oracle providers, currently deployed on Solana, which provides 80+ price feeds by aggregating data from over 65+ data providers, resulting in over 700 price update operations per second. They have been occupying more than 10% of Solana’s transactions. Hence, to scale further, they will soon be launching their own chain using Solana’s codebase, which will essentially give all of Solana’s TPS to themselves. But it wouldn’t be easy to implement completely on their own. Here, Pyth can potentially use eclipse to spin off their own roll-up and achieve all customizations they need.

Gaming:

At the beginning of 2022, every big game explored moving to their own appchain as they have high requirements for throughput and finality. An example can be: StepN, a Web3 running app, is one of the biggest dApp on Solana, which single-handedly caused Solana’s activity to rise, and was seeing ~500K monthly active users. They can potentially be an Eclipse appchain with all the Solana TPS for themselves.

Web2 Enterprises:

Hate or love it; big Web2 giants love to have their own customizations to enhance user experience and retain control. We all know how crucial it is to attract Web2 giants as they can enable the mass adoption at a much faster pace. One of the value propositions for them can be to roll out their own sovereign chain using Eclipse. For instance, if banks like JP Morgan want to launch their own array of currency-based stablecoins, they can spin off their own chain and build their ecosystem of applications. They don’t have to worry about infrastructure and can work on power use cases like remittances, synthetic real-world assets, and more. Another reason for enterprises launching their tokens can be to avoid regulatory hurdles of launching their tokens and just paying the base layer for the data.

The case for Permissioned Appchains: CBDC

Permissionless is one of the core ethos of Web3, but not everyone prefers permissionless, particularly central banks and financial institutions, as they would want only verified individuals to enter.

Let’s say a Central bank wants to launch its own Central Bank Digital Currency (CBDC) on a public blockchain to have transparency but also wants to have full control as it can’t afford anyone to manipulate its national currency. They would want to leverage existing Virtual machines like Solana VM while having customizability like:

On-chain KYC for ensuring only citizens of the country hold the CBDC
Freezing of CBDCs in the case of terrorist financing or monitoring and limiting the activity of suspicious individuals, or withdrawing CBDC from a wallet in case of a hack or wallet compromise
Allows banks and financial institutions to become the set of permissioned validators, which ensures decentralization

All these controls would be very difficult to be deployed on a monolithic blockchain, and hence spinning off their rollups using Eclipse would be an ideal solution.

Bringing Real-World Assets (RWA) on-chain is another interesting application for permissioned chains, where institutions can launch their own permissioned chain for issuing securities, bringing additional controls and compliance. For instance, Intain is launching Asset-Backed Securities on-chain as Avalanche Subnet.

Competitive Landscape: First Mover Advantage

With a great market opportunity comes great competition as well. While many ecosystems have been developing their own appchain module, the most famous being the Cosmos SDKs, which has advocated appchains since 2016. But, Eclipse is uniquely positioned; let’s see why by first looking at the competitors:

Appchain Enablers: These ecosystems aren’t necessarily modular in nature but are offered by well-established ecosystems like Cosmos, Avalanche, and Polkadot. They have been very well advocating the appchain thesis, with many popular dApps already deploying on their appchains or intended to deploy.
SVM Compatible: There is another interesting project called Nitro which is building “Solana VM for Cosmos ecosystem”. It can be thought of as an L2 for the cosmos, which will enable any Solana project to launch on Cosmos easily. Just like Avalanche and BNB is EVM compatible, it will bring SVM compatibility to Cosmos instantly access the broader IBC ecosystem. Apps built on Nitro can leverage the SVM for high performance while gaining interoperability native to IBC. It also has eclipse-like rollups on its roadmap.
Having the first-mover advantage will be crucial to attracting Solana-based projects. However, the bigger game lies in tapping into Web2 Enterprises and bringing dApps from other ecosystems, and becoming the first choice for a new project.
Modular Rollups: There are a good number of projects building on modular blockchains theme, but most of them are still not in the mainnet and are either building or have deployed their devnet/testnet. A few interesting ones are:

Dymension: This enables anyone to launch their consensus-free blockchain ie. “RollApps” are connected to the mainchain via Dymension Hub, just like Cosmos. It utilizes Cosmwasm VM, where RollApp developers can choose DA (Data Availability) providers which are supported by the Dymension protocol according to their cost and security preferences.
Altlayer: This also enables anyone to launch their own rollups and supports multi-VM like EVM/WASM with low gas fees and fast transaction finality.

Although the appchain space is heating up lately though, I personally believe BD and Partnerships will play a very crucial role in attracting dApps. Leveraging a first-mover advantage to become the go-to choice for anyone launching their own chain will become the key to the eclipse foundation!

Backers and Partnerships:

Eclipse is still not out for any public testnet. However, they have started to be highly collaborative in nature, given their modular ethos. They have started partnering with relevant stakeholders like Saga to integrate their interchain security fee market to enable developers to deploy sequencers for Eclipse’s app-specific rollups easily. Interestingly, eclipse foundation has also participated in the $3 Million seed round of loyalty tooling, Kalder, which hints that it can be one of the early projects to launch on eclipse.

The founder, Neel Somani, has a strong background with work experience in Citadel, one of the most prestigious trading firms, and was previously developing a protocol, connecting the algorithmic Terra stablecoin with Ethereum, which would have allowed anyone to run EVM code on Terra. Although Terra’s crash left the project unfruitful, the concept of Eclipse was somewhat drawn from there.

The founder advisor, Sam Thapaliya, has previously built the streaming payments protocol Zebec on Solana. Zebec is a perfect use case for Eclipse architecture (one of the inspirations for building Zebec). To kickstart the project, it received a Solana Foundation grant for building optimistic rollups over Solana VM and connecting to IBC. It’s part of Celestia’s Modular Fellows program, along with other leading modular-themed players.

The $15 Million funding by one of the top investors like Polychain and Tribe, that too in a bear market, is definitely bullish for the project. They now have enough gunpowder not just to build a top-notch team but also to build a solid ecosystem of projects.

Roadmap: What’s on the horizon for 2023 and beyond

While there’s no official roadmap from the Eclipse team, however, let’s construct a rough roadmap from the team’s appearances in podcasts and what generally modular projects go through:

Testnet:

It’s expected to launch in Q1 2023, where they will be stress-testing Eclipse’s Tech by running various versions of Testnets. For instance, they can run three testnets specific to the use cases, as at the end, these blockchains will be application-specific:

DeFi Testnet: This can be used to test high throughputs majorly, and orderbooks are one of the perfect ways to test throughputs. Eclipse can launch a dYdX-like DEX, where a cohort of incentivized traders can connect their wallets and place orders.
Consumer Testnet: This can be either a gaming or social or NFT-based testnet. For example, they can launch a game-dedicated execution layer, and it can have an incentivized cohort of 300–500 gamers, where they play games for 2–3 days and test out if the testnet can handle 1,00,000+ transactions per day.
Physical Infrastructure Testnet: This is a unique case, which Eclipse is particularly focusing on, where wireless networks, like Helium, can launch their own chain.

Early access should be given priority to either unique use cases or big enough enterprises with ambitious plans via appchains.

Mainnet:

By the end of Q2 2023, Eclipse might look to launch their product and start getting existing chains on Solana and also attract Web2 enterprises to spin up their own chain. Initially, the eclipse will be looking to launch like optimism, where they run all of the nodes themselves to enable faster launch and sufficiently decentralize from there on.

Ecosystem:

At the end of the day, it’s all about adoption and how well not just existing Web3 dApps adopt Eclipse but also big Web2 giants like FinTechs, and Social Media launch on Eclipse. Business Development, Community, and Partnerships will play a crucial role.

Decentralization:

Initially, Eclipse might take the Optimism-style launch route, where they run all of the nodes themselves and don’t enable settlement. This way, anyone can immediately start using an Eclipse chain. However, the vision would be to decentralize and further build out our novel honest minority settlement layer. This also includes having a broad set of validators who can take part in the decentralization of any chain.

Will the next wave of appchains be powered by Eclipse?

The appchain is a compelling theme, and I am particularly bullish on them. This is definitely on my lookout theme for 2023. It’s all on Eclipse on how well they build an ecosystem around them. The risks are many, including liquidity risk, technology risk, and cross-chain bridging risks, but tackling these risks and building a trust-minimized system will be key.

The ultimate aim of Eclipse should be to catalyze the adoption of Web3 with scalability, security, and decentralization features with a focus on ease of integration, fast deployments, and user experience.

Feel free to hit me up on Twitter, would love to chat and help in any way. If you found this insighful, sharing always helps :)
Thanks Sitesh Kumar Sahoo for the wonderful cover image.🙂

Futher Reading and References:

Deep Dive: OpenBook

Yash Agarwal — Tue, 31 Jan 2023 08:48:04 GMT

FTX’s crash didn’t just vanish SBF’s $32 Billion but also shook the core of Solana DeFi. The Project Serum, which was used by numerous DeFi protocols was also at risk, potentially questioning the future of Solana DeFi. That’s when the community stepped up to save Solana DeFi and created OpenBook.

In this essay, we will first look at the story of how OpenBook came into existence, dive deeper into orderbooks along with OpenBook’s technical architecture, and lastly, dive into the spiciest part — the future potential of openbook along with recommendations. To not make it, just another ‘Forked Project Serum’ essay, we will not discuss Project Serum in much detail, but talk about the future potentials in greater depth to drive home some unique insights.

The Story: Death of Project Serum-Birth of Openbook

The story starts with the SBF’s ambitious vision to take DeFi to reach 1 Billion users and $10 Trillion of on-chain value. SBF described the vision as:

It’s what Web3 is supposed to be: an ecosystem the size of the internet… Serum is aiming really high. The goal is to get 10% of the entire world’s activity on-chain and composing on Serum. That includes 10% of financial activity, 10% of social media, 10% of payments, 10% of people, 10% of assets, etc. So a billion people and ten trillion dollars of assets.

With the launch of the Solana mainnet in early 2020, Solana demonstrated the high speed (64K TPS) and low gas fees (<$0.00001) to be possible for a Layer-1. FTX was a key investor in Solana and to release his vision, SBF decided to launch an on-chain orderbook called “Serum” on Solana.

Project Serum:

Launched on 31st October 2020, by Serum foundation, which was backed by a consortium including FTX, Alameda Research, and the Solana Foundation. It was the first major open-source project to build on Solana and was truly the centerpiece of attraction for Solana DeFi as it was heavily supported by FTX. With Solana DeFi summer kicking in 2021, Project Serum attracted more than $5.5 Billion in cumulative volume in just 9 months of its launch, regularly clocking more than $100 Million in daily volumes and more than 970 markets listed — the growth was simply insane in 2021. With the bear market kicking in, 2022 was a steady year with not many developments happening, until the darkest month of crypto: November 2022.

The FTX Crash: Death of Serum

By mid of November, FTX had collapsed and filed for bankruptcy on November 11 for the reasons, we all know. But a strange thing also happened, reportedly a hacker gained access to FTX and started moving funds. It sounds awful, but all of the private keys of Project Serum were housed within FTX, ugh! The Serum program update key was not controlled by the SRM DAO, but by a private key connected to FTX. This prompted all Solana DeFi projects like Raydium, and Jupiter to cut off ties with Serum as they had a fear that private keys can be used to update the program by the hacker, which have been compromised.

By November 13, everyone announced that they have cut ties with Project Serum and the work on a community-led fork was already on its way!

@ProjectSerum as a liquidity source a few hours ago due to security concerns about upgrade authorities, and we also encouraged all our integrators to do the same.\n\nThe ecosystem is working on a fork right now, and we will supporting it asap 🔥","username":"JupiterExchange","name":"Jupiter Aggregator 🪐","profile_image_url":"","date":"Sat Nov 12 20:10:35 +0000 2022","photos":[],"quoted_tweet":{},"reply_count":0,"retweet_count":70,"like_count":343,"impression_count":0,"expanded_url":{},"video_url":null,"belowTheFold":true}" data-component-name="Twitter2ToDOM">

The Birth of OpenBook: Power of Solana DeFi Community

In times of such a dire situation, the Solana DeFi community came together, and to safeguard this critical DeFi piece, developers and leaders from leading protocols joined hands to deploy OpenBook, a community-driven fork of Serum’s V3 program on November 15. The fork meant that all the Serum codes were exactly used, but all ties with FTX were cut. This demonstrated the true power of Open-source and what a strong community looks like. This allowed the community to have shared custody of Serum’s infrastructure and governance, and in a way, take over FTX’s control.

@openbookdex, the community fork of @ProjectSerum is working terrific and has been officially integrated into Jupiter 📖\n\nLiquidity from OpenBook will soon be included in Jupiter SDK/API for all integrators to leverage. ","username":"JupiterExchange","name":"Jupiter Aggregator 🪐","profile_image_url":"","date":"Fri Nov 18 14:12:15 +0000 2022","photos":[{"img_url":"https://pbs.substack.com/media/Fh2h8iaVIAIZE73.jpg","link_url":"https://t.co/hE7bGX3Sg1","alt_text":null}],"quoted_tweet":{},"reply_count":0,"retweet_count":86,"like_count":351,"impression_count":0,"expanded_url":{},"video_url":null,"belowTheFold":true}" data-component-name="Twitter2ToDOM">

Within just 5 days, it was integrated back into Jupiter and the other dApps followed — Speed, FTW!

Major Solana projects played crucial roles in the deployment and integration of OpenBook into Solana’s DeFi ecosystem. DEXs like Raydium and Solape shared liquidity with OpenBook. Jupiter Aggregator’s SDK/APIs integrated OpenBook’s liquidity and Switchboard-allowed price data. OpenSerum, created extensive dashboards covering the various markets utilizing OpenBook. Mango Markets announced that their V4 program will integrate OpenBook.

@ProjectSerum\n\nWith the collapse of Alameda and FTX, the Serum program on mainnet became defunct.\n\nAs upgrade authority is held by FTX, security is in jeopardy, leading to protocols like @JupiterExchange and @RaydiumProtocol moving away from Serum.","username":"ProjectSerum","name":"Serum","profile_image_url":"","date":"Tue Nov 29 05:31:09 +0000 2022","photos":[],"quoted_tweet":{},"reply_count":0,"retweet_count":72,"like_count":289,"impression_count":0,"expanded_url":{},"video_url":null,"belowTheFold":true}" data-component-name="Twitter2ToDOM">

To drive further adoption and develop trust, Serum’s public Twitter handle also openly endorsed the new fork i.e Openbook.

Now that we have learned how OpenBook came into existence, let’s now learn what exactly it does:

Central Limit Order Book (CLOB):

Orderbooks are not a new concept — US equity markets are mainly supported by orderbooks, processing daily volumes of ~$500 Billion. In an orderbook exchange like NYSE, buyers and sellers place bids and ask at specific prices (orders) and trades execute as those bids and asks match, and the price is updated to that particular bid-ask (Last Traded Price)

An on-chain Central Limit Orderbook and the matching engine allows for shared liquidity and price and time priority matching to traders and projects. Traders get to choose the price, size, and direction of their trades, while DeFi projects benefit from existing architecture, bootstrapped liquidity, and matching services.

AMMs vs Orderbook:

Compared to AMMs, orderbook offer better price discovery, as it’s an iterative process that involves the cancellation of multiple empty orders till the bid and asks match i.e the price is discovered.

While Orderbooks have the benefit over traditional AMMs due to tight quotes provided by traditional market makers, which leads to better pricing, the catch is: There should be enough liquidity with active market makers constantly updating their quotes. This isn’t possible for all assets since the number of assets traded on-chain is numerous (>100K). AMMs win on this as they support:

Long tail assets (Permissionless asset listing)
Anyone can create a market with Passive Liquidity

How OpenBook works:

In a trade cycle, the OpenBook program executes using the following steps:

Placing Orders: The user can place an order by including his order details (Market pair, Price, Size, Order type) in the order form. The OpenOrders account is created, if not present already. For buying, a user can fund it from their SPL wallet like Phantom. For a sell order, the amount is deducted from Openorders Account and moved to the SPL wallet.
Matching Orders: The process of matching involves removing requests from the Request Queue. The matching engine updates orders and records trades in the Events Queue. OpenBook is just like any other orderbook but for order matching it uses a process, known as crank turning. Anyone is allowed to run a cranker and be rewarded with a portion of transaction fees for it. All the orders are posted on the chain and the job of crankers is to ensure that they are being matched and executed properly. This entire process is automatic for the user and doesn’t involve any signing of the transaction as the program accounts for these accounts and signs automatically.
Consuming Events: In the Consume Events, the user account balances are adjusted in response to the events produced by the Matching Orders. For filling the orders, it updates the user’s account balances like decrementing the OpenOrders account’s total balance by the quantity paid. For Out events, it increments the OpenOrders account’s free balance by the quantity unlocked and removes the order from the OpenOrders account’s list.
Settlement and Cancelling Orders: The OpenOrders account balance can either be kept as it is or settled back to the user’s wallet.
Canceling an order has a similar trade cycle. To cancel an order, a user submits an order, which submits a request to the Request Queue and then processed by match orders. The order would be removed from the Orderbook, and an Out event would be added to the Event Queue to specify that the order has been canceled. The consume events would update all balances and the amount be made free for settlement.

All of the technical details of the step-by-step process are listed by the OpenBook team, would recommend reading it for a detailed understanding.

The Meat for Openbook Market Makers: Solving Liquidity Crunch

There can be essential three categories of asset pairs:

Category 1: Made up of stablecoin pairs like USDC-USDT which are nearly perfectly correlated by design. This is well-suited for AMMs since passive liquidity by retail LPs can also do the job of market-making, without requiring any advanced market makers.
Category 2: Made up of some of the most highly traded pairs like SOL-USDC and there happens active price discovery. This is where the opportunity for Orderbook Market Makers lies as price discovery is constantly needed, and an order-matching engine does a better job than LPs at AMM, which suffers from Impermanent Loss. This is where a majority chunk of the volume lies, allowing for a lucrative opportunity to tap by market makers.
Category 3: Long tail made up of the rest of the lesser-known assets. Active Market Makers in Orderbooks don’t find it profitable as there is a lot of uncertainty in their prices.
However, with the fall of the most active Market Maker, Alameda Research, Solana DeFi has been facing a liquidity crunch. Solana as an ecosystem actively needs more market makers, other than the current ones like Jump Crypto, Wintermute, and GSR. These market makers will help Openbook quote tighter prices and bring more liquidity to long tails assets and allow more synthetic/real-world assets on-chain. As they say, “Liquidity Begets Liquidity”.

The Trading User Interfaces:

While Openbook doesn’t have its own user interface, numerous DeFi projects like Solape, and Raydium have integrated Openbook, providing web-based GUI to trade, just like any Centralised Exchange. These trading dApps ask the user to connect to a wallet provider like Phantom, through which it asks the users to sign the transactions.

A few integrated UIs are:

Raydium: Raydium’s AMM integrates directly with Openbook’s CLOB to marry the best of two worlds by having AMM-style liquidity provision and CLOB-like deep liquidity and lower slippage.
Solape: It provides UI for swapping assets using OpenBook.
Prism: It’s another emerging DEX aggregator built on top of OpenBook to provide a CEX-like UX while retaining the self-custody of funds.

Fees: The Business Model

While Openbook doesn’t charge any fees at the moment, however, the fee is 4 bps (0.04%) which is split between UIs and Makers i.e each one takes 2 bps. However, if someone hosts their own UI or trades via SDKs, they can save on UI fees and will only pay 2 bps as the market-making fees. For stable pairs, the fee is 1 bps (0.01%) instead of 4 bps.

To ensure sustainability, OpenBook can also start charging fees in the near future, which can be deposited into the multi-sig governed by OpenBook governance. These can be used to incentivize Market Makers, drive DeFi integrations, and reward developers that drive open-book.

Max from Mango opened an interesting Pull Request, which proposes 3 Tiers: Base, Flagship, and Stable to incentive market making at all spectrum of asset pairs.

Should OpenBook launch a Token?

One of Project Serum’s features was its utility token $SRM, which granted a 50% discount on trading fees and governance to the holders. It also had another token, $MSRM which can be redeemed for 1,000,000 $SRM and increased fee discount to 60% and it was required to run a node. To increase the value of $SRM, a buyback-burn mechanism was deployed, where tokens are bought and burned equal to a percentage of platform fees. Everyone, including VCs, touted this as a “powerful mechanism” for value accrual to SRM and it did, but until the FTX crash.

Interestingly, FTX counted $5.4 Billion of SRM tokens in its reserves, as it had insanely high FDV (Fully Diluted Value) due to its poor tokenomics with not much real market cap. These SRM tokens still lie in FTX’s reserve, which will be liquidated, and hence, removing SRM tokens from OpenBook was a no-brainer decision.

The current version of OpenBook doesn’t have any tokens and doesn’t earn revenue. However, now the community has a larger question: “How will they sustain this project if there is no token?” Currently, Solana Foundation along with other DeFi projects is supporting the OpenBook development and is committed to supporting it as much as possible via grants and hackathons. However, Grants are limited and can’t sustain OpenBook forever. Sooner or Later, a sustainable source of revenue to incentivize maintenance and further development needs to be figured out.

An alternative can also be to have SOL itself as the token for Openbook, as it’s now a Solana public good. Solana would then be used to pay and accrue fees, however, this wouldn’t be the best approach to governance as SOL is the universal token, and not specific to OpenBook. Another suggestion was to have BONK, the memecoin as the fee token for OpenBook.

Many community members released their own proposals for potential OpenBook Tokenomics. Few interesting ones:

Soju’s proposal: It proposes a tiered-fee model with the excess fees generated to burn SOL, thus allowing value accrual.
Durden’s proposal: Launch the OpenBook token, OPB, and airdrop and keep buying it back and burn from the fees generated.
Dual Finance’s proposal: Launch OPB with SOL as a reserve asset

Overall, I feel that launching the OPB token can help grow OpenBook to be a more competitive CLOB DEX.

Community and Governance: Tight-Knitted

The upgrade authority for the Openbook program is held by a Realms DAO, with membership comprised of reputable figures from multiple Solana DeFi projects. There are 13 members such as Max and Adrian from Mango Markets, Sebastian from Solana Labs, and other pseudonymous members to control the multi-sig and take part in governance. It’s still centralized,

From the community point of view, the discord has ~350 members and the Social Media and community is moderated by Soju, who previously led Business Development at Solend. Interestingly, BONK, Solana’s own doge meme coin, has been the talk of the town for the past 2 weeks, for its astronomical run (rising 100x in a span of just 5 days). BONK has openly supported OpenBook and has allocated 15% of the supply to airdrop early OpenBook Traders. Further with BONK DAO’s grant program, developers in OpenBook can also be incentivized.

The fact that the Solana DeFi community came together in the hour of darkness to make Openbook happen is a testament to the strength and resilience of DeFi builders on Solana.

OpenBook Traction: The Numbers

Since its launch of the forked version in November 2022, OpenBook has been processing a daily volume of $3 Million to $6 Million, with TVL on a rising trend as can be seen from the chart. The number of transactions has been ranging from around 1 Million to 2 Million, with the peak being 4.4 Million transactions per day.

Data as of 15th January, 2023 | Source: https://solscan.io/amm/openbook

There are 1621 token pairs listed with the most active pairs by trading volume being SOL-USDC and mSOL-USDC with BONK-USDC being the rising star. While the numbers and traction are not that impressive at the moment, considering a restart, these are decent numbers, with a strong potential to regain daily volumes of $100 Million as more and more UIs get integrated.

Further activity can also be checked at the “Activity Dashboard” by Flipside Crypto.

Competitive Landscape: Getting Crowded

Project Serum paved the way for on-chain orderbooks by successfully attracting huge volumes, and it’s now not the only on-chain orderbook. Openbook now faces stiff competition from numerous types of players:

1. AMMs:

One interesting player to watch in the Solana AMM space would be Lifinity, which utilizes concentrated liquidity and a proactive market maker model using oracle prices, in order to remove reliance on external market makers, reduce Impermanent Loss (IL), and more.

2. Upcoming Orderbooks on Solana:

Ellipsis Labs, founded by an ex-Solana labs guy, is also building an orderbook for Solana called “Phoenix”, a crankless alternative to Openbook. It expands on the CLOB vision with a set of design decisions to improve efficiency like removing operationally-intensive cranking from the DEX design. With gigabrains working behind it and iterating over the orderbook design by incorporating learning from Project Serum — it’s definitely a solid project to look out for. By launching on Solana, it will directly compete with OpenBook’s liquidity.

Source: Talk at Solana Breakpoint

Other players to watch out for would be LayerN, which is building a Layer 2 on Solana and might enable its own native orderbooks, which would be compatible with existing Solana dApps.

3. Non-Solana Orderbooks:

While they aren’t direct competitors, they are certainly long-term competitors as users, institutions, and dApps would love to use the most efficient orderbook in the long run. Just like Solana, other high-performance chains like Near and Move VM family chains like Aptos, and Sui have started working on Orderbooks. Let’s look at some players:

dYdX: In the next version, dydx will have its own separate chain built using Cosmos SDKs, which will have an off-chain orderbook in which each validator will host a copy of the orderbook and match the orders, just like any validator proposes a block. dydx, being the leader in the space with a monthly volume of ~$30–50 Billion, is a must-watch.
NEAR-based Orderbooks: The Near is steadily becoming the orderbook chain, with the rise of orderbook DEXs like Tonic (1.3K+ users), Spin (9.1K unique users), and Orderly ($130M+ cumulative volume). To promote the development of a robust orderbook ecosystem on NEAR, it has also launched a $10M Orderbook Fund with all orderbooks launching perpetual in 2023.
Move VM-based Orderbooks: While there are many orderbooks being built on stealth, Econia has announced to launch of orderbooks for Aptos. With Sui and Aptos also being high performant chains, orderbooks on them will be an interesting watch. Ferum (‘S’ replaced with ‘F’) building on Aptos with similar architecture as Serum and the stellar team is also an interesting player to watch.
Sei: Pitching itself as a “Decentralised Nasdaq”, Sei is a trading-specific Layer 1 chain, which will have a native orderbook, built using Cosmos SDKs. It aims to have a finality of 600 ms, with market-based parallelization. It has already attracted a vibrant ecosystem of 50+ dApps building for use cases like spot trading, perpetual, prediction markets, and more.
An interesting thing to note here would be: Sei is also supporting the development of Nitro, which will enable Solana DeFi apps to launch on Sei. This can potentially lead to existing Solana dApps using Sei as the order matching engine, instead of Openbook if Sei manages to build a superior tech serving as a direct competitor!

As we can see, there is intense competition, but being a mammoth market, there can exist multiple players and competition shouldn’t be much of a worry, at least for the short term.

Let’s now move to the juicy part🧃

Road Ahead: Recommendations & Opportunities

While Openbook currently doesn’t have any solid roadmap due to the lack of a central team working on it full-time and the community is still discussing multiple aspects. To contribute to the community discussions, let’s explore the possibilities and why Openbook is still an exciting project:

1. Open Source and Public Goods:

Openbook is undoubtedly the biggest public good for Solana DeFi as its the backbone of many DeFi projects. With now DeFi community taking charge, Openbook can potentially lead the new wave of public goods on Solana by launching a grants program to encourage open-source contributions in Openbook. A potential way, developers can do open-source contributions can be Client-side tooling: Currently, Openbook has a JavaScript client library for interacting with the Openbook DEX. This JS client library can be further improved or just like Javascript, more languages can be added. Similarly, a significant improvement would be to go crankless which can be again an open-source contribution by an established DeFi team.

A Gitcoin-like platform would be perfect for such a case, where the DeFi community can contribute and the amount is matched by bigger DeFi protocols like Jupiter, Raydium along with Solana Foundation, or BONK DAO. Wireless Anon also proposes an open-source grants protocol for this purpose, which is also being discussed by the community.

2. Endless applications possible:

While spot markets i.e trading pairs like SOL/USDC, and SOL/USDT dominate on openbook, it has the potential to be a key primitive for other ecosystems, that might be collectively worth trillions. In fact, it’s an asset Agnostic order book for matching any Solana-based instrument from options, futures, borrow lending positions, or any financial and non-financial instrument that can take advantage of Openbook’s backend matching engine. To give an estimate, some use cases can be:

Tokenized Stocks: By tokenizing stocks like AAPL, and AMZN and enabling fast trading via OpenBook, we can potentially bring an NYSE-like structure to Solana. The key benefit of bringing it on-chain would be: increased accessibility as anyone around the world can trade these assets without relying on clunky international payments and long onboarding processes. Other synthetic assets like Bonds and commodities can also be traded via orderbooks.
GameFi: Decentralised Gaming presents a massive opportunity, and avid gamers are already familiar with buying/selling in-game items on third-party marketplaces, which are currently inefficient. Openbook here can be the missing link that can enable games to create in-game money markets where products such as in-game currency or items can be traded permissionless.
FX Markets: The Foreign Exchange Markets are huge — with a daily volume of ~$6 Trillion, even larger than stock markets. To solve international payments using Solana, it is also crucial to bring FX markets on-chain. Orderbooks can play a critical part by having local currency stablecoins pairs and allowing financial institutions to trade and add liquidity. CBDCs on Solana are another use case.
Traditional Lending: A money market can utilize OpenBook as its matching engine for borrowers and lenders.
Other applications like Prediction Markets, NFT Orderbook, Perpetuals, Interest Rate swaps,

3. EVM Compatibility:

Since OpenBook is fully built on Solana, it’s not EVM compatible restricting the EVM-based dApps to using Serum and thus, limiting liquidity to flow to and from. Once Neon Labs makes Solana EVM compatible and deploys its solution to allow Ethereum dApps to deploy on Solana, without re-building the whole application for Solana. We expect DeFi apps from Ethereum-based ecosystems to deploy on Solana, leveraging the high-speed Orderbook of OpenBook. This can potentially bring a lot of adoption and liquidity for OpenBook. An alternative route will be to make OpenBook cross-chain and either use cross-chain bridges like a wormhole or deploy on other fast chains like Ethereum-based L2s, Aptos, Sui, etc

4. OpenBook as a Separate Chain:

An idea worth exploring might be to spin off OpenBook as a chain of its own, just like Sei and dYdX. The best part will be, it can leverage the speed and low cost of Solana via SVM (Solana Virtual Machine), while achieving its own customizability. Check out my deep-dive on Eclipse to get a complete understanding of App chains on Solana.

Will OpenBook Thrive?

Despite FTX being a house of Ponzi, their contribution to the launch of Project Serum on Solana can’t be overlooked. The Launch of Project Serum was truly a defining moment, not just for Solana, but for the whole crypto ecosystem as it was one of the first on-chain orderbooks to have received traction.

Orderbooks are here to stay. AMMs are crypto-native novel innovation, but it was partly born out of the TPS constraints of Ethereum and with high TPS chains like Solana, NASDAQ on the blockchain is very much possible!

Credits: @M_Danger_Bick

Feel free to hit me up on Twitter, would love to chat and help in any way. It took me quite an effort to research and write — If you found this insightful, sharing always helps :)
Thanks, Sitesh Kumar Sahoo for the wonderful cover image.

Deep Dive: Lifinity

Adarsh Rao — Thu, 19 Jan 2023 13:39:38 GMT

If you've bought or sold a token on Solana in the past year, it's likely that you've already interacted with Lifinity.

Lifinity is a decentralised exchange (DEX) on Solana with a very unique take on AMMs. This is a deep-dive into its working where I will attempt to explain what they do, how they do it and why you should take notice.

The essay assumes minimal prior knowledge about crypto and I’ll try to build all understanding from the ground up with plenty of links sprinkled throughout.

What does Lifinity do?
But, what’s special about Lifinity?
- Protocol Owned Liquidity
- Usage of oracles
- Concentrating liquidity
- Rebalancing Mechanism
And how have these ideas played out?
Lifinity’s Tokenomics
Lifinity’s Governance Mechanism
The Road Ahead
Why you should care

What does Lifinity do?

Lifinity is a market maker. It creates and maintains trading pools for pairs of tokens. Other users can buy tokens from this pool or sell tokens to Lifinity, at the current market price for a small fee.

SOL-USDC is an example of a trading pool which allows users to purchase Sol with USDC or sell Sol for USDC.

Why is there a need for such pools

These type of pools form core DeFi infrastructure. They are sources of liquidity available 24 x 7, which are necessary for any healthy market and they act as reliable intermediaries between buyers and sellers.

In a world without such pools, if you wanted to sell your SOL for USDC. You would have had to wait until someone was ready to purchase the exact amount off you. But by then, the price might have moved. Instead with the availability of such pools, you can instantly sell your SOL to it at the current price and get USDC right away.

For providing this service and taking on the risk of holding these assets, these pools charge a fee.

The SOL-USDC pool pictured above charges a fee of 0.08% per $ of volume traded. So in the last 24 hours, it has earned 741,781*0.08% ~ $593 in trading fees.

Lifinity currently provides pools for 17 different combinations of tokens and has done over $2B in volume since inception.

Don’t trust, verify. Link to Solscan. Link to Defillama. Link to Lifinity.

If you’re already familiar with the concept of DEXs, nothing in the section above really stands out. You might be wondering —

But, what’s special about Lifinity?

So. Many. Things. But since your attention is precious, I will focus on 4 key innovations that set it apart.

Protocol Owned Liquidity to avoid needing LP deposits
Usage of oracles to reduce impermanent loss
Concentrating liquidity for higher capital efficiency
Rebalancing Mechanism for market-making profit

Protocol Owned Liquidity to avoid needing LP deposits

Traditionally, DEXs would only build out the the base program (smart contracts and a UI interface) for a trading pool and open it up to the public for deposits.

A trading pool is only as useful as the amount of trading volume it can facilitate and that is proportional to the amount of liquidity that users have deposited to the pool. Those who deposit to these pools are called Liquidity Providers (LPs).

DEXs began competing with each others to attract these LPs to their own DEX since their revenue comes from keeping a portion of the trading fees generated. The most common way to achieve this has been to offer token emissions as additional rewards for the LPs depositing.

This took the form —

Deposit your SOL and USDC into this pool to get ORCA/MNDE/RAY in addition to the trading fees you generate!

However, this was simply not sustainable.

This style of incentives resulted in mercenary-like behavior where Liquidity Providers would only offer liquidity as long as these token emissions lasted. As soon as the incentives ran out, they would move their liquidity to a pool on another DEX that offered better incentives.

Additionally, these LP providers would immediately sell the emissions they received on the market resulted in a consistent sell-pressure on the token being offered as an incentive.

This was obviously a problem but there were no solutions in sight.

Enter Lifinity.

Lifinity solved this problem by using fundraising as a way to own the liquidity that is provided to these pools. The term they use for this is POL, Protocol Owned Liquidity. This was genius because now Lifinity is no longer subject to the whims and fancies of mercenary LPs who might leave at any moment. And they also don’t need to hurt the price of their own token with token emissions. It was a one-time sale only. This has the added benefit of Lifinity being the sole provider of liquidity to its pools and earning 100% of the trading fees.

I’m leaving out a lot of detail there and you might rightly have many questions. How much did Lifinity raise? Why did people participate in the fundraise? What was Lifinity providing in lieu of token emissions? How does it all tie together?

They raised money for this protocol owned liquidity in two phases —

An NFT Collection called Lifinity Flares Raising $2.6M from a sale of 10,000 NFTs for 1.5 Sol each back in Dec 2021
An IDO for their token, LFNTY Raising $9.6M in Jul 2022

The liquidity raised from the NFT Collection is called FOL — Flare Owned Liquidity

The liquidity raised from the IDO is called POL — Protocol Owned Liquidity

But, why did people participate in this fundraise?

These fundraises were successful because of the unique revenue accrual mechanism and the fact that they were the only way to get exposure to Lifinity’s high APR pools.

For the NFT Collection, it was the perpetual buyback mechanism. The entire raise amount seeded liquidity for Lifinity’s original trading pools and 50% of the revenue that is generated, is used to purchase Flares off the market. In the last year, this has resulted in over 7% of the NFT supply being bought back creating a deflationary collection.

For the IDO, it was the promise of pereptual revenue share for holding the locked version of the token.

I’ll go into more depth on each above in a future section. But for now, lets try to understand how Lifinity extracts maximum value from the funds they raised.

Usage of oracles to reduce impermanent loss

The next key innovation was Lifinity’s usage of oracles to reduce impermanent loss. To help explain what oracles and impermanent loss are and how Lifinity uses them, I need to introduce the concept of AMMs.

Feel free to skip the following section if you already know what an AMM and its price-curve equation is.

What is an Automated Market Maker (AMM)?

AMMs are simply another name for the trading pools I mentioned at the very start of this deep-dive. They allow users to trade against the pool for a fee.

Original AMMs used x*y = k as the price-curve equation where x is amount of token A and y is amount of token B

The equation you see above is what the AMM uses to determine the price it is willing to offer for either of its assets.

Example

Let’s say a pool contains 100 $SOL and 1000 $USDC.

According to the price-curve equation,

Imagine you want to sell 1 SOL to this pool. After you have sold it to the pool, the pool will contain 101 Sol and some amount 1000 - p USDC where p is the money that the pool gave you for the 1 Sol you gave it.

According to the price curve equation, the product of this still has to remain constant

which gives us

Which means that the price the pool offered you for your 1 Sol was 9.9009 USDC

If instead you had sold the pool 0.1 sol it would’ve offered you price equivalent to 9.99001 USDC. I will leave this as an exercise for the reader.

In the interest of the length of this deep-dive, I’ve kept this explanation brief. If this intrigues you, please visit this article with more detailed exampels — https://research.paradigm.xyz/amm-price-impact

Takeaway

This equation is how AMMs encapsulate price. They only need the amounts of tokens available in the pool and don’t require any outside information to determine what price to offer.

This concept was revolutionary when introduced. Since their introduction in 2018, AMMs are now a core piece of infrastructure in DeFi because of their simplicity. Anybody can start a trading pool between two tokens that others can trade against to generate a price for the token. You no longer needed dedicated marketmakers.

Problems with traditional AMMs

Unfortunately, providing Liquidity to AMMs is not profitable in itself because of impermanent loss.

To understand what impermanent loss is, lets continue the example from above.

Imagine you were the liquidity provider who provided the initial 100 Sol and 1000 USDC for the pool to get started.

At 100 SOL and 1000 USDC in the pool, the implied price of SOL is 10 USDC/SOL
1. So you put in an equivalent sum of of 2000 USDC (100SOL*10USDC + 1000 USDC)
Lets say enough trades have happened that the now only 50 SOL is left in the pool. According to the price-curve equation, there should be 2000 USDC and the implied price of SOL is 40 SOL/USDC
1. The pool now contains 50 SOL (=2000 USDC) and 2000 USDC for a total of 4000 USDC

Your money is now worth 4000 USDC but if instead of providing liquidity, you had just held onto your SOL and USDC, you could’ve had 5000 USDC (100 Sol * 40 USDC+ 1000 USDC )

Do you see how providing liquidity is actually a bad deal for the liquidity provider? This is called impermanent loss (or divergent loss). And it’s equally applicable even when price decreases.

To learn more, check out this medium article or this one

To counteract this, AMMs charge fees. So that even if a lot of trading happens back and forth and the price ends up where it started, the pool will have accrued fees from all the trading.

In practice, outside of a few popular pools with a lot of trading volume, the fees generated simply do not result in enough APR for liquidity providers to justify providing liquidity.

This results in an increase of fees until the pools can attract liquidity but at that point, users are better off just using a Centralised Exchange with lower fees.

Enter Lifinity.

Lifinity’s key insight was the usage of oracles to reduce impermanent loss

An oracle tells you the price of an asset at a given time. Whenever a trade is routed through lifinity, it fetches the price from the oracle at that point in time and uses that as the price-to-offer-the-trade at as compared to a CPMM which would use pool’s quantities to determine the price of the trade.

Why is this better?

For tokens with high trading volumes like SOL, BTC, ETH, the price discovery does not happen on AMMs. It happens off-chain on centralised exchanges like Binance.

What this implies is that the price-encapsulating nature of AMMs is actually a negative.

Following up on the original example, lets say the pool contained 100 SOL and 1000 USDC implying a price of 10 USDC/SOL

But lets say that the price shot up to 20 USDC/SOL on a centralised exchange, the AMM pool is actually STILL offering the price of 10 USDC/Sol and waiting for someone to come in and arbitrage the difference to move it up.

The arbitrageur is happy but as the AMM, you’re not.

On Solana, Pyth publishes the price of a token on every slot. Lifinity’s pool use this price as the one they are willing to offer to anybody selling/buying tokens from it. This means that Lifinity’s pool could still contain 100 SOL and 1000 USDC but it would be offering a price of $20 USDC/Sol instead.

This has the effect of reducing or even negating impermanent loss making providing liquidity to Lifinity’s pools actually profitable.

Concentrating Liquidity for higher capital efficiency

Another issue with traditional AMMs is high price slippage. Meaning that when you trade large sizes against an AMM, you move the price by a lot because of the price-curve equation. To move the price less, the pool needs to have a lot of liquidity but remember, providing liquidity is not inherently profitable and therefore is a hard sell.

Traditionally, the larger your TVL (total value locked/liquidity in your pool), the more volume you get because you offer better prices.

Lifinity gets around this by concentrating liquidity around the current price by modifying the price curve equation. (You can find the math in their litepaper)

This allows them to have a high volume to TVL ratio, sometimes resulting in crazy amounts of capital efficiency.

Rebalancing Mechanism for market-making profit

Concentrating liquidity comes with its own set of risks and because Lifinity owns its liquidity, it needs to be even more careful than other AMMs about leaving its pools unbalanced for long.

To minimize this risk, the protocol employs a rebalancing mechanism to keep the pool balanced. It does this by adjusting its liquidity whenever a trade occurs or a change in oracle price happens.

If token x in a pool is worth more than 50% of the pool, the algorithm decreases the available liquidity for it and increases it for the other token y. This incentivizes traders to purchase token y by selling x and therefore return the pool to 50% in value.

When you consider all the possible scenarios in which rebalancing occurs, Lifinity’s pools end up buying the dip when prices fall and take profit when the prices rise. This results in market-making profit.

The exact equation and a more succinct explanation of the rebalancing mechanism is available in their litepaper.

To recap, the following 4 ideas are what sets Lifinity apart from traditional AMMs

Protocol owned Liquidity
Oracle Usage
Concentrating Liquidity
Rebalancing Mechanism

And how have these ideas played out?

We should judge a market-maker based on the following two metrics

How much volume do they generate?
Are they profitable in the long-run?

The bear market has been rough but Lifinity has been doing well on both accounts.

Trading volume

On any given day, Lifinity consistently ranks in the top 3 DEXs on Solana by volume (Source — Jupiter Stats Page). Considering that its TVL is just a fraction of what it is for the other DEXes, this is impressive and evidence that idea behind concentrating liquidity and using the oracle has been working out.

Additionally, Lifinity recently surpassed $2B in total trading volume (Link)

Revenue

Lifinity publishes its monthly revenues from its POL liquidity on their discord (link to channel) and Twitter. Over the last 6 months, this has amounted to over 952,000 USDC

And the revenue earned by Flare Owned Liquidity is published weekly and this currently totals 11,516 SOL over the last year

How is this revenue used?

50% of the revenue from POL is used to buyback the LFNTY token and the other 50% is distributed to veLFNTY holders

50% of the weekly revenue from FOL is sent to the Buyback fund to buyback Flares and the other 50% is added to the Flare Owned Liquidity

Although the primary income stream is from its pools, it bears to mention that Lifinity also provides other services and a portion of this revenue can be attributed to them.

Here’s a list of all other income streams

MMaas (Market Making as a Service) Partnerships where protocols provide Liquidity and Lifinity market-makes with it for a fee
- UXD Protocol
- xLPFi
LaaS Partnershps (Liquidity as a Service) where Lifinity provides both liquidity and market-makes on behalf of other protocols
- LIDO
- MNDE
Providing Liquidity in NFT AMMs
Providing SOL Liquidity on Frakt Pool for Lifinity Flares
Royalties on its NFT Collection
They tried lending SOL and USDC out to other DEXs on Solana in between but after a lot of hack-scares in the year, this was stopped.

Lifinity’s Tokenomics

This deep-dive would be incomplete if I didn’t mention how Lifinity’s tokenomics work and how they use their revenue to support it.

In a world of high FDV with a low circulating supply, Lifinity’s tokenomics and the reasoning behind them were a breath of fresh air. I would recommend you read their 6-part series on Medium in their entirety (1, 2, 3, 4, 5) but here’s a shorter version.

If there’s one takeaway you should note it is that there are no constant emissions of LFNTY tokens to LP holders to create a consistent downward sell pressure that plague all other DEX tokens.

Lifinity has 3 tokens

LFNTY — This refers to unlocked LFNTY

veLFNTY — Locked version of LFNTY that grants you access to protocol revenue on a monthly basis

xLFNTY — This is 4 year locked LFNTY token

Total Supply

20M LFNTY was sold in the IDO for a total of $9.6 million. Majority of this was sold as 4 year locked veLFNTY with a starting price of 0.42

Buy Pressure for LFNTY comes from

The protocol consistently buying back LFNTY every hour from its buyback fund which is replenished monthly (Link to the buyback account)
Users who want to purchase LFNTY to lock as veLFNTY to get access to protocol revenue

Sell Pressure for LFNTY comes from

Allocation for the NFT Holders who stake
Any IDO participants that want to exit
Team’s allocation if they choose to sell
Users whose veLFNTY decays into LFNTY and are looking to exit

On Dec 31, 2022 — In the 6 months since launch, the Lifinity Buyback bot bought a total of 1M LFNTY back, which is approximately 5% of the circulating supply.

Where can you trade these tokens

You can purchase/sell them on Jupiter but the underlying markets are

Lifinity runs a LFNTY-USDC pool and xLFNTY-LFNTY pool and provides liquidity to each of them
It has also created a serum market for xLFNTY-USDC but does not provide liquidity here

Performance of the token

LFNTY is currently $0.33 from it’s starting price of $0.84
xLFNTY is currently $0.31 from it’s starting price of $0.42

If you bought $1000 worth of unlocked LFNTY at IDO, it is currently worth $402

However, the majority bought 4 year locked LFNTY at $0.42. Assuming you bought $1000 of it at IDO, it is currently worth $756 and in the 6 months since the IDO, you would’ve gotten $57 in total revenue share (simplified calculations).

Token down, token bad?

The token is down significantly, does that imply bad tokenomics? Not really. The buyback mechanism has been working as advertised. Lifinity has bought back 1M LFNTY tokens. That is almost 5% of the circulating supply.

Price being down simply implies more people want to sell than people that want to buy.

But why have people wanted to offload their LFNTY?

Reduction in the asset prices that Lifinity holds to market-make Lifinity had raise $7.3M as POL (link) from their IDO. This amount was ~$5 M a month ago (link)
Lesser APR than projected Lifinity’s SOL-USDC pools in early testing had phenomenal APR, often upwards of 100% and I suspect a lot people invested looking at that. However, other pools haven’t been able to recreate this level of APR. The combined APR has been usually around 10-20% and that’s not enough.
Inability to deploy the entire POL A significant portion of the POL is undeployed and is sitting idle because there aren’t many tokens with significant trading volume on Solana.
Reduction in DeFi volumes Solana-wide Trading volume has come down significantly in this bear market. Jupiter did 4B in volume in May and 300M in volume in December. That’s 10 times as less. This directly affects the volume that Lifinity provides.

Lifinity’s Governance Mechanism

Lifinity outlines their approach to governance in this medium article.

Their approach to governance is influenced by their desire to be nimble and move quickly by not having to put everything they do to a vote. The team decides what should and should not be put up for a vote.

Examples where team will not plan to seek input

LFNTY emission schedule
New pools to add
Adjustments to parameters like trading fees, concentration

Their explanation for this is that since the developers are intimately familiar with on-chain market data and have spent considerable time optimizing the DEX’s parameters, they are best equipped to make decisions of this type.

However, they maintain that they value user’s input and feedback in everything that they do. An example of this is how they launched the tokenomics series 1 post at a time and als in advance for flare holders and took feedback before launching it for the rest of the team.

Examples of decisions made with voting

If the Flare DAO should deposit its bought back flares into GOATSwap

What should the protocol do with the MNDE that it received through a grant?

Examples of decisions made without voting

New pools to add
Adjustments to parameters like trading fees, concentration
Buyback bot frequency
What the team should be focusing on next

Although Lifinity has a token, it does not follow a token-based governance model. This means that whales don’t have an outsized influence on the votes and the median voter gets a much higher say in what happens to the protocol. Also, there is no worry about votes not reaching the required threshold to pass. The team takes a call in such situations.

Votes are done through a discord bot that called Pollmaster. It uses emojis to keep track of the options. Voters can see the results after the poll is closed.

From what I can recall, there have not been any major disagreements. I think a lot of that has to do with the trust that the community has in the team to do the right thing. Durden makes it look easy but he does a lot of legwork before a proposal is enacted in ensure that views of the holders are considered.

The participation of the community in these polls is generally higher than it would be if these votes happened onchain. Discord is simply easier for people to use.

The Road Ahead

Lifinity is experimenting with a v2 that should do better in single-sided markets. It’s called DNMM, a delta-neutral market maker which aims to remove price exposure of the tokens held for market-making and further improve profitability. Initial signs have been promising. Link to Medium Article

When DeFi volume returns to Solana, it will be interesting to see how well Lifinity’s v2 will be able to keep up.

Why you should care

Sometimes all of crypto can feel like a ponzi and the past year has not helped. Project after project designed to fleece retail investors out of their money to fuel unsustainable growth. NFTs whose entire value proposition is hype. Trust in the Solana ecosystem is at an all-time low.

In such a world, Lifinity is a breath of fresh air.

From day zero, the focus of this project has been on profitability and ensuring that its holders are placed above everything else
They focus on profitability of the protocol over other gameable metrics like volume
They have been extremely transparent in their communication and vocal in calling out bad actors
They are pushing the crypto space forward by actually innovating on existing models
What they’re building is only possible on Solana and nowhere else

It’s hard not to root for them.

If you’ve made it this far, thank you! I enjoyed writing this deep-dive and I hope I was able to intrigue you enough to check Lifinity out.

If you notice any inconsistencies or mistakes, please do hit me up on my Twitter @adarshrao_. I would love to improve my understanding of the concepts outlined here or just answer any further questions you may have!

References

Lifinity Discord
Lifinity Medium
Lifinity Litepaper
Tokenomics Series — Part 1, Part 2, Part 3, Part 4, Part 5, Part 6
The Beacon — Latest edition of Lifinity’s monthly newsletter

Disclosure: Author own tokens and NFTs of the project mentioned in this article and has a financial interest in them succeeding.

Disclaimer: This is not financial advice and you can lose your entire investment in anything in crypto.

Deep Dive: Hyperspace

Rohit Kumar Varma — Mon, 16 Jan 2023 10:00:13 GMT

Storytime: Imagine you traveled back a month ago, to the day of the world cup final between Argentina and France, and you are rooting for Messi to lift his first World Cup since your childhood (well, we all know what happened 🥹). You were about to get to the airport to catch your flight to Qatar, and just then you got to stay back for an important extended office session, which ruined all your plans to be there for your football hero!

And we know what happened that night, Argentina won and Messi scripted history! You saw all of it live on TV and pumped up with joy and celebration.

You want to forever cherish this memory by collecting the final ticket from someone who visited the game! But there are two major problems:

How do you know if someone is selling you an original ticket?
Where would you buy it??

Conquering the WHY?

By the end of the story, we got to figure out two questions: How to verify the authenticity of the collected ticket and where would you buy it from?

And the answers to those questions are NFTs and Hyperspace respectively.

So, what are NFTs?
Non-Fungible-Token or an NFT is a unique digital asset that can represent any form of value like a piece of art, music, a random jpeg, etc. It is a digital form of the asset which is stored on a blockchain (on-chain), to enable the following properties:
Ownership Verifiability
Determine the quantity and interest on an asset
Track asset history
and many more such properties and use cases, which will be discussed in depth in an upcoming independent section.

Now, wassup with Hyperspace!

To understand what and why of Hyperspace, let us get into a classic Web2 vs Web3 POV!

A web2 POV to show the need for data aggregation

WEB2 POV: Let us consider the above example from the web2 world, In India, among many others, the two major E-commerce “Marketplaces“ are: Amazon and Flipkart.

As we can see in the above example when we search for the term “iPhone 13 mini“, we see different vendors in both marketplaces, selling the same product at various price points. When we compare with other available marketplaces like Snapdeal, Myntra, etc, these disparities in marketplaces boil down to the following points:

Different Price Points for the same product: Indicating varying “Platform Fee“
Availability: Some products are only available exclusively on specific marketplaces
Lack of availability of Advanced filters across platforms

With all these happenings, the web2 E-Commerce users needed a unified marketplace before going as crazy as our Homer Simpson:

Web2 users with no unified marketplace

Web2 World came up with a “patch-up“ solution: Google Shopping, which can be seen in the previous illustration.

As we know Google indexes the whole of the web, and with this huge amount of data, google managed to create a shopping page, which aggregates data from all the major E-Commerce across the internet and serves as a unified interface with various price ranges of products across platforms and a unified filtering service.

But there is still a major problem with the web2 world in integrating marketplaces:

Lack of Platform-Agnostic User Experience

These can be explained the way the above-explained Google Shopping works, it aggregates the data, tracks the real-time data, and presents it in front of a user in a unified interface, but still, when the user clicks the link of the product, the user reaches to the E-Commerce platform itself! This is a massive setback toward a truly interoperable and platform-agnostic user experience.

Well, the need for a unified marketplace aggregator exists in the web3 NFT world too! Let us see if any platform solves this problem (spoiler: it does! Thank Hyperspace 😉)

web3 POV: Hyperspace showing the way toward platform-agnostic unified NFT marketplace

When a creator wants to generate art with varying traits like eyes, nose, clothes, colors, artifacts, weapons, etc, this gives a unique personality to each piece of art, but as these are generated by the same artist with similar traits, they come under a unit called a “Collection” of NFTs. In this example let us talk about a high-value collection called “Smyths“, which is an NFT collection by “Blocksmith Labs“, which contains cool stylized warrior images with various varying traits for each NFT.

When we check out the Solana NFT ecosystem (Solana is one of the major blockchains in the world, known for its blazing speed and highest recorded Transactions per second, more on it later!), there are many NFT Marketplaces like Magic Eden, Solanart, Coral Cube, Fractal, etc.

Let us consider Magic Eden and Solanart for this example, and let us search for the collection called “Smyths“, Magic Eden shows the collection, and Solanart doesn’t. And both these platforms have varying fees, this brings us back to the same problem as web2, the need for a UNIFIED NFT INTERFACE, in this case on the Solana Blockchain.

Fret not, we’ve got Hyperspace to solve this massive problem!

As shown in the above illustration, Hyperspace is an NFT aggregator, which unifies all the NFT collections across marketplaces on the Solana Blockchain ecosystem. But does it solve the Platform-Agnostic User Experience problem faced by Google in web2? YES!!!

Every NFT as said above is a piece of code stored on top of a blockchain in smart contracts in the form of a token! So on-chain is a platform-agnostic medium that helps Hyperspace to scrape through the marketplaces, analyze the contracts, and list all collections in one unified interface! This enables Hyperspace to allow its users to buy NFTs from any marketplace across Solana to buy NFTs directly from their site with no additional fee than the original Marketplaces, all this without any redirects or leaving the Hyperspace site!

Hyperspace.xyz

Hyperspace.xyz, is aiming to be the one-stop Bodega or Kirana store (In Indian terms) of Solana NFTs, and provide a unified interface to analyze, track, trade, and support users and upcoming NFT creators and collections to launch their ideas to the moon!

What does Hyperspace gets going in its way compared to other marketplaces and aggregators on Solana? Let’s find out:

Open APIs and Decentralized (On-Chain)
Composable Frontends (hella exciting frontier!!)
Least market fee in the Solana NFT space
Developer support and SDKs
Escrowless NFT sales

And tons of other standout points as we go into the deep dive! Let’s start from scratch and learn about NFTs and their ecosystem in Solana, then build our way up to Hyperspace’s working, potential, ecosystem landscape, etc!

Let us jump into this exciting, astronomical deep dive into the world of Hyperspace!

An Overview before jumping into this deep dive

A Brief Introduction to NFTs

A Non-Fungible-Token or an NFT is a digital asset stored on a blockchain in the form of a native specialized token standard (like SPL tokens on Solana, ERC-721, and ERC-1155 on Ethereum). This allows the token to hold assets such as jpegs, music, art, documents, etc, and store them on a blockchain.

Any NFT token stored on a blockchain contains a set of metadata along with the asset itself, some of these fields by default, include the wallet address that “minted“ or created the NFT, Current wallet owner, and transaction history, which can be explored on a blockchain specific scan applications like Solscan on Solana or EtherScan for Ethereum. Along with these, there will be NFT-specific metadata like NFT attributes and generative traits of the image, Royalty fee, etc.

These properties allow users to track, and verify NFT ownership and transaction history. This allows users to implement various applications like Token-Gated Communities, intellectual properties, Patents, Metaverse and Gaming, etc.

Traits and Attributes of an NFT

Visualizing Traits and Attributes of an NFT

As discussed above NFTs contain various attributes and traits, which define the generated Art. As shown in the above illustration, Degods, one of the top-selling NFT collections is shown, and these avatars contain various varying properties like the Background, Skin, Mouth, Speciality, etc. These properties allow creators and developers to create a collection of NFTs with the combination of several variations of properties. For example, Degods is a 10,000-pack NFT collection, which contains 10K unique NFTs.

Traits and their push towards Rarity

We can observe from the above collection that, some of these traits are highly repetitive and others are rare in nature. The rarer a trait, the higher the chance of an NFT with the trait having a high value. From the below image, we can see a couple of traits from the Degods as an example which shows the percentage of availability of each type of trait in the collection, for example, Divine Robe is only available in 0.36% of the total collection hence NFTs with that feature would have a higher selling price.

Filter based on traits

The Solana NFT market is huge, it is evident from the following graph showing the number of new NFTs being minted on Solana every day, with a peak of more than 300,000 NFTs being minted in a single day in September 2022.

Solana NFT ecosystem number of transactions

And as the ecosystem grows, there will be an emergence of newer dApps and marketplaces on Solana, thus the need of the hour is to develop a unified aggregated interface to analyze, trace and trade the NFTs across the marketplace in a platform-agnostic way. The importance of this platform-agnostic NFT aggregation would be explained in the next section.

The Need For Hyperspace 👨‍🚀

Marketplace-wise share in Solana NFT daily transactions

From the above graph on daily NFT transaction count on Solana, we can observe two important trends in the Solana NFT ecosystem, they are:

Market Dominance from Magic Eden
The emergence of new Marketplaces in the ecosystem

This brings us to two key immediate needs in the Solana NFT ecosystem:

Protect NFT collections from Market Dominance and restrictions: Upcoming NFTs will surely depend on Market leaders like Magic Eden, to increase their chances of getting noticed by a wider audience, this gives such platforms a monopoly to leverage which may lead to a restrictive ecosystem in the future, thus supporting all the NFTs projects in Solana under a single, open and decentralized platform is the need of the hour.
Support Emergent Marketplaces to gain traction among avid NFT creators, collectors, and traders by creating a medium to reach a wider audience. Thus creating a platform that gives an equal, wider audience to all marketplaces alike.

So the need of the hour in the Solana NFT ecosystem is a platform with:

Open, Decentralized platform to support every single NFT under a unified interface
A unified interface to give all marketplaces equal representation and a wider audience

Sounds like we need a marketplace aggregator, right? Well, let’s dive into Hyperspace to learn more about the platform and the services it provides to create a single platform to analyze, track, trade, and support all NFTs across the Solana ecosystem.

Hola Hyperspace! 👋

Introducing Hyperspace founders

Hyperspace was co-founded by Kamil Mafoud from MIT, Santhosh Narayan from MIT, and Johnny Tan from Georgia Tech. The team started with a platform called “Solanalysis”, which is a utility interface to analyze all the NFT collections on Solana and their statistics. The team then rebranded Solanalysis into “Hyperspace“, which is not just an analytics tool, but it is an end-to-end NFT aggregator and Marketplace on Solana with advanced analytics and Launchpad support for upcoming NFT projects.

Core Motto and Products of Hyperspace

Hyperspace stands tall on its four core pillars as its principle motto:

Analyze: Provide general users, traders, and NFT creators tools and utilities to analyze NFT collections, wallets, trends, and data across the Solana NFT ecosystem, with advanced filters like time periods, price ranges, rarity, etc.
Track: Hyperspace provides users with individual wallet profiles, which can help users to track the offers on their NFTs, or keep an eye on current offers on interesting collections by subscribing to them via Notifi.
Trade: Hyperspace enables users to trade NFTs across all Marketplaces in the Solana Ecosystem, directly from the Hyperspace application. No Redirects. Everything On-Chain. This allows users to gain a platform-agnostic experience while maintaining their NFT collections.
Support: Hyperspace’s other major pillar is its extension of support to launch upcoming NFT projects, airdrops, and mint events, and engage them with a wider audience.

Hyperspace Platform Overview 🔍

The Hyperspace platform can be divided into three main sections as shown in the above diagram, they are The Aggregated Marketplace, Analytics, and Launchpad.

In the upcoming sections of the deep dive let us explore each of the components and its sub-parts to understand all the services offered by the Hyperspace platform.

Hyperspace Aggregated Marketplace 🏬

The Aggregated NFT Marketplace is the primary service being offered by the Hyperspace Platform it enlists two types of NFT collections for users:

Hyperspace listed NFT collections
Aggregated NFT collections from Marketplaces across the Solana Ecosystem

This is the home page of the Hyperspace platform with tools to quickly analyze the top-performing NFT collections in the last 1 hour, or 1 day or 1 week. This page provides users with a quick understanding of the current market scenario across marketplaces, and shows them a glimpse of new and upcoming collections.

POV: Hyperspace Collections 🪺

An NFT Collection, as discussed in the prior sections, is a bundle of minted or yet-to-be-minted NFTs, which has a common creator and a set of similar attributes and traits. These Collections will be up for grabs, i.e., available to the mint for basically free! Users can get these NFTs from the collection just by paying the gas fee, which is less than $0.00025 per transaction. But hey! This is just when you are too early and one of the first holders of the NFT collection to mint the NFT, but in general any user can offer or buy an NFT from the available listings.

The above image shows one of the popular NFT collections on Hyperspace in detail. As we can see from the illustration I’ve placed some markers on the image for a better understanding of the different components on the page:

Component A: Collection Overview:

This part of the collection page contains the following metadata related to the NFT collection:

Name of the project
Floor Price: The current least price of an NFT among all the NFTs present in the Collection. This is the current minimum anyone has to offer to buy an NFT from the collection.
Floor Bid: It is the current least bid from the buyers to buy an NFT from the collection, if there is no offer for the current bid the buyer can increase the floor bid.
The component also contains an easy-to-access quick button called “Place a bid“, to quickly place a bid to buy an NFT from the collection.
The next part of the component is the number of NFTs in the collection that are listed for sale currently, this is dynamic in nature and gets updated as the transactions get completed, or as new offers pop up.
The 1-day volume, as the name suggests, enables the users to analyze the amount of trade done within the collection in the last 24hrs.
The Unique owners are another important parameter to determine the amount of diversity in the collection and to predict how active would be the project.

Component B: NFT Overview:

This is another important component to get a quick, single-glance understanding of a single, specific NFT in a massive NFT collection gallery. This simple card-like component gives users a clear idea about 5 important parameters:

The top left identity icon gives a short gist of the owner's wallet address.
The bottom half starts with a pink symbol with ME, this indicates that this particular NFT is listed on Magic Eden. It symbolizes which marketplace this NFT is listed on.
And the next number showing #6131 indicates the serial number of the NFT in the entire collection.
The next value showing 43.97 Sol is the current listed price to get the NFT.
The last value at the bottom showing 24.8 Sol is the previously sold-out value of the NFT.

Component C: Search NFTs in the Collection

It is a quick-use utility to search a particular NFT with its serial number.

Component D: Sort NFTs

This is another quick-utility tool for users to sort and analyze the collection based on various parameters like Price, Last Sale Price, Recently listed, and Rank (based on rarity will be explained in an upcoming section). This helps users to find an NFT of their choice according to their budget and interests.

Component E: Advanced Filter for NFTs

This is an advanced filtering utility provided by Hyperspace to filter NFTs in a collection precisely by configuring the thresholds. The given configurable parameters are:

For Sale: Show NFTs only if they are up for sale.
Hyperspace listings: Show listings only if they are exclusive hyperspace listings.
This is a toggle to show or hide NFT pool listings (Basically show or hide NFTs that have been kept in a type of liquidity pool for NFTs as collateral).
Price-based filtering with configurable start and stop prices.
Filter based on the rarity Rank of NFTs, based on Hyperspace methodology.
List of Attributes and Traits (called Fractals here), with which users can try a combinational approach to get the desired NFTs.

Component F: Quick Sell

This is a quick-sell feature that allows users to sell their NFTs in the current Collection directly at the floor bid price, which will be dynamically updated as offers come in. When we click on the sell now button, we will be getting the following dialogue box which says that I don’t have an NFT from this collection (ofc, I am broke:)

Hyperspace finds the optimal marketplace to give the user the best returns on the sale.

There is another option below Sell now, which says “Sell all offers“, which lists all the current offers available to buy NFTs in the collection.

We can see some more tabs below the NFT collection overview (Component-A), let us explore these features on this page:

Activity:

The Activity tab takes the user to the recent activity and transactions in the collection across all the marketplaces on the Solana ecosystem. The table includes the following properties of a transaction:

NFT serial number which is involved in the transaction
Transaction volume (amount)
The rank of the NFT
Seller and Buyer Wallet addresses
Marketplace chose for the sale
Time of transaction and type of transaction (sale or listing or offer made)

Analytics:

The above analytics tab is present inside each NFT collection on Hyperspace, and this page contains the Market overview of the Collection. Let us understand each of the above analytics in brief

Market Overview: This is a Floor Price and Number of Listings Graph with respect to the time period, which shows the number of available listings and the floor price at that particular time, in this example of the “Pilots“ collection, we can see a constant growth in the Floor price which is a very good sign of a growing NFT community, as it brings profit to all the shareholders of the project.
Unique Holders: This graph gives an overview of the total number of unique members in the collection, holding at least one NFT from the collection. The greater this number, the high the activity in the collection community.
Listing Price Distribution: This is another important chart that shows the number of listings up by a percentage of holders, at a certain price range. For example, the first bar on the left shows that there are 57 listings among less than 5% of the holders, with a price range between 43.2-45.4 SOL.
And the final table shows the top NFT holders (wallet addresses) of the collection, the percentage of the total supply they hold, the number of NFTs, and the total value of those NFTs. This table also shows if any of the NFTs from these top holders are on listings.

News: This is a section where the holders of the collection can post the latest news about the happenings of the community and this news tab can be subscribed to by any user via Notifi.

Bids:

This table shows the incoming and outgoing broadcast of bids on-air. Any user with an NFT from the collection can accept a bid from this list and sell the NFT directly to another user.

NFT Specs 👓

As we saw in the previous section user, can surf through the seamless interface of the collection to get a view of all the NFTs in the collection and filter the ones they are interested in. But before buying, Hyperspace enables users to check deeply into the details of the NFT. These details include:

Current Owner of the NFT.
Current and Last sold price of the NFT.
As we can see in the above image this NFT was sold just an hour back (49 mins), and it is listed just 7 mins back. This allows users to see how in-demand the NFT is in.
Then comes the details section where users can check metadata like the Marketplace the NFT is listed in, Creator royalty fee, Blockchain the NFT is stored on, Mint address, and Update authority address, etc.
A list of recent bids on the NFT.
And the history of all transactions done over the NFT.

Rarity Calculation Methodology Enabling User-Heuristics 💎

While exploring the aggregated marketplace we saw an exciting feature called “RANK“, which is used to rank the NFTs in a collection based on their Rarity.

Rarity is a measure in NFTs, which measure how rare an NFT is among other NFTs of the collection. This is generally decided using the traits and attributes embedded in the NFT. The rarer the traits of an NFT, the greater the rarity of the NFT.

But why measure Rarity as a factor?

In NFTs generally, users perceive the rarer the traits of an NFT, the higher price and demand the NFT commands. Because why on Earth someone don’t want something special?

For this, cause Hyperspace designed a Rarity Calculation Methodology inspired by utility services like rarity.tools. Let us explore this design in 4 simple steps:

Step-1: List out all the traits in the collection. As we can see in the below picture each individual NFT has a set of properties or Traits, and sometimes a trait can be ignored as we can see here the “speciality“ trait is ignored.

Hyperspace Docs

Step-2: Find the Rarity points for each trait across the collection. We can simply find the popularity of a trait, by dividing the number of items which consist the trait by the total number of items in the collection. And as we saw previously, the more Popular the Trait, lesser its Rarity, hence Popularity is inversely proportional to the Rarity of the Trait.

Step-3: Find the sum of Rarity scores of each trait for a specific NFT item. And the next step is quite intuitive, just sum up all the rarity scores of traits held by a single NFT item in the collection. Higher the score, Better the Rank, and if there is a tie between any two NFTs then both of them can be given the same rank and demote the next closest NFT to the next rank.

Subscribe via Notifi 🔔

Another interesting feature that needed to be mentioned is the integration with Notifi platform. Notifi is a web3 notification-hub platform, which can be integrated with a wide range of dApps across blockchains, to enable users to view notifications, warnings, and updates in one place, in real-time. This helps Collections and the Hyperspace platform itself to send quick reminders and notifications from the collections to which the users subscribed, directly into their Notifi Hub.

Notifi website

Trade process 🪙

The trade process on the platform is a UX focussed design. Where users can do all the following trade activities from one place in the Hyperspace platform:

Buy NFTs

NFTs can be bought in many simple ways on the Hyperspace platform. The first step anyhow is to connect the user's wallet, and Hyperspace accepts almost every single wallet available on the Solana ecosystem:

Choose your favorite wallet from the available options, accept the confirmation sent to your wallet, and BOOM you are set to go!

Once the user’s wallet is ready, there are multiple ways a user can buy an NFT from:

Click on your favorite collection and hit on the buy now button on the desired NFT, this brings a Cart to which the user can add multiple NFTs at once and buy and check out all of them together.
Sweep: Sweep is a degen way of buying all the lowest priced NFTs in bulk. This can be done by clicking on the sweep icon shown below, which is beside the Collection sort button, thus enabling the user to check out all the purchased NFTs at once.

List NFTs

Listing an NFT has never been so easy. Both Buy and Sell (List) are put together in a single panel via which a user can select as many NFTs from a selection and broadcast all those NFTs into the listing at once.

Make, Accept and Cancel an Offer to an NFT

A user can Make an offer to any NFT from a Collection by visiting the NFT via collection, clicking on the “Make Offer” button, and entering the offered amount, this allows users to have dialogue and negotiate before confirming the transaction.

And as shown in the above illustration approval and cancellation of offers are done directly on the user’s profile page where all their current offers and activity are listed.

Wallet Analytics 👛

Analytics is one of the four main pillars Hyperspace is built upon. It is important for users from all phases like traders, NFT enthusiasts, or developers too. These analytics give the users a sense of the amount of activity and trends taking place in the Solana NFT ecosystem.

And one of the key analytics offered by Hyperspace is “Wallet Analytics“, which enables users to analyze the activity in a wallet and verify the NFTs the wallet holds.

Hyperspace provides two different ways to search wallets and analyze them:

The most direct is the “Top Wallets“ feature on the homepage, which takes the user to this elegant table showing top valued wallets across Solana NFTs.

The second interesting way is to directly visit an address by searching it in the search wallets bar on the navigation bar:

Users can enter ANY valid public wallet address on Solana into the Hyperspace search bar. And monitor their NFT assets, Portfolio, Offers, and Activity.

Cool Fact: Users can search for any valid Solana public wallet address in the Hyperspace search bar, even if it is not connected to the platform ever before! It shows the NFTs in the wallet currently.

How cool is that!

Collection Analytics

The first service offered to analyze the NFT collections as a whole is the NFT leaderboard page, where the NFT projects or collections are ranked based on the total value locked, Market cap, and the Avg price, among many other parameters.

Another way to analyze the Collections is based on the popularity of NFTs. The Hyperspace platform also provides some cool filters like DEGEN (Popularity in the last 1hr), WAGMI (last 1d), and BASED (last 7d).

Launchpad, Mint events, and Drops

Launchpad is the last pillar of Hyperspace to be discussed, It is a service that offers support and a wider audience to upcoming projects, and it also helps in engaging mint events for new NFT projects. These events help NFT project onboard their first holders easily, one such event is going to be held this January 13th on Hyperspace, check it out (remember, we are on Solana and first mint, just the gas fee 😉).

Why Decentralized Composable Frontends?

Hyperspace envisions an open web structure in the future of web3. Where dApps can be built using smart contracts and programs deployed by other applications as building blocks of their services. This leap of interoperability enables rapid growth of the ecosystem to onboard the next billion users.

To enable this dream the Hyperspace team has implemented certain parts of their Native Smart Contract in such a way that any developer or team can spin off their own decentralized frontends using the existing infrastructure of Hyperspace!

The massive upside to this decision is that this enables future dApps to access every NFT in the Solana ecosystem, from a single aggregated Marketplace like Hyperspace! This enhances the number of buyers massively by reaching a wider cumulative audience!

Dev Tooling and open-sourced SDKs

As said above to enable a decentralized composable frontend dApp ecosystem to be built on top of an aggregated marketplace like Hyperspace, the team released two important resources for the developers:

A hyperspace-client-js package on npm, which can be integrated into any other dApp to access the on-chain data stored by Hyperspace. Currently, this requires an API key from the team.

NPM package of Hyperspace

Another way by which the team is supporting developers building dApps on top of Hyperspace is by providing a REST API service, and this too currently needs an API Key to access, from the Hyperspace team. (Interested devs can apply for API key directly from their developer docs: Link)

Marketplace Integrations and Collaborations

The Hyperspace team already collaborated with all major Marketplaces in the Solana Ecosystem, and the list of composable dApps built on Hyperspace is going strong.

Source: Hyperspace Docs

Apart from these Marketplace Integrations, the Hyperspace Team is actively engaging and integrating with teams from Hadeswap, Elixir, and Solvent, to develop a simpler UX to enable efficient trading for the users.

The Hyperspace team also started embracing varied Rarity methodologies by integrating with teams like Howrare.is and Moonrank.app, this allows users to choose their own style of Rarity methodology to analyze an NFT collection.

And the team integrated with the Glow wallet platform to bring listing your NFTs directly to your wallet!

And other notable Integrations include integrating LaunchMyNFT (LMNFT) a tool to launch new mints efficiently and enhance the launchpad performance. Exchange.art integration to get started with 1/1 fine art NFT collection on Hyperspace!

Competitive Landscape and Threats

The Ideal Lands

Hyperspace is technically in a position where there is no reason for other marketplaces to compete with. Because, as of now Hyperspace doesn’t affect the market fee or incentives of any other marketplace, because Hyperspace allows users to trade on whatever platform the NFTs are listed on either Magic Eden or Solanart, or Opensea. And Hyperspace is listing its own lineup of NFT creators and projects through its holistic launchpad, the growth is steady but it’s nowhere when compared to Magic Eden or Opensea, or most of the marketplaces. We can check this stat to understand the previous statement:

When we analyze the above image we can observe two things:

From the Solana daily NFT transactions chart, there is no sign of Hyperspace yet as a marketplace. So this infers that as a marketplace Hyperspace exclusive listings are minimal.
But the second chart is the Hyperspace Q3 report which shows that Hyperspace accounts for more than 20% of the weekly NFT transactions on Solana, and crossed a peak of 40% in a single day!!

Does it ring any bells? These two statements infer that Hyperspace is a minor Exclusive Marketplace and a MASSIVE AGGREGATED MARKETPLACE!!

This proves that Hyperspace, at least as of now is not “magically“ killing the market of any other exclusive marketplaces, but enhancing the unified NFT market volume of Solana!

My Thoughts and Conclusion

Let’s come back to square one, did Hyperspace help me get the ticket for the Worldcup, that we discussed in storytime, YESS!

And what else does this amazing platform offer me?

Hyperspace offered:

The least platform fee among all major marketplaces at 1%, while Magic Eden at 2% and Solanart at 3%.
Non-Escrow transactions: NFTs are completely under the user’s control until the transaction is completed. No middlemen.
Configurable Rarity Ranking: Hyperspace brought the choice to the users, they can choose either the default Hyperspace Rarity metric or they can choose from the recently integrated rarity tools like Howrare and Moonrank
Composable Decentralized Frontend: Being open, decentralized, and providing devs all the support to build an interoperable and composable open web3!

Hyperspace fulfilled all the promises that it was truly meant to be. And I am really hyped up for what the future holds for this amazing platform ❤️

Thank you, guys, for reading this article, and kudos to you to learn all about this amazing platform, if you like my work and got the gist of my attempt, comment with your feedback and share this with your friends!

💌

Regards,

Rohit Kumar Varma,

References

Dune Analytics Solana NFT transactions chart by Chuxin

A Comprehensive Deep Dive into Dialect

Rohit Kumar Varma — Tue, 10 Jan 2023 08:36:51 GMT

Heading into the web3 world in 2023 is all buzzing and bright with new technologies like Interoperability protocols, Metaverse, NFTs, DAOs, Appchains, Oracles, DEXs, etc. All the upcoming web3 companies and platforms are getting record funding, everything looks so great!

But there is a major problem looming in the web3 ecosystem for a long time now

“Interconnectivity and Simple Usability Experience for Users“

Both these factors are prime reasons for the lack of mass adoption of web3 protocols primarily in non-crypto native users, let us try to understand this and how Dialect shows a bright light to solve this problem in the most elegant way!

Comparision between web3 and web2 UX

When we analyze the above image we can clearly see why web3 technologies are intimidating to use for the non-crypto native community, UX elements like accounts, networks, and wallets which we see in most of the modern web3 wallets like Metamask or Phantom are not intuitive, and comprehensible for mass adoption of web3 technology.

When we compare the web3 UX with the web2 equivalent of it, Google Pay (a Google-owned product that allows users to transfer money via the Unified Payment Interface in India), the payment is very intuitive and social in nature. We can:

Pay users directly from the list of contacts.
Send payment requests to notify others.
Chat directly with any contact along with the payment facility.
A simple and elegant confirmation screen with no jargon.

The next thing which is inhibiting web3 protocols is their inability to create a unified interaction method, to interact with any protocol the user is involved with, from a single application. To put that into perspective, let us take the same example of Gpay to show how it is providing a unified interaction to complete payments for different companies and entities ranging from mobile recharges to electricity bills:

Interconnectivity in web2 applications (Example shown: Gpay)

A simpler user interface that is not complex even for non-crypto natives and an interconnectivity mechanism to unify the interactions between users and various web3 protocols is the need of the hour to bring web3 to mainstream user adoption.

And DIALECT is doing exactly that but with a wider suite of features to enhance interconnectivity between dApps to the next level. It also provides an open-sourced SDK for the developers to integrate its services across other web3 applications. In this deep dive let us explore all the services proposed to be offered by the Dialect Platform and the future potential of this amazing technology.

An Extensive Overview of this deep dive

Dialect into the act!

Dialect is a smart messaging protocol, which enables composable, and interactive messages and notifications, which allow user-to-user and protocol-to-user interaction. Dialect is made with a simple UX in mind and was built to act as a one-stop center to interact with all the notifications from protocols that the user is involved with.

Chris Osborn (Founder and CEO of Dialect)

Dialect was founded by Chris Osborn in 2021 and it was part of the Global Solana Hackathon, called IGNITION, where the project secured 5th place in the web3 track.

Dialect aims to enable two key territories which are lacking usable UX and interconnectivity in the web3 ecosystem, they are:

User-User Interaction (Wallet-to-Wallet communication, Transfer Crypto, and a lot of fun and cool NFT sticker thing going on, which will be explained in later sections)
Protocol-User Interaction (Dev tooling) (Composable, Interactive Notifications, Conditional Cross-Chain Alerts, Subscription models, DAO management, NFT bidding, DEX trading, and endless other tooling features)

In the next section let us explore in detail what is web3 Interconnectivity and it’s major issues that Dialect will be targeting to solve

What is web3 Interconnectivity?

Let us use an example to understand how important web3 interconnectivity is: Assume you are an avid cryptocurrency user and you are interested to place a bid for an exciting upcoming NFT. To do this you need to monitor two applications:

A Decentralized Exchange like dydx or Uniswap, to monitor your trade metrics to sell at a specific price and gain the optimal profits from the asset.
An NFT marketplace like Opensea or Rarible, to purchase the NFT you were looking for, by placing a bid.

And now what if you were really busy that day, missed making a profit, and also didn’t place a bid in the marketplace, because you are too busy to go around multiple applications and monitor them regularly.

No one has time to monitor multiple dApps in this busy world

Now if web3 was interconnected, developers could build a single application to monitor multiple dApps and notify the user in a popup alerting the user about the price and if the popup is composable and interactive with rich media text, the user can approve the transaction from the popup itself.

This is the exact thing Dialect is trying to achieve but in a much wider range, because today’s web3 ecosystem is wild, it consists of DEXs, DAOs, NFTs, etc, and Dialect is built to provide the devs required tooling to build applications and integrate Dialect services into their existing projects to provide their uses with a more interactive and simpler way to monitor and approve transactions. Hmm, lots of tools for devs, you know what it’s called? Dev tooling!

What is Dev Tooling?

Dev tooling is a set of tools and infrastructure built for developers to provide them with the required tools to build projects that enhance the adoption of any ecosystem, here when we talk about web3 as an ecosystem, there are a lot of dev tools available like:

DAO frameworks build the base of DAOs with minimum code and then configure the rules of the project.
Node management tools.
Development frameworks like Hardhat, Truffle, etc.
Oracles like Chainlink, Pyth, etc.
Data storage tools like Pinata, Arweave, etc.

Similarly, Dialect aims to provide the required dev tooling for developing things like:

Integrated alert notifications in dApps
Conditional Cross-dApp triggers
Unified Asset Management, etc.

In the next sections let us explore what are the different services offered by Dialect to enable Dev tooling for interconnectivity and User Experience Enhancement in web3.

What does Dialect offer?

Services offered by Dialect

As shown in the above visualization, Dialect offers a lot of dev tooling infrastructure, along with the Dialect App, which brings all the features together to give users a simple and intuitive way to enable wallet-to-wallet smart messaging to chat and transfer crypto socially!

In the next sections let us explore each of these services in depth!

Dialect Subscribe: User POV 👤

Dialect Subscription vs Web2 Notifications

Dialect provides developers with a way to build simple user interfaces to register users by subscribing their wallets to the Organization dashboard (which will be covered in the next section). This is a much more time-efficient way for the user to go through all the important updates from the organization, rather than going through hundreds of chat and spam messages in discord servers (the ol’ web2 way :d).

Substack subscription modal as a web2 analogy

To make a better analogy with web2, it is quite similar to subscribing to a Substack newsletter, where we get automated notifications about new posts from the creators.

Users can get rid of long authentication loops they face on web2 websites asking them to confirm their mail ID by entering some weird codes..Nah we don’t do that here! Just click on connect wallet and subscribe in a single click.
No more page redirects to confuse users with login or signup options.
No need to create any accounts, this helps users to stay spam free and reduce the risk of a potential leak of data like on web2 websites. Here using Dialect only the public wallet address is used to subscribe to the Organization’s updates.

Dialect Subscribe: Organization POV 📱

Community managers and their average salary (source: https://web3.career/)

Community management on sites like discord and slack is a very well-paying job, but it is often not quite affordable for early startups to hire Community Managers who charge an average salary of 65K USD and can go up to 185K USD (source), and it’s common to feel an increase in the gap between the founder’s thoughts, and updates users get. Dialect solves all these problems for creators, projects, and organizations, by providing a simple dashboard to do all the following operations:

Compose a new message to all your users and send them directly to their wallet with a single click.
Analyze the audience statistics.
View message history.

The subscribe component can be directly embedded into any website and can be configured for an entire project or individual creators as well. The subscribe component can be simply added to any existing project by following these steps:

source: Dialect Docs

Register new dApp
Install the required packages for rendering the subscribe component
Configure the parameters in the Subscribe component, to choose from which chain among Solana and Aptos, and which backend option DialectCloud or Solana.
Drop in react component and render the component on any website.
Login with the same keypair into https://dashboard.dialect.to/, compose, and send the first message to your community!

The messages can be sent via different mediums like Telegram, Email, SMS, or of course directly to the user’s wallet (which brings the much-needed simplicity to the user’s experience while interacting with various organizations).

Dialect Powered Inbox (SDK)

Working of a Dialect Powered Inbox (source: A Dialect-Labs article)

Dialect gives an open-sourced SDK to power dApps with an embedded inbuilt Inbox with a decentralized chat feature and also an embedded notification alert modal, which can be used to alert the users when an on-chain parameter triggers an event.

As you can see above animation, it is the working of Dialect powered notification modals on the Jet protocol dApp, warning the user about the collateral health according to the given input. The window of the notification and other data monitoring parameters can be configured using the Dialect SDK.

Feature Updates

Being a validator, developer, or core community member of a buzzing and fast-paced blockchain like Solana is not easy! Tons of new features are added and removed every day, and they need to always stay on top of them, to make changes and prevent any breaking blocks in their projects and applications. To do this they need to constantly monitor the community pages, discord, and other social outlets of Solana, which time inefficient and unorganized.

Dialect came forward and introduced a solution to this problem by developing a Solana Feature update notification and monitoring system, to help validators, developers, and core community members to stay updated, they can just sign up with their wallet and check the updates on the Dialect App (about it in the next section !)

@solana feature updates!\nIf you're a validator, developer, or community member who wants to stay in the know, we’ve got you covered\n\nThanks to @jacobvcreech of @solanaFndn & @brianlong of @triton_one on this rollout\n\ndialect.to/solana-updates","username":"saydialect","name":"Dialect 🟣","profile_image_url":"","date":"Wed Jul 20 14:58:46 +0000 2022","photos":[],"quoted_tweet":{},"reply_count":0,"retweet_count":20,"like_count":81,"impression_count":0,"expanded_url":{},"video_url":null,"belowTheFold":true}" data-component-name="Twitter2ToDOM">

Introducing Dialect App

In the initial phase of the launch, Dialect provided SDK for other dApps to embed the services they provide into their applications. But currently, on December 15th, 2023, Dialect launched their App live on ios exclusively.

@marculinopng\n\nWeb3 mobile messaging is here LFG ","username":"saydialect","name":"Dialect 🟣","profile_image_url":"","date":"Thu Dec 15 16:27:39 +0000 2022","photos":[{"img_url":"https://substackcdn.com/image/upload/w_1028,c_limit,q_auto:best/l_twitter_play_button_rvaygk,w_88/nhhfkzvixp035u5j6tlj","link_url":"https://t.co/5lMvxN6GUH","alt_text":null}],"quoted_tweet":{},"reply_count":0,"retweet_count":91,"like_count":317,"impression_count":0,"expanded_url":{},"video_url":"https://video.twimg.com/ext_tw_video/1603426549000044550/pu/vid/540x540/Tz10Jy0N3WG4T1Ij.mp4?tag=12","belowTheFold":true}" data-component-name="Twitter2ToDOM">

The Dialect application provides all the Dialect services in a single place for the users:

Wallet to Wallet to Smart Messages
Composable and Interactive Notifications
NFT chat stickers
Updates from user-subscribed external dApps.

Dialect is in progress to deliver its application for Android and the team is ready to deploy the application live onto the much-hyped Solana Saga on Day 1 of its release!

Dialect is also specifically working in collaboration with Solana Mobile team to build the core SMS infrastructure, by building the default DIAL APP on the upcoming Solana Saga (a Solana blockchain based decentralized smartphone). Dialect team is extending their messaging standard to the core SMS to enable DM and Group chat directly from the Wallet on Solana Saga, Stay upto date with notifications from the subscribed dApp platforms, and approve crypto transactions right from DIAL APP. This application is also open-sourced and can be used by any other dApp out there, to further strengthen the wen3 infrastructure.

In the next sections let us learn more about each of the features we saw in the Dialect app like the Smart Messages, Smart Notifications, and NFT chat stickers!

Dialect Smart messages

Smart Messages (source: Dialect)

Smart Messages is an amazing user interface revolution being developed by the Dialect team. It can do literally any operation, that a user can perform in any dApp that is embraced the Dialect Messaging Standard (there are right now 50+ dApps that embedded the Dialect Messaging layer into their tech stack). With this users can perform operations like:

Minting NFTs directly from the wallet interface.
Placing a bid for an ongoing NFT auction directly from the wallet.
Polling user votes for decision-making on DAOs.
Trading on DEXs directly from the wallet.

All the above and more, are Platform-User interactions, but Dialect Messaging Standard is capable of much more than that!

@solana to build the first Smart Messages\n\nAND we're launching a $100k Grant Program to kickstart the next wave of apps building the future of messaging\n\nRead more @CoinDesk coindesk.com/business/2022/… ","username":"saydialect","name":"Dialect 🟣","profile_image_url":"","date":"Sat Nov 05 11:37:22 +0000 2022","photos":[{"img_url":"https://substackcdn.com/image/upload/w_1028,c_limit,q_auto:best/l_twitter_play_button_rvaygk,w_88/afnf7yau9ifwecsrejxi","link_url":"https://t.co/lArfgPv6zI","alt_text":null}],"quoted_tweet":{},"reply_count":0,"retweet_count":61,"like_count":237,"impression_count":0,"expanded_url":{},"video_url":"https://video.twimg.com/ext_tw_video/1588857975065583616/pu/vid/320x320/FWNE7TjZawl8TsVJ.mp4?tag=12","belowTheFold":true}" data-component-name="Twitter2ToDOM">

As we can see from the above embedded video, Dialect turns a personal DM chat into an interactive payment portal so seamlessly….COOOL RIGHT!
Did you observe any difference between the first image of Gpay (web2 payment platform) and this Dialect interface??
YES, THIS WEB3 VERSION IS SO MUCH BETTER!
Because it has all the simplicity of a web2 application and its a crypto transaction! It need not go through centralized banking systems!
This shows the potential of web3 when combined with user-focused minimal interfaces, it goes miles ahead of its web2 alternatives!

Smart Messages (source: Dialect)

Wait! There’s more to it! We discussed the subscription-based updates service earlier right? This can be done in chat! Just send the wallet address of the creator or the platform which can be followed directly from the chat, to enable updates on the wallet!

Everything looks so cool already, but do you miss the fun stickers you send your friends on web2 social media, wait for the Dialect version of it, it’s wild!

NFT Chat stickers

NFT Genesis Sticker Pack (source: Dialect)

NFT chat stickers are a unique feature being offered by the Dialect Mobile Messaging application, where users can Mint, Share, and Trade stickers in the form of NFTs!

As you login into the application, you are gifted with a generous NFT pack of stickers called “GENESIS“, as you use the application, the more the number of friends you refer to use the application, the higher the chance of grabbing a rare set of NFT stickers.

Not only that, these stickers are NFTs made using two of the coolest technologies Solana and Metaplex, with their innovative compressing technology, the minting costs are reduced to a large extent, making it a cheap and easy way to express user thoughts and emotions in a fun and interactive way!

There is more to these NFTs, in the future Dialect wants to create a 1/1 line-up of digital artists to create a unique collection of special collectibles and NFTs. The current team of amazing sticker pack artists can be seen in the below image!

source: Dialect Mobile App

Dialect Smart Notifications

Dialect Smart Notification is another key solution to a problem called Web3 interconnectivity. As we discussed previously this enables dApps to send notifications and updates directly to the user’s wallet. This reduces the amount of noise and spam in the web2 channels like Discord or Slack. It also helps developers to create a Conditional Cross-dApp platform to trigger notifications when a certain event occurs.

Over 50+ integrations have been done with various dApps which embraced the Dialect messaging standard and embedded the subscribe option to enable their community to view updates directly in the Dialect Mobile App wallet.

source: Dialect Documentation

Going multi-chain: Hola Aptos

Along with Interconnectivity, there is a need for interoperability, where users can perform transactions and view updates across a multi-chain ecosystem. And Dialect adheres to the same principle, and as a step towards the same, Dialect announced its support for the Aptos chain and its extended Ecosystem. And Dialect is in plans to extend its multi-chain capabilities by accepting more chains in the future.

@AptosLabs ecosystem ","username":"saydialect","name":"Dialect 🟣","profile_image_url":"","date":"Tue Aug 30 17:06:58 +0000 2022","photos":[{"img_url":"https://pbs.substack.com/media/FbbK2aqUIAAE8pA.png","link_url":"https://t.co/hgTvdetTdP","alt_text":null}],"quoted_tweet":{},"reply_count":0,"retweet_count":83,"like_count":463,"impression_count":0,"expanded_url":{},"video_url":null,"belowTheFold":true}" data-component-name="Twitter2ToDOM">

Onboarding the Dialect App

Let’s get to the good part! Dialect already announced its live application launch on the IOS platform, so let us explore the onboarding experience on the applications!

Welcome page:

source: Dialect Mobile App

Username registration: The user registration is quite simple, the interface shows the wallet address on the screen once the user enters a unique username and proceeds to the next step.

source: Dialect Mobile App

Claiming the NFT sticker pack (peak hype!!!): Next the user would be asked to claim the default GENESIS NFT pack, this action can be completed in a single click, then this package would be added to the collection.

source: Dialect Mobile App

User chat with NFT (glimpse): As shown in the below glimpse this is the way users can communicate on the wallet itself, and can also share the NFT stickers in the collection.

source: Dialect Mobile App

Smart Messages (glimpse): As discussed above, a smart message can involve many things like NFT bidding, DAO voting, or a simple crypto transaction, in the below image we can see how users can transfer crypto directly from the chat, just by clicking on send and approve!

source: Dialect Mobile App

Referral Page: The referral page contains the current leaderboard with the most number of referrals, and the more referrals you get to the app, the rarer NFT sticker packs you get!

source: Dialect Mobile App

Untapped potential of Dialect

Dialect is still in the mid-stage of its development, but it has tremendous potential applications in the future, which can define the way web3 goes into the masses, some of the interesting applications would be:

Collaborating via wallet DMs: Every day there are hundreds of projects being shipped in the web3 ecosystem, there might be many factors pulling back developers from collaborating with bigger projects or creators, lack of social presence, coming from an underdeveloped nation, etc. But a pseudonymous wallet like Dialect can act as a barrier to avoid these factors affecting the growth of the ecosystem and developers, and creators can collaborate with each other, on Dialect with on-chain activity linked to their address as Proof-Of-Work!
Developers can build dApps linking specific events across the ecosystem: For suppose a developer can create an application that can monitor the trading price on a DEX, and ask for notification-based approval of selling when a price event is triggered, which is previously set by the user.
At the same time, this can also be used to create conditional dApps which will be of the format (if this, then that), which is a classic web2 API analogy, which can trigger multiple actions across dApps, with a single approval via notification.

Competitive Landscape and threats

source: Blockscan Homepage, XMTP Twitter, Bloomberg

As of now, there is a limited competition to Dialect, as most of the other implementations are still in a preview or in development modes like XMPT’s message transport protocol or WalletConnect’s Wallet-to-Wallet messaging preview. The closest competitor to Dialect would be Blockscan, which is being developed by the team behind Etherscan. Although Dialect holds a key advantage being a Mobile application that is accessible to a larger demography compared to Blockscan’s web version. But the next important step for Dialect would be to spread its presence across multiple chains, to spread services to key dApps across the web3 ecosystem, before other competitors arise on different chains.

My thoughts and Conclusion

I always wondered why I see a very less number of web3 applications on mainstream media or in mass adoption, and after researching the origins of the Dialect platform, I can confirm that a complex technical UX and lack of interconnectivity are the two main reasons why most the dApps fail to reach their target audience.

Really happy about Dialect for two things, one obviously for developing this application to help dApps reach their target audience and help users experience a clutter-free web3 ecosystem. But the second reason is the way Dialect is open-sourced as an SDK for any other dApp to integrate it into their product, kudos to the team for this decision!

💌

Regards,

Rohit Kumar Varma

Twitter

References:

Dialect website: https://www.dialect.to/

Dialect Developer Docs: https://docs.dialect.to/documentation/

Web3 Career Website

Blockscan Chat

Article by Multicoin Capital

Dialect Twitter: https://twitter.com/saydialect

The Wormhole Deep Dive — Connecting the blockchain countries via Bridges

Sitesh Kumar Sahoo — Sun, 13 Nov 2022 10:32:10 GMT

$25 Billion — That’s the amount of capital that flowed through bridges at its peak in the month of March. If you consider blockchains as countries, the cross-chain flow of capital is going through their “FDI moment”. In the 1990s, the capital which was once restricted inside the countries began to flow freely across the globe. Just like the free flow of FDI (Foreign Direct Investment) led to new kinds of commerce & globalization in real-word, blockchains are now going through “cross-chain globalization”.

Leading this Renaissance is today’s spotlight project — “Wormhole”, which started as just a Solana Hackathon Project by Certus One, but quickly rose to be Jump Crypto’s darling and $4.7 Billion in Total Value Locked (TVL) at its peak.🤯

In this piece, we will discover how Bridges are an essential Infrastructure, security concerns, how wormhole is solving them, and at last the juiciest part, the bull & bear case for Wormhole.

Let’s go🚀

Bridges & Cross-chain:

Right now, there are 20+ blockchains with sizeable ecosystems, with Ethereum leading the pack. With the rise of Alt L1s (Solana, Cosmos, Avalanche) and L2s and now even shiny Alt L1s like Aptos and Sui, we are slowly heading towards a Multi-chain future, where there will be many ecosystems existing. However, currently, blockchains are siloed.

For a true multi-chain future, we need to enable the flow of both capital as well information. Here’s where bridges kick in!

Roughly, there are two types of bridges:

Two-way Asset Bridge, which enables the flow of capital
Messaging Bridges, which enable the flow of Information

Let’s first focus on Asset Bridges, which have seen immense adoption, and then see why Messaging Bridges are the next frontier!

Asset Bridges

Banks take in assets (deposits) on one end and issue liabilities (loans) on the other end. They must continuously maintain enough liquidity on both ends so that they can continuously process both loans and deposits. Similarly, Bridges has to ensure liquidity on both sides of blockchains, so that they can process cross-chain transactions smoothly.

Currently, most of the bridges are ‘state-sponsored’ or ‘network-sponsored’, which simply means that they are sponsored by the blockchains on which they are built. In the real world, we are connected through roads and rails and they are subsidized by the nation, just like that bridges in crypto make the influx of users and their assets into another blockchain, that’s why it makes sense for the blockchain to sponsor them.

But do users trust them? Forget users, can YOU trust them?

Most users don’t really care for decentralization as long as they are able to transfer their funds successfully across chains and not lose a single penny. And the TVL lies where the users are. So the most efficient and trusted bridges will be those with a long track record and that makes the ‘network-sponsored’ bridges the go-to option for users.

Security Concerns around Bridges — How Wormhole solves them?

Most likely you heard about Wormhole from the infamous $350 Million Wormhole hack. Bridges are the most vulnerable point in a network so they often become the obvious targets of these hacks.

A simple search about Wormhole on Google

Let’s first explore what are the security risks that should be considered for crypto bridges

If we start from the high-level overview, the first thing that comes is the risk with the Network.

When a chain gets compromised, let’s suppose in a 51% attack the intruder can make random transactions on that chain.
Then when you go on step deeper the next thing that can happen is when the validators get compromised.
And at the core, there always exists a Smart contract that can get compromised and the attacker can get away with the available funds. Bridges have the capability to transfer as many tokens, as much value as you want. But being fully limitless is an appealing quality, but it can swiftly backfire if there is a smart contract breach or chain compromise because the token bridge can be rapidly drained in record time.

When trying to bridge a token, reconciliation or accounting on both chains becomes crucial to make sure that the origin chain has the money before it can be moved to the destination network.

And there comes Wormhole!

Wormhole is a message-passing protocol that connects multiple blockchain networks like Ethereum, Solana, Polygon, Avalance, and many more together and provides them with cross-chain compatibility.

xDapps — The future of DApps

Cross-chain functionality is made possible by this message-passing mechanism. To transfer the xAssets (cross-chain assets) between networks or access the xData (cross-chain data) to supply them with services on their present network, users interact with xDapps (cross-chain decentralized applications). xDapps are the type of chain-agnostic application that can take advantage of xAssets and xData

Two particular applications help in getting liquidity for xAssets on top of the Wormhole message protocol. Token and NFT transfers through the Wormhole bridge can be done in a standard message format thanks to the Portal Token Bridge and Portal NFT Bridge.

for example, On an app running on Solana could accept direct Ethereum deposits! The developer only needs to integrate the Wormhole SDK into their front end, and the Portal Token Bridge will pick up the deposit and transfer it to the target chain, here Solana.

Who are Guardians?

A guardian is someone who observes the messages and signs or verifies them. Think of one guardian as one node, Wormhole depends upon a set of distributed nodes to monitor the states of the various blockchains. This action is done independently by every guardian and at the end, the resulting signature is combined.

A multisig proves a state has been witnessed and accepted by the majority of the wormhole network by the ensuing collection of independent observations from guardians. In Wormhole, these multisigs are known as VAAs.

Some of the popularly used Guardians are: Everstake, 01node, ChainLayer, Certus One (The original founders of Wormhole)

List of Guardians (Source: Wormhole)

Verifiable Action Approval (VAA)

When enough guardians agree that an observation has been made, the message is put into a structure called a VAA, which combines the message with the guardian’s signatures to create proof. In the end, a smart contract on a receiving chain has to process these VAAs in order to receive a wormhole message.

Here comes Relayer!

The thing which acts as a middleman between the wormhole and the target chain is called a ‘Relayer’. A Relayer picks up signed VAAs from the wormhole network and sends it to the target chain.

But why they are important?

To understand why they are needed, let’s remove them from this situation. If there were no relayer, you would need to get the VAA from the network, submit it to the target chain, and pay the gas fees using the tokens of the target chain, which would not be an out-of-the-world experience for sure (get it? 😏)

Tl;dr: A relayer is software that transfers messages between the guardian network and the target chain.

Applications building on Wormhole:

The wormhole ecosystem is already pumping up with a plethora of applications, let’s discuss all of them one by one, category by category:

Core Layer

Allbridge:
Similar to the Portal bridge, Allbridge is a blockchain bridge that enables the transfer of tokens and/or arbitrary data between chains. Their other product, Allbridge Core, offers a one-click way to move native stable currency between chains without the need to wrap and unwrap the tokens first. Allbridge uses a cross-chain swap in the Wormhole core layer to carry out those “wrap-less” transfers.

xAssets

Friktion (a structured products platform on Solana) uses Wormhole’s Portal Bridge to enable its users to deposit assets from other chains like Avalanche and in the backend, it converts them to Solana Assets. It recently launched Volt#01 for APT bridged from Aptos to Solana via Wormhole.

Apart from friction, there are projects like Mango Markets, Solend, Port finance also use the xAssets.

xChain

Sweat Economy:
It utilizes a variety of DeFi, NFT, on-chain, and off-chain incentives to reward people for fitness activities. it aims to create value for any type of physical activity. Users of Sweat Wallet are rewarded with SWEAT tokens for every action they take. Only verified user movement is used to create SWEAT. The SWEAT coin becomes a true xChain asset thanks to Wormhole! While SWEAT originally existed as a NEP-141 token on the NEAR blockchain, it is now also accessible as a native ERC-20 token by using Wormhole.

Token Bridges:

Mayan Finance:
A cross-chain exchange architecture allows EVM-based chains to access Solana protocols. The objective of Mayan is to make cross-chain swaps as simple as native swaps. Users are able to perform cross-chain swaps with a single click in order to execute this. Mayan built their own “Swap Bridge”, on Wormhole’s generic message-passing layer. While it uses the Serum order book to fulfill swap orders.

2. Nexa:
A decentralized, cross-chain sale platform, to launch native, chain-agnostic assets. Nexa allows for xChain Token Sales (XTS) which is powered by Wormhole. Users from any chain can connect to their wallets and participate in an xChain Token Sale.

The Portal Bridge

The Wormhole Portal is the application that is built upon Wormhole. In early 2022, the Wormhole team saw the necessity to have a clear distinction between the protocol itself (Wormhole) and a reference implementation for a native bridge built on top of it (Portal) — leading to the development of Portal. When you bridge tokens using Portal, the target chain creates a new Portal-wrapped token while locking the origin token in a smart contract. On the target chain, you can exchange those for different or native tokens.

Portal TVL (source: DeFiLlamma)

On non-native chains, portal-wrapped assets have frequently gained canonical status. It is quite liquid to trade assets like wETH on Solana and wSOL on Ethereum, and these assets are fungible and exchangeable just like their native counterparts.

Let’s now discuss some Pros & Cons of Asset Bridges like Wormhole:

Pros

More Permissionless: A good alternative to Asset Bridges is Exchanges, where you can perform cross-chain transactions in a permissioned and centralized way i.e you have to go through the custody of exchanges and perform KYC, which isn’t preferable by many DeFi-native users.
Smart contract composability: Developers can seamlessly build on top of these bridges
No liquidity Lock-up: All thanks to the wrapping up of assets, there is no external liquidity lock-up required.

Cons:

Attack on Verifiers: There is a lot of dependency on verifiers to act in a trusted way, however, they are vulnerable to attack, as seen in previous bridge hacks like wormhole and Ronin. Further, their interaction also introduces smart contract vulnerabilities
Wrapped Assets — Liquidity & DePeg issues: The liquidity of these wrapped assets is fragmented right now, which decreases capital efficiency to some extent and also induces very limited options for users to unwrap these assets. Moreover, these are issued on the credit of the protocol and are exposed to hacks, leading to depeg, which can significantly induce systemic financial risk and loss of confidence.
The Asset list is still permissioned by the protocols — we are yet to decentralize this!

An alternative solution to such Token Bridges is “Omni-chain DEX” which tries to combine both CEX and Token Bridges. Think of them as uniswap, but for Bridges. Just like uniswap, anyone can add liquidity to any assets, and instead of wrapping, there is simply a bridge’s native token in which the sender’s asset needs to convert and then the receiver’s asset on another gets converted back from the native token. However, the middle chain induces its own vulnerabilities and with extra swaps, comes an additional layer of fees and slippage.

How Omnichain DEX works (Modified from AntiApe’s piece)

All bridges Infrastructure projects are currently figuring out the most optimal solution: with minimum cost, maximum decentralization, highest security, maximum asset & blockchain coverage, and best user experience — we will have to wait and watch, who wins the race in token bridges!🍿

Cross-chain Messaging

Cross-chain bridges allow isolated ecosystems to interact with each other.

Haseeb recently wrote about this, Will state-sponsored bridges to Ethereum win in the long term?

The free flow of capital may be enabled through a variety of bridges, but a worldwide interoperable system cannot be established by two-way bridges alone. This is so because the majority of these bridges only provide straightforward money transfers; they cannot support complicated interactions.

Cross-chain messaging can be a solution here. Cross-chain messaging means the ability to call a contract on another chain. It’s so much more than just the asset transfer. Think of being able to use Serum from Ethereum, or being able to create multisig on Squads from any chain. It will only be possible when the blockchain can talk to each other in a trustful manner. This form of composability is not available today, currently, every activity on cross-chain is just multiple things put together.

In the end, the main goal will be that users won’t necessarily need to be aware of the chains that the application’s backend uses. People have always used the Internet in this way: when a website connects an API to a server operated by a third party, the user only uses a single application. If you use Solana, Ethereum, or any other chain today, it is evident. Future iterations of web3 might provide a similar user experience to the internet, where you only have access to the application you are currently using and the rest of the intricacy happens in the backend.

Competitive Landscape

LayerZero
LayerZero is just a couple of contracts that outline the tasks of “relayers” and “oracles”. Oracles are in charge of reporting the real state on the underlying blockchains, and relayers are in charge of actually delivering the messages cross-chain and establishing message validity. The user has the option of using a certain third-party relayer or oracle. LayerZero is not intended to perform either the relaying or the oracle; it is merely a neutral communications medium.
Axelar
Axelar is a PoS network that has its own native token. Every node on Axelar is using software from another blockchain (Ethereum, Cosmos, etc.). The Axelar nodes synchronize with one another to query their local blockchain clients and concur on the present state of other chains when you ask it about the status of any underlying blockchain it connects to.
Synapse
Synapse is another protocol that enables secure cross-chain communication. Synapse has an expandable collection of smart contracts for developers to use, it can be deployed on any blockchain, to create genuinely native cross-chain apps. Whether using monolithic base layers, roll-ups, or application-specific chains, Synapse provides interoperability support amongst all blockchain implementations like lending products, cross-chain DEX, yield aggregators, etc.
Bungee (Cross-chain Aggregator)
Bungee is a cross-chain aggregator which finds the best routes for your bridging needs. It includes things like Maximum output on the destination chain, minimum GAS fee, lowest bridging time, etc.
Blockchain-specific bridges like the Polygon PoS bridge (State-sponsored)

Blockchains & Assets Supported

Wormhole supports a growing list of networks, apart from Solana, Ethereum, BSC, Avalance it also supports chains like Terra 2.0, Celo, Fantom, Klaytn, Polygon, Aptos, Aurora, and many more.

Community

Wormhole recently organized a hackathon named “xHack” for builders across the chains. It hosted hundreds of builders, speakers and panelists from different DeFi protocols, L1s, Wormhole core contributors, Web3 researchers, and many others in those four weeks at xHack.

Community is a MOAT in web3, As more and more people are getting involved with Wormhole, the community is continuously growing and will continue to do so. Currently, on their Discord server, there are already more than 19k+ members, and on Twitter more than 70k+ followers (!).

Future Recommendations & Scope

Native Asset Swapping: Unwrapping wrapped Assets on the destination chain along with a total bridge time of 10–20 minutes is a huge pain in the User Experience. The solution here can be “Native Asset Swapping”, where let’s say USDC is just burned from a source chain, let’s say Solana, and a USDC on the destination chain, let’s say Ethereum is minted. The communication of burning and minting is just relayed via Wormhole’s cross-chain messaging. This way, many cross-chain assets can be bridged natively, without any need for wrapping of assets — leading to superior UX and cheaper fees. In fact, Circle has already worked in this direction with its latest announcement. This can offer a wide range of seamless applications in payments, and lending, where assets like USDC will be truly interoperable across chains.
Cross-chain Identity: With on-chain identity space heating up, interoperability across chains is a big opportunity going forward — it will allow developers to ask for user details from other networks. For instance, ENS (Ethereum Name Service) is one of the biggest identity ecosystems, and accessing users’ cross-chain data (xData) will allow developers to implement a “Login with ENS” system even on the Solana or Aptos blockchain. Essentially, applications on other chains can read the details about the end user’s avatar, name, wallet address, and more without the user needing to re-upload that information on another blockchain. Cross-chain reputation is another big opportunity in this direction.

Bull Case for Wormhole: Multi-chain Future with cross-chain applications 📈

The Multi-chain Future — Ensuring Maximum Coverage: As we gear towards a more multi-chain future, ensuring maximum blockchain coverage becomes quite critical. Wormhole already supports 17+ blockchains, and recently, it also added Aptos as soon it was live on the mainnet, depicting that the wormhole is very keen on supporting even the newest blockchains.
Jump adding $320M from their own pocket shows their belief in the huge opportunity and it can be considered as an investment to make sure, they have the full trust of the ecosystem. This did work in their favor, as now users have the assurance, that even if there is a future hack, the wormhole will make sure that users don’t lose money. Further, they also announced a $10 Million bug bounty to ensure vulnerabilities are minimized as much as possible.

Bear Case for Wormhole: Multi-chain but siloed Blockchains

Why the future will be multi-chain, but will not be cross-chain

In a Reddit post, Vitalik Buterin infamously described why he has some pessimism about bridges.

Here is the gist of what he said.

The reason is the security limits of bridges. He points out how Cross-chain activity has an anti-network effect: it is safe while there isn’t much activity, but the risks increase as there is more activity happening.

It revolves around 51% attacks, but not the way most people think about the consequences of 51% attacks. If the blockchain is hacked in some absurd way, the aftermath is still reasonable if you had 100 ETH but sold it for 240000 DAI on Uniswap. You would either keep your 100 ETH or receive the 240000 DAI. The result in which you receive neither (or both) would be unacceptable because it would break the protocol’s rules.

Source: Internet

Imagine, for instance, that you have 100 ETH on Ethereum and that Ethereum gets 51% attacked, causing some transactions to be blocked and/or revoked. You will still have 100 ETH, no matter what happens. Even a 51% attacker will be unable to propose a block that steals your ETH because it would go against protocol regulations and be rejected by the network. Even using 99% of the hash power can not steal your ETH because the rest 1% would still follow the chain as the blocks adhere to the protocol regulations.

But the issue arises when you are moving ETH to a bridge on Solana. Let’s take the same example from his post. You are transferring 100 ETH using a bridge to get 100 Solana-WETH but at that time Ethereum gets 51% attacked. When the Solana side confirmed the attacker’s deposit of their own ETH, he immediately reversed the transaction on the Ethereum side. Your 100 Solana-WETH may now only be worth 60 ETH because the Solana-WETH contract is no longer fully backed.

2. High Competition:
Although wormhole is currently leading the pack with an excellent team & backing, however, the space is heating up lately, and we will see a plethora of bridges Infra getting built which might have a better working model & UX, which might be a significant headwind going forward.

3. Siloed Future:
It’s also possible that blockchains may continue to pop up, but each blockchain has its own use case and ecosystem around that and there is not much need to exchange assets & information across the blockchains. In this scenario, the bridges as a whole, wouldn’t find much or limited traction.

Closing Thoughts: Cross-chain Globalisation

A truly cross-chain universe enables a wider range of decentralized applications, assets, and composability across all dApps. Wormhole has the ability to Supercharge the user counts and protocol growth across the ecosystem.

We have to achieve a user experience on par with what we have in Web2 applications where you don’t feel like something crazy is going on behind the scene, instead, it just feels seamless. With the siloed nations of the blockchain states coming together with bridges we need to make sure nothing gets lost in between, everything is safe and secured. Because at the end of the day if users lose money, that’s the ultimate bad user experience!

Just like globalization in the 1990s gave rise to the MNCs, we believe with cross-chain interoperability, cross-chain applications will enable anyone to experience the whole ascending Web3 world seamlessly with 100X better UX!

That’s all folks!

— Thanks to Yash Agarwal for helping with key concepts and reviewing this article.

This was a deep dive into the Wormhole and how it building for the interconnected future. If you find it helpful or want to suggest anything feel free to reach out to me at @inSitesh on Twitter.

Until then…

Sources:

DO YOUR OWN RESEARCH. We make no representation or warranty as to the accuracy or completeness of the information contained in this report, including third-party data sources. This post may contain forward-looking statements or projections based on our current beliefs and information believed to be reasonable at the time. However, such statements necessarily involve risk and uncertainty and should not be used as the basis for investment decisions. The views expressed are as of the publication date and are subject to change at any time. Read the full disclaimer here.

Pyth Network Deep Dive : Enabling every asset price multi-chain

Sitesh Kumar Sahoo — Thu, 03 Nov 2022 10:36:03 GMT

Until 2018, Blockchains had a major limitation — the DApps could only work with data already on the network. As bringing off-chain data reliably wasn’t an option, it couldn’t reliably bring off-chain data: the applications were not suitable for real-world use cases.

So, how to make blockchains communicate with the external world?

To access off-chain data, “oracles” are needed. Think of oracles as bridges to the external world!

Over the past 5 years, we have seen various types of oracles emerge from centralized to decentralized, but each of them has its own limitations. The goal of today’s project deep-dive is simple: “To make every asset price available on every blockchain”.

In this piece, we will explore the Problems that Oracles solve → Challenges faced by existing Oracles → How Pyth Solves them → Pyth’s stakeholders → Competitive Landscape & Business Model → Use-cases & the future.

Let’s go 🚀

Problems: Why do we even need Oracles?

For example, let’s suppose Raj and Stepan want to bet on the outcome of a FIFA match. Raj bets $10 on team A and Stepan bets $10 on team B, and those $20 total are now held in escrow by a smart contract, like a middleman. In a conventional world, a middleman can simply check the scores after the match ends and release the funds to the winner.

However, how would the smart contract know whether to release the funds to Raj or Stepan? A market can only read on-chain data and in this case, the match outcome is external data. This is what requires an oracle mechanism to fetch the accurate match outcomes data off-chain and deliver them to the blockchain in a secure and dependable way.

While sports is just one small use case, DeFi is a whole mammoth use case.

While you might be wondering, Oracles are unnecessary in DeFi because pricing information is frequently available on-chain. For example, querying Decentralized Exchanges(DEXs) may be used to determine to price. Compared to using an oracle, integrating the on-chain source involves no more effort in infrastructure or coordination, and the chance of a delay or off-chain failure is reduced. However, compared to centralized exchanges, DEXs sometimes have lower levels of liquidity.

As a result, DEX prices might not be indicative and are frequently simpler to manipulate than CEX prices. These problems can be solved by using an oracle since it adds reliable data from CEXs to the chain.

So, What’s exactly an Oracle?

An oracle in crypto is simply a medium that streams some data from an external source to a blockchain. So price oracles are like bridges that connect the off-chain world with the blockchain by publishing on-chain price data.

Let’s now understand the challenges faced by existing Oracles in detail👇

Challenges faced by existing Oracles:

Unreliable data sources: Some available solutions at times just scrape the data from the internet or even get that from illegal sources which makes them not accountable for the accuracy or its reliability. Most of the solutions are insufficient and unlikely to widely scale to support multiple high fidelity asset classes.
Delays: Delayed oracles can be disastrous. Let’s add some nuance to it. A great post by samczsun, “So you want to use a price oracle” touched upon some critical points around price oracles where he proposed ‘Time delays’ as a potential solution to address oracle failures.

It emphasizes the fact that because Uniswap’s oracle averages prices over a 24-hour period, short-lived price shocks are mostly ignored and even a significant and serious shock (such as 30% for an hour) will only affect the oracle price by not more than one percent, because of the averaging effect.

This Uniswap V2 TWAP (time-weighted average price) oracle can be prone to price manipulation. Because if there is too much selling pressure (for fair reasons) then the oracle will lag significantly from the “accurate” or “true” price and will show a stale price across all protocols where it is being used. Though this might not be an issue for stable assets where the volatility is fairly low, but crypto, as we know is a tale of spikes and dips, so being this volatile the problem of TWAP becomes even worse. Even in real-life scenarios like this using a twenty-minute TWAP can lead to a huge lag in the oracle price as compared to a Centralized Exchange like Binance, or FTX.

Though the motivation for introducing delays seems to stop the market exploits in DeFi, whereas for markets with high volume and volatility, it might not work the best.

Source: Binance

Now think about using oracles with TWAPs in real-time financial products with such latency. It will be a disaster! DEXs will show not show correct prices and arbitragers might take advantage of some protocols to make some profits.

Source: Jump Crypto

Legacy Oracles vs Pyth (Source: Pyth)

Let’s now look at an interesting case study of LIBOR by Jump👇

LIBOR → SOFR Case Study

Aligned incentives are necessary for a low-latency product like a financial oracle. When we talk about incentive alignment, there is one story that tells an interesting story with a lesson and solution. It’s about LIBOR (London Interbank Bank Offered Rate).

The (theoretical) rate at which the biggest banks may exchange short-term unsecured loans with one another as indicated by LIBOR. Simply put, it’s the exchange rate between banks. In this, about 16 prominent banks with operations in London were surveyed every day before 11:30 am GMT. Considering currencies and maturities, the following question was posed to them: “If you were to look for and accept interbank offers in a fair market size just before 11 am, at what rate might you borrow money?” The findings experienced modest editing where the top and bottom four replies would be eliminated to remove variations. At 11:30 GMT, the averages of the remaining submissions were released as the day’s LIBOR benchmark. These responses were anonymous

Soon it started to be seen as the epicenter of finance and the rate got used for more than $300 Trillion notional in contracts like loans, and mortgages to complex instruments like futures.

But it wasn’t too late until some banks started to misreport the LIBOR submission and started gaming it to rake in more profits. This finally ended the rate’s dominance in 2021 (which has been there for 52 long years) and resulted in penalties and criminal prosecution.

In this context, if we consider staking, then we start to connect the dots around the fundamental design challenges to LIBOR:

Participants did not stake any collateral on the accuracy of the information, leading to misreporting of rates.
Participants were reporting rates on hypothetical scenarios and not based on their trades.
Participants lacked skin in the game as they were collectively anonymous, which lowered their reputational risk if they manipulate the rates.

SOFR fixes this!

Secured Overnight Financing Rate (SOFR) solves these design challenges, as it is based on real transaction data and not hypothetical data and uses a “Staking by Trading mechanism”. SOFR is calculated directly by the Federal Reserve Bank of New York. This strong supervision and regulatory powers, make it harder to manipulate making it a strong reputational staking mechanism.

How Pyth solves them?

Pyth network is an oracle solution, which makes timely, accurate, and valuable financial market data accessible on the blockchain with an interesting incentive model and protocol design.

Let’s go a bit further.

Both on-chain and off-chain apps can utilize the first-party chain price data that is gathered by the Pyth network. It is able to achieve this by offering incentives for market participants, including market makers, exchanges, and trading firms, to provide on-chain price data as a part of their regular business operations.

So here the data publishers have to stake tokens in order to publish data for a product and if they publish price data that has some error or is mistaken then their stake is given out to the end users (consumers) who pay data fees.

Delegators on the other hand choose which price feed to stake on top of so that they earn data fees with the risk of potentially losing their stake if the oracle is inaccurate due to the publishers’ fault. Though at first 80% of the data fees will go towards paying delegators and the publishers will share the remaining 20% (these parameters are subjected to PYTH’s governance)

Building a self-sustained and decentralized network

The network consists of 3 parties

Publishers

Publishers have the access to accurate and timely price data, they publish those price feeds and earn a share of data fees.

They need to stake PYTH tokens to participate in the protocol and earn a % of the rewards (data fees). Here staking makes the publishers to have some skin in the game, which means if they provide incorrect or inaccurate data (whether intentionally or not) their stake will get slashed.

2. Consumers

Consumers read those price data and use that in their dApps by incorporating that data into their smart contracts. Consumers can be both on-chain or off-chain applicants who will pay the data fees.

They pay data fees mostly for two reasons:

First and the most important reason is that using Pyth price feeds will reduce their risk, as they can receive a payout if there is a failure.

The other reason simply is, by paying data fees, more publishers use the product, increasing the reliability of the price feed.

3. Delegators

Delegators can stake tokens on a particular publisher to receive a percentage of the data fees generated (paid by consumers), but there is a risk that they could possibly lose their stake if the oracle proves to be incorrect.

Though delegators will initially receive lucrative payouts, but as the market grows more efficient and there is greater competition among them, the payments might eventually decline.

The Incentive structure and protocol design

Traction

Pyth launched on Solana mainnet in August 2021, after launching on devnet in April 2021. In just over a year, it has secured over 90% TVS (Total Value Secured) of Solana’s Addressable Market, 550K+ client downloads, and half a billion value secured.

Most used price feeds of Pyth (source: dune via @cctdaniel)

Today, there are 70+ publishers supporting the network, and more than 80 price feeds are supported. The most used price feeds are SOL/USD (21.5%), ETH/USD (14.7%), and BTC/USD (13.5%) followed by all other cryptos/USD pairs.

Yeah, it is the same cover image! (list of clients down below)

Pyth has two types of clients: Data Consumers & Data Publishers

Clients [Data Consumers]

Over 72 Protocols & Projects, now use Pyth as the price feeds provider. Their data consumers include a wide range of categories:

1. DeFi: Asset prices are the obvious use case here.

a. Lending & Borrowing: They generally use Pyth’s oracle prices and confidence to actively track their users’ account health and to determine liquidations.
Examples: Solend, Tulip, Port Finance

b. DEXs & AMMs: These utilize Pyth’s real-time prices to make sure they are in sync with other exchanges.
Examples: Mango Markets, Drift, 01, Lifinity, DeltaFi, HydraSwap

c. Options & Derivatives, Structured Products, and Vaults: They leverage Pyth’s price feeds for options settlement at expiry and compare with the strike price to determine the P&L of their vaults/structured products.
Examples: Zeta Markets, Ribbon Finance, Friktion, Katana, Cega

d. Stablecoins: Since these stablecoins are backed by either collateral assets like SRM or RAY or using derivatives to remain stable, all these price feeds are fed by Pyth Oracles!
Examples: Hubble, Hedge, UXD

2. DAO tooling & Infra.

All the tooling & infra projects require asset prices for interacting across chains, multi-sigs, etc.
Examples: Squads, Snowflake, Neon EVM, Backpack

3. Off-chain Applications:

These are ideally analytics platforms that require various asset price data for analytics purposes.
Examples: SHIFT Search, Crux, Ideal Prediction

The Consumers of Pyth Network

The most active consumers by the number of transactions are DEXs & Derivative platforms like Zeta, Mango, Entropy, and 01. You can check out the entire list of consumers here

Clients [Data Publishers]

The Data publishers act as suppliers of data, which is a critical piece of the data flow. Over 77 data publishers now publish data in the Pyth network. The current publishers comprise:

Market makers & Trading Firms like Alameda Research, Hudson River Trading, QCP Capital
Traditional exchanges like CBOE Global Markets, Chicago Trading Company
Crypto exchanges like FTX, OKX, KuCoin
Decentralized exchanges like Orca, 0x, Serum

The Publishers on Pyth Network

You can check out the entire list of publishers here.

Business Model & PYTH Token Model:

Pyth currently generates ~65 SOL as fees, and monthly fees amount to ~1750 SOL. By this calculation, we get an Annual Revenue of $700K as per the current SOL Price. However, if we have a bull market, the annual revenue can even shoot up to $10–20M, given the high volume of transactions and higher SOL price.

Pyth Network will be soon releasing its own native token — PYTH, which will enable:

Publishers to stake PYTH and earn a share of data fees
Consumers can pay PYTH as data fees
Delegators will stake PYTH on specific price feeds to earn a share of data fees.

In case of any misbehavior like incorrect data, the staked PYTH will be used to compensate the consumers.

Overall, Incorporating these tokenomics will significantly improve Pyth’s current business model, as now instead of using SOL, they can leverage their own native token as a currency for using Pyth.

Competitive Landscape: Threats & Opportunities

While Pyth is a dominant player on Solana (>90% market share), Switchboard is another emerging player on Solana. However, Pyth has developed a serious moat in Solana due to the following reasons:

Highest quality Institutional-grade data from first-party sources, who actively participate in price discovery.
No other oracle solution updates with as much frequency as Pyth protects users with high confidence intervals & ensures high oracle reliability, transparency, and data legality.

Apart from these, players like ChainLink have been there for quite a long time in Ethereum Ecosystem, and pose a serious threat to Pyth in the multi-chain future. In comparison, ChainLink has 1000+ data consumers, with 12+ Blockchains supported and a $75 Billion Total Value Secured at its peak in December 2021, with a cumulative transaction value enabled of $6 Trillion+

Building for the multi-chain future 🔮

Pyth is now live on the mainnet on BNB Chain with Venus as the early adopter. It has also launched on Aptos, and the protocols on Aptos like Aries Market can even access price feeds like APTOS/USD apart from the normal price feeds. The next blockchains in the line are L1s and L2s, including Ethereum, Polygon, Injective, NEAR, Avalanche, Fantom, Algorand, Arbitrum, Optimism, Sui, and more.

How does it take the data Cross-chain?

The publishers will continue sending the pricing data to the on-chain program as usual. However, in order to send it to other blockchains, Pyth will be leveraging Wormhole’s generic messaging protocol. Simply put, Wormhole is a bridge that allows the flow of information or tokens from one blockchain like Ethereum to another blockchain like Solana.

For instance, A data consumer from a wormhole-supported chain like Binance Smart Chain would be able to request Pyth prices from Wormhole. Once the request is received, the wormhole will vouch for the prices from Pyth and transfer those prices to the Pyth contract deployed on Binance Smart Chain i.e the user’s native chain. This implies that any protocol from that chain can request prices at their desired frequency from the relevant Pyth contract.

The prices will be available on-demand to ensure cost reductions and once a particular data is requested, everyone else on that chain can use those data.

Source: Pyth’s Medium

“If it’s fair game for Wormhole, it’s fair game for Pyth.”

After all, Both Wormhole & Pyth are pet projects of Jump Crypto, after all — we love Jump :)

Future Use-Cases and Applications for Pyth 🧪

Right now, the data feeds are dominated by Crypto-USD pairs, however, as we take more and more applications & financial assets on-chain, the need for reliable external data will only increase exponentially. A few use cases that would present huge opportunities for Pyth might be:

Real-World Assets on-chain: With more and more real-world assets like Trade Finance, Revenue-based Finance, Carbon Credits, and Real Estate coming on-chain, there will be an immense need for reliable data for these external assets. For instance, if someone wants Real Estate in New York to be tradable on-chain, they would need a price oracle for Real Estate, through which they can obtain reliable & robust prices.
Weather, Politics & Sports: With Pyth focussing primarily on “Financial Markets” data right now, there lies a ton of opportunity to build for non-financial sectors like Weather, Sports, or even Politics. An obvious use case here is prediction markets, where smart contracts require reliable data sources for settling bets related to topics like Sports. Finding reliable data publishers would be key here.

Conclusion: Can Pyth be a Trillion dollar in Value Secured Project?

Pyth has made significant progress toward bringing reliable & valuable 80+ financial data like Crypto, Equities, and Commodities sub-second price updates to Solana. However, in terms of price feeds, it hasn’t even scratched the surface, there are thousands of data lying around, which are yet to be published on-chain. Besides, bringing a diverse range of data, expanding multi-chain, and moving towards self-sustaining and completely decentralized is the ultimate goal.

However, the path is not easy — we saw this in the recent Mango Markets fiasco, where Pyth’s price feed wasn’t even used, but such Price Oracle manipulations do pose a threat. Going cross-chain would also come up with its own opportunities and threats. If they are able to successfully, tap other chains, they can easily secure $1 Trillion as the value in the next 2–3 years.

It’s still early days for Pyth, and the team behind Pyth (Jump Crypto) is A+ which will ensure the robustness of the network, which also presents a strong bull case for the Pyth network. If executed correctly, then the end crypto consumers can harness the power of DeFi coupled with the speed and reliability of traditional markets.🚀

That’s all folks!

— Thanks to Yash Agarwal for helping with key concepts and reviewing this article.

.This was a deep dive into the Pyth Network and how it is solving for the backbone of the numbers we see and movements we experience in dApps. If you find it helpful or want to suggest anything feel free to reach out to me at @inSitesh on Twitter.

Until then…

Sources:

Solana DAO tooling: Ecosystem, Challenges and Opportunities

Sitesh Kumar Sahoo — Sat, 24 Sep 2022 05:30:09 GMT

In 2021, DAOs started picking up rapidly with a common narrative, that DAOs would be huge and every web3 organization or even Web2 company would eventually be DAOs. We saw every kind of DAOs from Social DAOs to DeFi DAOs to Investment DAOs to Service DAOs, getting built. This led to the “Pick and Shovels” thesis, which was inspired by the famous gold rush of the mid-1800s, where Hundreds of thousands of hopeful gold miners headed west in the hope of making fortunes. This was a risky bet, as not all of them would be successful, but the best way to profit from this gold was to sell these prospective miners the tools with which they will mine gold — “Pick and Shovels”. Similarly, crypto is the new gold rush, and DAOs being the hottest, everyone started building “Pick and Shovels” for DAOs by the end of 2021.

The result? In just a span of a few months, we came down to saying: “There are more DAO tools than DAOs!”. Fair enough, indeed there were many “DAO tooling landscapes” flowing around on Twitter, and yet DAOs are still struggling to manage even basic operations!

In this deep dive, we will discuss and see an overview of the tooling landscape in the Solana ecosystem (with the top 36+ tools), the missing gaps in them, and what are the challenges that need to be solved for DAOs.

This essay is structured into the following parts:

Introduction- DAOs and DAO tooling where are they now?
An In-depth list of tools (What are they, features, How to get started, etc.)
The challenges and opportunities in the ecosystem (The fun part)
Conclusion

We will keep this direct, easy, and actionable. Let's dive into it 🚀

Solana & DAOs

We are seeing a lot of DAO tools getting traction in Solana. To understand them better, we can categorize various DAOs tooling as:

Discovering DAOs: Product Hunt for DAOs
Infrastructure for DAOs: AWS for DAOs
Talent Liquidity: Linkedin for DAOs
Productivity and Collaboration: G-Suite for DAOs
Payments-focus: Stripe for DAOs
Fund Management: Banks for DAOs

Note: The Categories are just here to put some structure and for better discoverability. There are many tools that might overlap with multiple categories but here, we tried to list them exclusively to their core functionality.

Discovering DAOs: The DAO Marketplaces

While these necessarily don’t categorize as DAO tooling, but these serve as excellent DAO discovery platforms, where contributors can explore different DAOs, just like you check out different products in Product Hunt based on different categories, reviews, etc.

Here are a few of them:

DAOHQ
It lets you discover 1000+ DAO — a one-stop-shop to find, invest and vote in DAOs.

DAO DAO
(DAO, DAO) is a Web3 social platform that allows you to start, fund, and trade DAOs. Imagine Reddit + Kickstarter + Coinbase, but for DAOs.

CREW3
Onboarding flow for contributors, data drive automation to reward active contributors, community spirits, events, analytics, and API to reward members inside their apps.
Truts
Truts makes it easy to discover top DAOs in their space by reviewing them. It’s 100% on-chain: 600+ verified communities listed with 350+ reviews.

Truts

Discover DAOs
Find anything there is to learn about DAOs and discover among the numerous DAOs listed on the site.

Infrastructure for DAOs

These are the tools. which gives the infrastructure for DAOs to launch their Tokens which are essentials to their DAO and to help them build their native organization.

Grape

Grape lets you create, reward, and secure any online community by using Solana.
Users gain access based on their wallet balance and the tokens they hold. Grape can be integrated with your Discord ID, so now can get access to some DAOs’ discord and get the roles based on the tokens you hold. The data is stored on Solana, so it is very easy to restart the community again with the existing people’s wallets.
They have also won second place in the Solana Hackathon that happened in May 2021.

Solsanctuary

Empowers community-led DAOs with the tools and resources they need to take over and decentralized abandoned or rugged projects.

Upside

Upside helps to securely launch and manage tokens for the building blocks of web3 native organizations.
Upside has helped companies like Cere Network, Republic, DappRadar, Chingari, Freshcut, and many more to create, launch and manage over 1 Billion tokens, distributed to over 700K blockchain accounts.

Talent liquidity

More than just tools, these are the best ways to learn, earn and build in the ecosystem.

Here you can find full-time or part-time opportunities, Grants to build any projects or bring value to any idea, and Bounties. Do check them out.

Questbook

Questbook provides a decentralized solution to grant management. In Guestbook, you can run grant and bounty programs for DAOs and foundations.
But questbook has another track called Openquest where you can learn to code and build in web3 using Solana, Ethereum, and Polygon.

Questbook.app

Superteam

Superteam is a cooperative of creatives, developers, and operators who are experienced in launching and growing technology businesses. SupeteamDAO helps the most promising projects in the Solana ecosystem in the ascending world (India, South East Asia, Eastern Europe, and Africa) launch and grow.
To get membership into SuperteamDAO you either win a Bounty or a mission (A freelance gig ranging a certain duration) or win an Instagrant (Grant given by some sponsors).
Superteam is known for its talent and the amazing projects coming out of it and understandably so. In fact, this deep dive submission is for a Superteam bounty.
Building on Solana or want to go full time into Web3, do check out superteam.fun and earn.superteam.fun for earning opportunities.

Layer3

Layer3 is a platform that enables anyone to contribute to a DAO. It provides a marketplace of bounties where you can earn in tokens and by completing/doing things regardless of your skill.
There are multiple communities and various tasks listed on their site as bounty, which people can complete to learn crypto and earn in crypto.
They have partnered with multiple projects. They started in June ’21 and till now, users on LAYER3 have made more than 2million+ on-chain transactions and many have started their Web3 journey.

Backed by world-class builders and loved by the community. Do check them out if you want to earn while you learn.

Productivity and Collaboration

Most DAOs have difficulties doing tasks efficiently. Effectively coordinating work when decentralized is challenging and does not come easy. There must be procedures, agreements, and collaboration. These tools help in doing that.

DeWork

A web3-native Trello with token payments, credentialing, and bounties.
Has raised $5 million from paradigm, pace, and many investors. Multiple DAOs and bounties get created frequently on the platform.

The Dework Graph of Work- Every circle is a contributor and the size is determined by the number of tasks completed by that contributor.

SourceCred

SourceCred is a tokenized protocol that allows communities to track, admire and reward project and community members, according to flexible, self-set parameters. Tl;dr- Contribution measurement and community governance
It is an open-source tool for communities to measure and reward value creation and organize communities
Makes it easy to onboard new contributors into the DAO seamlessly and makes it easy to manage them
It is easy to integrate with other tools and platforms of your choice and get started with your DAO operations.

Dilect

Dialect is an open-source smart messaging protocol for dynamic, composable dapp notifications and wallet-to-wallet chat.
It provides an alternative way to communicate with DAO members outside of tools like Slack and Discord in a more personalized manner, which may increase the communications across DAO members.
Some of the features include Wallet-to-wallet chat, in-dapp notifications, Email, and SMS.
And now it is powering the messaging and notification for Solana’s biggest projects

Dilect is Backed by leading investors, Multicoin Capital, Tiger Global, Jump Crypto, and many more.
It is entirely Open Source, developers can get up and running with tools quickly with few lines of code. Check out their GitHub.

Reputation-based tools

While building a community, having a value-measuring system is important. Especially in DAOs contributors can be rewarded both monetarily (through tokens) and abstractly (reputation in the DAO). These tools help you get rewarded based on your on-chain reputation.

Underdog Protocol

It helps people to build their on-chain network to reward & recognize their biggest supporters by launching their tokens on Solana. Think of it like Linkedin Kudos.

Backed by Forge, One Block, Techstars, and more.

xHashtag

xHashtag works with Web3 projects by helping them build and grow a reliable community, and uses the large user base towards the project, by rewarding them with non-transferable achievement credentials called #SoulSwags for their contribution to the project in terms of task and campaign completion.
Backed by Titan Ventures, SOLRAZR, KuCoin Labs, ZBS Capital, and many more investors and advisors.

There is another open source tool called Civic, which revolves around Onchain Identity Management.

Decision-making and Governance

In the context of DAOs, governance proposals refer to the mechanism to carry out any type of modification to the protocol held by the DAO. Members of the DAO normally need to have a specific amount of the token before making any proposals, and changes are often suggested through modifications to the smart contracts that govern the protocol. Depending on the aggregate vote cast by DAO members, these modifications are passed or refused.

Tribeca

Tribeca is a protocol for creating, managing, and interacting with DAOs on Solana. It is an open-source governance primitive built and maintained by members of Solana’s leading protocols.
Integrations and DAOs getting launched for many protocols, including Saber, Friktion, Port finance, Arrow protocol, Acumen, and more

It is heavily inspired by the designs of Compound and Curve governance.
Their code is unaudited and they have been inactive for a while on their Twitter and discord. Tribeca is pluggable with other Anchor-based projects and tools, allowing for greater composability. Check out their docs to know more.

Realms is another governance tool, you can find it in the All in one tools section of this essay.

Payments-focused tools

These are generally used for token distribution & vesting and payroll.

Streamflow

Streamflow is a token distribution platform that provides teams with the necessary tools to manage their treasury and distribute value (Streaming payments and on-chain salaries) with ease.
The TVL is 130+ Million with 30,000+ Streams and 170+ Tokens. It is backed by prominent investors including Jump crypto, Solana Ventures, etc, and is used by projects like Port Finance, Hubble protocol, Jungle finance, Nosena, and more.
You can build Integrations on top of Streamflow too. Check out their SDK and docs to know more.

Zebec

Zebec is a continuous settlement protocol on Solana. It is enabling the composable transfer of value starting with Zebec Payroll and Zebec Safe is fully customizable multi-sig on Solana. Think of this as “Gnosis safe”, but for Solana.
Zebec allows employees to seamlessly convert their real-time liquidity to fiat currency via custom metal debit cards. Audited by CERTIK, it becomes the go-to platform for organizations or DAOs trying to do Multisig Treasury Management and Streaming Payments
It is backed by investors like Solana Ventures, Lightspeed Ventures, Alameda research, and many more. Till now, they have partnered with Katana and Tribeca and has their own native token.
Developers can build with Zebec Protocol by using their SDKs to easily implement Zebec Pay features directly into your projects.

zebec.io

Liquify

Making it easier to manage token distributions, compliance, and track vesting schedules.
Audited by trusted firms like Macro, Quantstamp, and Sherlock, and used by Companies like balancer, Indexcoop, Superare, and Snackclub.
Liquify is backed by investors like Dragonfly, Nascent, OrangeDAO, Robot ventures and angels like Balaji(Former CTO, Coinbase, and GP at a16z), Packy McCormick (Not Boring Capital), Anthony Pompliano (Pomp Investments), and many more such individuals.

Liquify.finance

Managing the fun(d)s

These are typically used for Treasury management i.e managing the treasuries of DAOs, either in storing the assets or giving yields from these treasuries. Treasury management is an important component of the DAO since it ensures organizational transparency. Every member may then see and contribute to the direction and diversification of funds inside the treasury as they move hand in hand with governance ideas.

Let’s take a look at a few of them:

Squads

With Squads, you can securely manage your treasury, program upgrades, and tokens with your DAO members.
3000+ Multi-sigs deployed till now
Audited by OTTERSEC and BRAMAH SYSTEMS.
Loved by the ecosystem and recently they launched their V3 which is more secure.
Their SDK provides classes and utilities to make it easier to interact with Squads programs. || Their docs
Live Yes || Open source — Yes

Goki

Goki provides an interface to create, manage, and audit multisig wallets on Solana. Keywords: ‘Secure’ and ‘Easy’
Recently partnered with Cashmere Wallet, Query protocol, Atrix protocol, and TribecaDAO Governance. (more info on their Twitter)
It’s not public yet, but you can join their waitlist on their site.
Live NO || Open source — NO

Castle Finance

Castle Finance provides a safer way to earn yield for DAOs and their communities with their DAO native custom vaults.
The USDC vault gives out a ~2.8% and has over $301k+ in TVL.
Apart from that, Castle Finance has also Integrated with Cashmere Wallet to give seamless yields to users and teams.
Backed by Solana Ventures, Nascent, Shima Capital, and many more partners.
Live yes || Open source NO

Katana

The Katana protocol enables users to passively access the best risk-adjusted yields in the ecosystem by offering a suite of packaged yield products across the risk spectrum. This makes Katana THE yield generation layer for Solana.

Friktion

Friktion offers DeFi-powered, risk-adjusted return generation strategies for DAOs, individuals, and traditional institutions through institutional-grade structured products and risk management.
It introduces cool concepts like Volts and Circuits into the DeFi ecosystem, which offers both active and passive portfolio management strategies.

Unique.vc

Unique Venture Clubs is a no-code platform that allows people to pool resources, establish custom on-chain governance structures, and collectively own assets. Lets you create or join web3 investment clubs to purchase and manage assets on-chain.
They are building the infrastructure and the tools that allow people to pool resources together, eliminating financial, technical, social, and trust hurdles.
Supported Assets currently are NFTs and Fungible tokens and many more coming soon.
Audited by ZOKYO, they are backed by investors like Solana ventures WW ventures, MEXC, SVC, and more. Other projects like Grape, Bonfida, Streamflow, Magic Eden, etc., have partnered with Unique.vc.
Live yes || open source NO

Cashmere Wallet

Cashmere wallet lets teams or DAOs manage treasuries through multisig actions, you directly send, receive, and grow your digital assets in the Team vaults.
The platform has also integrated scheduled payments, many integrations across the Solana Ecosystem, and Slack notifications. They have also promised a fully functional SDK which might come soon.
It is Audited by Ottersec and trusted by managing treasuries for Opensea, Million on Mars, Fast Break Labs, etc.
To explore IDL methods, Check out their docs

MeanFi

Teams and organizations can create crypto corporate treasuries, issue vesting contracts to investors, and operate payroll operations using real-time money streams. Mean Fi enables this with its no-code Token vesting, Crypto payroll, and Safe Multisig solutions, as well as its DEX with HLA providing DDCA.
Backed by 16+ institutions and 100+ treasuries, MeanFi becomes another solution for treasury management, Payroll operations and token vesting.
Another example of multi-sig is Ownbit.

Data, Data, and Data

These are tools that let your gather data from on-chain sources. You can analyze them to get better insights and test your instincts about a certain topic.

Dune

Dune Analytics is a data platform that analysts and investors use to research specific projects such as NFTs, DeFi platforms, DAOs, or any blockchain ecosystem.
Anyone can query the data and create visualizations using Dune.

Deep DAO

DeepDAO collects and organizes a variety of quantitative and qualitative data about DAOs governance, their structure, people, and decision-making. It currently serves interactive data dashboards, project descriptions, a DAO Tools go-to, and a governerds’ discord channel. (source: Deep DAO)

Flip Side Crypto

There are learning materials and many bounties listed through which you can earn and learn various things and data analytics and SQL.

API key to the most comprehensive blockchain data in crypto. Query on-chain data from most of the blockchains available

The all-in-one tools

Crypto is built upon the promise of data that is open to anyone to use. Which not only makes it very open but also makes it very composable to build on top of them. Apart from the previous categories, there are some tools that give the one-stop solution (mostly) to create, manage and operate a DAO. On Solana, this is one of the few that exist.

Realms

DAO creation, voting, and treasury management, all in one fully on-chain product. Realms has all the tools for that.
You can invite members(Cardinal Twitter integration), and vote on proposals, apart from these, it has tools for treasury management, identity management, and analytics of those actions, all under one platform.
Realms is also managing some of the biggest projects of the ecosystem.

Few more exciting tools to look out

Tools that didn’t make it to the list but are worth giving some attention.

Parasol Finance

Community-governed IDO platform built on Solana serving both the Investors and the projects.

Celesta Labs

DAO onboarding and context management. For Causes & DAOs it helps in creating social impact by donating tokens and you receive Impact NFTs that certify your donations on-chain.
Available on other chains like ETH, Polygon, etc. yet it is not on Solana, but something like this is good to have in the ecosystem.

Challenges and Opportunities 🛠

We saw the tools across all the categories, what they are solving for and how many are there.

But one thing that is still visible is that not all of them solve all the needs of a DAO, especially in a Solana landscape. That takes us to the Challenges (opportunities!)

In a nutshell

Challenge 1: Technical challenges

Cross Platform Collaboration
If you are using multi-sig tools like Realms or Squads then you should be able to the ability to collaborate on documents with platforms like Wordcel.
For example, same idea can be applied to DeWork <> Squads <> Wordcel, DAOlens <> Realms and the list can go on.
Cross-chain Collaboration and On-chain collaboration
For example, if there are multiple contributors in your DAO yet you want to publish articles on Wordcel, how would you do that? Definitely, you don’t want to share the wallet (A big NO)

Then what strikes is, to have integrations for the Workplaces from the governance or treasury management sites to work with wordcel. If you are added as a member there you should be able to publish on the DAO’s publication

Another thing is collaborative publishing which lets more than one people collaborate on any media and it is on chain.

These types of purely speculative imagination and data interoperability can open up possibilities that we have never calculated and change the way we use applications in Web3.

Challenge 2: Payments — a critical missing piece in the puzzle

While crypto by default solves for the payment rails, DAOs face a lot of hurdles in managing & automating payments, often resulting in late payments & multiple follow-ups. Sometimes, DAOs give out payments in their native tokens, which are very volatile. We have also heard often contributors find it hard to off-ramp and prove their crypto income as a reliable source of income. Further, many active contributors find it hard to get their expenses made for DAO projects like SaaS spending, Travel expenses reimbursed seamlessly. All this leads to poor DAO-contributor payments experience.

Potential Solutions: To solve automation issues, achieving operational efficiency via payment request links, scheduling payments, and expense management tools are critical. Corporate Cards are another solution, where all active contributors of DAO can be issued a card, and they can spend for all their business needs like SaaS expenses or Conference tickets, via the card itself. Web3 counterparts of Web2 tools like Expensify, Gusto, Brex are yet to be built and when these tools will be built, it will attract much higher interest for companies to operate as DAOs.

Mesha is an interesting solution

Challenge 3: Building a grant ecosystem and platform like Gitcoin on Solana

There are a lot of open source projects with issues and bugs which can be approached through bounties or community funding for projects that the ecosystem needs.

The existing system of grants and bounties results in appropriate VC investment being allocated to one specific project. This distorts the priority of Solana’s communities.

Creating something like Gitcoin Grants is more of a socio-philosophical problem than a technological one. Most of the Ethereum projects like Uniswap, Aave, and Polygon regularly engage in the rounds because of their strong belief in supporting public goods. Essentially, their viewpoint is consistent with that of the greater Ethereum community.

Vitalik also points out large initiatives that do not participate in supporting public goods on a regular basis. And till now we haven’t seen any kind of philosophical movement around public goods in Solana. That’s the need of the hour, the need while building a better ecosystem.

Challenge 4: The legal structure for DAOs

How can a community achieve legal clarity?

DAOs are similar to many organizations like corporations, non-profits, partnerships (including both general and limited liability), and co-operatives. But these organizations are all regulated and governed by the rules of where they exist.

Whereas there is nothing sort of exists for DAOs, they are purely decentralized lacking a particular place, and the governing rules are not specific to any existing legal framework. Today DAOs from across the world battle with regulatory issues such as taxation of DAO tokens, treasuries, and investments, how to get insurance on investments, implementing other policies, etc.

Though this is not entirely a tooling problem, once there is some legal clarity in any region, it will act as a precursor to a huge range of tools catering to the legal needs of a DAO.

Challenge 5: HR solutions for DAOs

I know you might be thinking, are we back to Web2 again? Nope, there is more to it.

Aside from the legal challenges of DAOs, there are also complicating factors about the best methods for hiring, onboarding, and managing a team.

With the newness of DAOs, finding and vetting talent that is well-suited to work in the largely ambiguous and self-directed jobs accessible in DAOs is tough. DAOs that do not have connected organizations must also figure out how to address the legal complication of engaging in a connection with talent when there is no counterparty to engage in employment or contractor agreements with or to guarantee talent does not reveal secret information.

Teams in the DAOs find it tedious to convey institutional knowledge to new members once joined, hence DAO core teams frequently end up accountable for the majority of operations. Given the transparency of DAOs, this may appear contradictory, however, due to the rapid shift of DAOs, these firms have had difficulty documenting their internal procedures, making it difficult to onboard new members.

After being onboarded, DAO core teams must determine how to manage personnel, which may be difficult in a flat structure and even more difficult when a group is attempting to portray itself as highly decentralized.

Conclusion

Tools can NOT solve for the communities without a common objective, intention, and value system. While the market is still not very big for DAO tooling, the space will continue to evolve. Just like first protocols were built, and then came the applications. Similarly, we believe that, Tools will get built first and DAOs/Web3-native organizations will get built with help of DAO tools. DAO tools will essentially attract many organizations to be Web3-native, as they get more and more efficient. Overall, we believe Solana is one of the perfect chains, ripe for disruption, given a vibrant community & ecosystem.

It will be excited to see, how the Web3 organizational stack gets built from here on🚀

That’s all folks!

— Thanks to Yash Agarwal for helping with key concepts and reviewing this article.

This was a deep dive into the wilderness of DAOs and the tools that wrap them together. If you find it helpful or want to suggest anything feel free to reach out to me at @inSitesh on Twitter.

Until then…

You can read this essay on-chain only on wordcel.

Sources

State of DAO tooling on Solana by Aditya Shetty
Contributor payments experience in daos challenges and opportunities by Yash Agarwal
DAO tooling in solana: what can we expect in the future? A deep-dive with-solanaFM
All the links to the respective tools are hyperlinked with the name itself.

Deep Dive : Solana Mobile Stack & Saga

Aditya Shetty — Sat, 17 Sep 2022 09:44:18 GMT

In this essay, we deep-dive into the Solana’s mobile stack & Saga - the flagship phone they are building with the team @ OSOM. Thanks to Austin Federa, Shek_Dev, Srijan & Anoushk for discussions that contributed to this essay.

TL;DR

Mobile matters. 4G >> Wifi , Mobile >> (Laptops + Desktops + Tablets) when it comes to adoption. For Crypto & web3 to go mainstream, it needs to go mobile.
Web3 is a paradigm shift: money is baked-in & self-custody is the norm. Traditional phones are not optimised to provide for the design & security needs of the use cases that are now possible. Signing transactions directly through your phone is a super power.
Key features of the Solana Mobile Stack: Seed vaults to secure the private key at the device level. Mobile wallet adapter to standardise signing UX across dApps. Solana Pay support for Android - with tap & scan to pay. A dApp store that doesn’t feel like a toll booth.
Any android hardware manufacturer can use the Solana mobile stack SDK to launch a crypto-native phone. Any software developer can build apps on top of it. It is open-source & permissionless. Saga by OSOM is hopefully the first of many.
Get Involved : This is your chance to shape the future. A privilege often reserved to a small group in a small part of the world. Skip ahead to the RFP section for ideas on what makes for a great grant application.

Why launch a phone?

The first question that comes to mind is, why does Solana or any other blockchain for that matter, need to launch a phone at all? Android & Apple smartphones have seen parabolic growth over the last decade. They are cheaper, faster & more performant than ever. So, why would someone need to launch their “own phone” ? What exactly is a “crypto phone” ? And how on earth will it compete with Apple & Google????!

We’ll answer this question in two parts.

First, if crypto & web3 has to go mainstream it has to deliver a world class mobile experience.

It is generally accepted that mobile phones have provided billions of people access to the internet. But I think we under appreciate that for most of these people a mobile phone is the ONLY way they access the internet.

Here are some stats to really drive home just how far ahead mobile adoption is globally compared to broadband connections. India has a total of 17.8 million broadband connections, amounting to 1.33 connections per 100 people. We also have 1.2 billion cellular subscriptions, amounting to 87.3 subscriptions per 100 people. Brazil has 113 cellular subscriptions per 100 people & 13.7 broadband connections.

Source: Wikipedia

While the trend of higher mobile subscriptions per 100 people is generally true across all countries, the extent of difference is particularly stark for developing countries.

The reason for this is obvious - having a broadband connection is expensive. Let’s quickly estimate the cost of this in India. First, you need a laptop which will cost you ~$700 on avg. The most basic broadband plan will cost you ~$7/month. Along with this you need a stable electricity connection & a workspace where you can use this setup. Most people have access to neither. Developing countries have larger household sizes & lesser sq. ft per person. Lastly, you need a permanent address with the required documentation to get a connection. On the other hand, the avg cost of smartphones is ~$200, a prepaid cellular data plan of 1GB/day for 9 cents.

This should help establish that the future is overwhelmingly mobile. Existing devices like laptops, tablets have lost the race for global adoption (while remaining obviously useful to many people, like you & me). More immersive devices like headsets & glasses will need to first achieve mass adoption before they can stake a claim on our metaversal future.

This brings us to the next section, it is impossible to deliver a great crypto experience on traditional Android & Apple devices.

Crypto Native Phone Design

We’ll break this down into three sections - security, design & app distribution.

Security

The most important & novel concept in crypto is the ability to self-custody digital assets. This includes your NFTs, tokens and even your data. We do this by signing messages with our private key. A user can & will have many accounts each having their own private key. These accounts are set up and operated through wallets. A recovery or seed phrase provides root access to all accounts in case a user forgets their password. If you or your wallet leaks access to your seed phrase, anyone can access your wallet and steal your assets, NFTs, data etc.

This is what happened in the recent slope wallet hack. The wallet was sending user's “private key material” unencrypted to a logging service from where it got hacked. So, not only did people lose access to the wallets they created with slope, but ANY of their wallets that shared the same seed phrase.

The team at the Solana foundation argues that this shouldn’t have been possible in the first place. All devices have something called a Secure Element. This is a dedicated part of the hardware that can’t be manipulated externally beyond specific interactions. This is how our biometric data is secured by existing Android & Apple phones today.

And while the capability to do this exists, it can only be done at the OEM level. So, the team at Solana could either lobby android, apple & hope that they listen OR build their own phone and distribute it at sufficient scale which forces larger players to listen.

So, that’s reason #1 : Only by working directly with hardware manufacturers can we ensure adequate security of the seed phrase. This ensures that no wallet or dApp can accidentally or intentionally leak it & compromise all associated user assets and wallets.

This is a UX unlock disguised as a security feature. Today, apps require you to open up your wallet to sign a message. On the Saga, they can interact directly with the secure element via an API. This will reduce the friction in carrying out on-chain transactions from within rich applications significantly.

Apps like StepN have achieved this UX today by implementing their own in-app & on-chain custodial wallets. But it is far from ideal. You need to set this wallet up separately & maintain another seed phrase. You can then transfer assets to & from this wallet. Alternatively, you can rely on deep-links provided by wallets. This doesn’t scale because not all wallets may provide them. They will be non-standard across different wallets. And may not encompass all the functionality required by your app. Or import a wallet by manually typing in the seed phrase.

Using the Solana mobile stack, you can basically use your device to sign messages. So each app won’t need to build and maintain a custom wallet, nor will we need to rely on access via deep-links or QR codes from a few wallets. The mobile wallet adapter standard will provide seamless & secure authorisation.

Design

There are two fundamental design assumptions baked into our mobile experience today. The first one is the process of authentication & authorisation via login. The second is the movement of financial assets across products & services.

Let’s start with authentication & authorisation via login. The fundamental assumption in today’s software is that data & code is hosted by the corporation owning the application. Users “request” for access to their posts, tweets, and social connections by logging in. Developers access this data via well defined APIs & publish through an approval process set by the corporation.

I’m not making an ideological comment here, but a technical one. Today’s software is optimised for a single authority reading & updating all code and data within an application. And don’t get me wrong, we’re living in an era of apps far superior to anything we’ve seen so far. But to paraphrase the famous saying - what got us here won’t us there. This design does not scale for apps & protocols that are built around the principle of self-custody.

Apps built using crypto & web3 principles don’t claim ownership over access to their user’s data. The most critical elements will be hosted on a public blockchain (like Solana) & secured through a user’s wallet. Each time you want to access an app, you will connect and provide it access to your data. Another app developer can just as easily request a user to connect their data to a new application they’ve built and also update it. All of this does not require any permission from the application where this data was originally generated.

This is why the ability to authorise transactions using your phone is a superpower. Today “login with google/apple” is a ubiquitous pop-up on our phones and the dominant way of authorising access to our apps. In the future it’ll be via our phone as a universal wallet (see the minting experience in the video below the image).

Source: Google Developer Docs

Flow of money

The great thing about today’s consumer apps is that they’re mostly free to use. This has been critical to achieving mass scale & connecting billions of people. Advertising was the dominant business model of the internet. With platforms like Google, Meta, Amazon & now Apple, Netflix are the ad exchanges. Through their product innovations and network effects they became custodians of our attention & data. Thus effectively dictating terms to advertisers on the various ad formats, targeting methods, pricing models. This allows no room for direct interactions between brands and customers.

Web3 powered apps will most likely still retain advertising led business models but reduce the power of the ad exchanges by transferring ownership of the most valuable asset (data) back to customers. Brave is already pioneering this approach by enabling direct financial interactions between advertisers & customers. Multicoin Capital wrote about the idea of DataDAOs, which have the potential to collect large scale consumer data while allowing people to retain control over how it is used & a share in the financial value derived from it.

The second business model of the internet is subscriptions. A way for consumers to directly pay for the services they want to use. This is accessible to a much smaller and relatively affluent set of people. Today, mobile app subscription transactions are allowed to happen only via the respective app stores. The payment methods used are restricted to the ones supported by these platforms & a 30-50% commission is charged on each transaction. This is why many services like Netflix don’t support purchases through the app store because they feel like they don’t really depend on the app stores for discovery. Subscriptions are typically rigid, billed monthly or annually. Transactions are always structured between the corporation owning the app & the users, never peer to peer - leaving massive value on the table. Reward programs attempt to fill this gap by (trying to) gamify app interactions and assigning an internal token value. Even these aren’t p2p, have limited spending sinks and are unusable outside the originating app beyond some vanilla “partnership” deals. We spoke about the limitations of today’s approach and possibilities of a crypto-native loyalty program in this essay.

In crypto, everything can be a financial asset that flows seamlessly through products. I’ll reserve comments on whether this is good or bad, but it is happening. This makes today’s advertising and subscription models look limiting. Real-time streaming of tokens as payments, NFT-gated content access powered by infinite asset types freely tradable between people and apps will unlock a new paradigm of interactions that our existing infrastructure can’t support.

That’s reason #2, self-custody of data & assets requires a signing entity (wallet) to be built into the fabric of the phone.

App Distribution

After reading the previous 2 sections, this is the most obvious next limitation that comes up. Publishing an app is entirely at the discretion of Google & Apple. There have been sufficient instances of apps being delayed, denied approval or taken down. The business model & incentives are misaligned too, as Chris Dixon outlined in his essay on Why Decentralisation Matters. Platforms want to maximise the value they can extract, while publishers want to pay the least possible. Often platforms can entirely vertically integrate into categories where they see potential (like Google or Apple Pay).

Source: Mid Journey

I feel for the teams facing the brunt of these tactics but I don’t think these matters are going to be settled in the court of law. These platforms are corporations designed to maximise value to their shareholders. They have built the largest and most thriving ecosystems of our lifetimes, albeit with the help of apps. But they have God mode & they’re going to use it.

Reason #3, The best protest is to build a better alternative. A world where the app store is minimally extractive & more transparent.

So far, we’ve understood why mobile matters & what a crypto-native phone looks like. In the next section we’ll answer the question - what exactly does it mean to launch a phone ?

OSOM, Saga & the Solana Mobile Stack

There are two key components - the device (Saga) & the software stack (Solana Mobile Stack). While they come together in an attempt to build a crypto phone of the future, it is just as important to understand them separately.

The Saga is a phone being manufactured by a company called OSOM, led by Jason Keats. It is designed to be a standalone flagship android phone powered by Google mobile services & the Solana mobile stack.

Let’s take a bit of a detour & get to know the CEO of OSOM (or chief hooligan as he likes to call himself), Jason Keats. He has easily one of the coolest and unconventional backgrounds I’ve come across in a while. Started off with a degree in Astrophysics from Berkeley to call himself a rocket-scientist. After graduating he started a motorcycle company, worked on Solar Panels and then ended up working at Apple on the macbook air, ipad, an infrared camera and many other (to this day) top secret projects. An interesting anecdote from a podcast he did with Anatoly - the camera he worked on produced one handmade unit & sold for a couple of million dollars. If the owner ever uses it and needs to get it repaired - there’s a note in there saying “Call Jason”. He then went on to work at Andy Rubin’s Playground where he worked on Essential. And is now leading OSOM, building the hardware of tomorrow. In fact, he had never worked in crypto until their partnership with the Solana foundation.

The Solana mobile stack (SMS) is an open-source SDK that can be integrated into any Android phone by the OEM (manufacturer). Yep, that’s right - the team is building this open-source from day 1. Any Android OEM, today, can integrate the Solana mobile stack into their devices & compete with the Saga. You’ll probably get a grant from the foundation for that as well.

Quoting from their github page, there are currently 4 key features of the Solana mobile stack.

A seed vault: The Seed Vault is a system service providing secure key custody to Wallet apps. Your keys, seeds, and secrets never leave the secure execution environment, while UI components built into Android handle interaction with the user to provide a secure transaction signing experience to users.
Solana dApp store: It will provide a distribution channel for apps that want to establish direct relationships with their customers, without other app stores’ rules restricting the relationship or seeking a large revenue share. The goal of the Solana dApp Store is to empower the Solana community to eventually play a key role in managing the contents of this app store. One of the hardest problems to solve here will be finding the right moderation policy. While it will take time to nail this down, there will be significantly more community (developers & device owners) participation than there is today. Including governance structures & the ability for anyone to float a proposal to initiate a change they wish to see.
Mobile Wallet Adapter: Mobile Wallet Adapter is a protocol specification for connecting apps to Wallets on mobile devices. It allows Wallet apps to provide transaction signing services for different types of apps on mobile devices. The protocol is not limited to Android devices either; it envisions similar support for iOS devices, as well as the capability of Wallet apps to provide signing services to applications running remotely, such as on other mobile devices, and on desktop or laptop computers.

Source: Wallet Adapter Spec

Solana Pay for Android: A reference implementation demonstrating how Wallet apps can use the system features of Android devices to capture Solana Pay URLs via QR codes, NFC taps, messages, and web browser interactions to launch Solana Pay requests.

The primary reason why the partnership with OSOM is so important (apart from the fact that Jason seems like a legend) is that the SMS needs hardware support & access to the secure element we spoke of earlier, to unlock its full potential.

And this brings us to the next section, what’s the endgame here? Does the Solana foundation want to out-manufacture Apple & Google? If yes, then why open source your SDK? How will they ever compete with the manufacturing might of the existing players? What about all the other crypto phones?

The Endgame

The goal with the Saga is to demonstrate the power of the Solana mobile stack, by building an “unconstrained playground for crypto’s first 50k users”. Instead of continuing to operate within the limitations of today’s phones. The team believes this is a worthy tradeoff which will push the space forward overall.

OSOM is a private company & they do want to maximise the impact they can have with the Saga. At the same time they hope that as they achieve scale, competitors start taking note and integrate the freely available SMS into their devices. Positive sum thinking can be so strange.

Saga is (hopefully) the first of many smartphones built on the Solana mobile stack

Request for Proposals

If you’ve kept up so far, are excited about the future of a crypto native phone AND want to contribute to it - The Solana foundation & Superteam would love to support you.

The Saga is currently shipping to the US, EU, CA & UK. Importing it into other regions makes it prohibitively expensive. If you are an Android hardware manufacturer who wants to run SMS on their devices & ship them in your country - reach out to the Solana foundation or Superteam.

If you want to build applications, tools, infrastructure, etc. on SMS, you can apply for a Solana Mobile grant or a Solana foundation India grant.

What makes a good grant application?

Building core utilities that are necessary but hard to monetise (e.g. a free to use, open-source, mobile-native wallet)
Building infrastructure that helps others build better & faster (e.g. a gasless NFT minting layer)
Building apps with potentially high consumer pull (e.g. games like StepN)
You’re building as open-source as possible.

Here are 9 ideas to get you started:

A “default” mobile wallet interface: So far, wallets were our gateway to using web3 apps. Everytime you carried out an action on-chain you needed to sign a message through your wallet. Now, your phone is your wallet. This makes the core functionality of authorising transactions, viewing & transferring assets a feature not an app. This will push wallet apps to find other ways to monetise, just like UPI is forcing payment apps to monetise using lending, investing etc. An open-source wallet built on top of the mobile wallet adapter that users and apps can use is a valuable public good.
Gasless NFT minting : NFTs will play a critical role in onboarding new users to crypto. Especially as brands look beyond PFP sales & build user-specific NFTs with real utility. We illustrated a few examples in a recent essay about the FTX Crypto Cup. Simplifying the UX & allowing communities/brands to pay gas is key to a magical first onboarding experience (Even though gas is negligible, the experience of buying 0.0000000001 SOL is high friction). Candy Pay has built a no-code mint builder & gasless APIs that work with today’s wallets. Building this experience natively for SMS will be immensely useful to all the other apps.
Pokemon Go: Straight from Austin, a game where you can mint Pokemons based on your IRL location, verified by Helium.
An NFT Gallery: Today, our phones have a stock gallery app (mostly google photos). PFPs remain an important use case of NFTs. Some of the best and most valuable communities will be built around NFTs. There are many reasons why we haven’t seen a gallery take off yet - users typically split NFTs across multiple wallets, stake them, etc. With the phone becoming your universal wallet, a default gallery that displays all of your NFTs is a utility application.
A Web3 profile: An app that consolidates your identity across domain names, NFTs and other assets. Our web3 identity is being formed across the many different communities, protocols & dApps we use. Service that issue domain names is a first step in building a digital home for us. A mobile app that allows us to freely connect NFTs that represent proof of work, attendance, membership etc. has the potential to become the “identity” primitive on Solana.
A Camera app & creator studio: This is an idea inspired from Cini, a project that recently won 2nd place in the mobile track of the Solana Summer hackathon. A camera app that allows people to list their filters, designs, photos, reels as NFTs for others to use & compose on has the potential to drive the next generation of photo sharing apps.
A fitness app (primitive): Build an app that mints steps taken (& other movement) into an NFT. This can become a fitness primitive used by many other apps & services.
Social publishing: An editor that lets you publish to protocols like wordcel, spling, etc.
Location based rewards service: An app that allows people to complete location based tasks for rewards, all verified on-chain. data entry for maps, reviews. E.g. tag information on hivemapper, aggregate reviews, unlock rewards, etc.

Applying with these does not guarantee a successful application. Neither should you constrain yourself to these ideas. This is just meant to help you get started. The possibilities are endless…

Disclaimer: This post is not financial or investment advice. It is meant for informational & educational purposes only. Please do your own research about risks and compliance before buying, investing/ or trading.

Cover image source: Mid Journey

Deep Dive: Capx & Community Bonds

Aditya Shetty — Mon, 08 Aug 2022 07:56:33 GMT

One of the biggest promises of crypto and web3 is it opens up access to ownership upside to a lot more people. Public blockchains have tokens natively programmed in. These tokens can be used to pay fees, accrue value & gate access. Holding & using tokens is easier & more useful than traditional equity. Equity has no applications beyond representing ownership. It is also separate from the underlying product or platform, for e.g. holding AirBnB shares doesn't seamlessly allow you to stay at one.

This is a major paradigm shift. Ownership is not restricted to founders, investors & a few early employees. Contributors, developers, community members, creators & even consumers can have meaningful ownership of a product or network.

But, this shift brings its own challenges. Because it is easy to raise capital from the internet, a lot of people did it. This resulted in the ICO boom in 2017. Many of these people were looking to make a quick buck - raising funds in the name of projects & then disappearing. In other cases, projects failed despite good intentions. This resulted in retail investors being more cautious. It became harder to raise public funds without a working product or past credibility. To be clear - increased caution is a good thing. It signals maturity from a newly created class of investors.

As the technology & use cases emerged, private capital started to flow in. Venture & hedge funds, angel investors, and large institutional investors operate differently from the current retail investor. Professional investors have larger time horizons and higher risk tolerance. They also bring credibility to early projects and unknown teams. Founders increasingly started raising private capital before doing public sales. In 2017, a public sale happened on day 0, before a product or community existed. Now, projects wait for anywhere between 6 - 18 months before opening up token sales to the public.

Fundraising in web3 & crypto will mature over the next few decades or so. Community & retail investors will get increasingly sophisticated. We're seeing early signs of this in the form of gaming & investment DAOs. Crypto native private investors recognize this shift too. Many of these funds are setting up research teams, running validators, building deep technical skills, etc. All of this is in pursuit of keeping up with evolving fundraising landscape. It seems unlikely that either retail or institutional capital will edge out the other. Instead, they will each find their place in an increasingly open fundraising environment. In the short term, the more sophisticated private investors will continue to enjoy early and exclusive access. A few savvy communities will start operating as efficiently as their professional counterparts. No one knows what the end state will look like. But it feels like we will head towards a more accessible and level playing field compared to what we have today.

With this in mind, I spoke with Vaibhav Tyagi about what they are building at Capx, including their latest product - Community Bonds (CBDs).

Let's dive in.

Capx: Making secondary markets great again

Here's the Capx mission statement from their website.

"We at Capx are building the infrastructure & tools to make the secondary markets of crypto - more efficient and accessible. Our ecosystem comprising of Capx Liquid, Capx Exchange and Capx Lend will make these markets more accessible for the community to participate and the projects to build on top of it"

To understand what this means, let's first understand how the fundraising process works & the importance of vesting. Simply put, a project receives cash from investors and provides them with tokens. The idea is that as the project delivers, the tokens become valuable - making everyone who holds them rich in the process. To ensure that the founders and investors are committed to this for a reasonable period of time - tokens come with time-bound lockups. This prevents anyone from immediately dumping the tokens. It also signals the seriousness of the founding team to the investors. However, this means that founders & investors often have a major part of their wealth locked up. Their first product, Capx liquid, addresses this problem with wrapped vested tokens (WVTs). It enables the discovery and trading of these locked-up tokens.

First off, as an outsider to the world of investing - ngl, I found this a bit odd. Why would you want to create liquidity for something that was supposed to be illiquid by design? On digging further, I learned that there are three reasons why someone would want to sell locked-up tokens:

Secure principal (and some upside) from short-term price appreciation
Liquidity needs that are unrelated to the health of the project
Loss of conviction in the project as an investor

These are legitimate use cases. In fact, it is common practice in traditional companies to carry out the sale of unvested stock. This happens to make room for new investors (early, smaller investors exit this way) or create some liquidity for founders and early team members. Although uncommon, it is also a tool for investors with more conviction to enter and replace existing ones who may have lost conviction. In the absence of proper infra for this in the crypto space, founders and investors resort to opaque p2p & OTC deals. This creates three problems - price discovery, operations & information asymmetry.

WVTs can solve the first two of these problems. Tokenizing these illiquid positions makes it easy to quantify & price them. Anyone can then trade these on the Capx exchange or any other DEX. To be clear, the project token & rights associated with it still remain locked. What you are trading with these WVTs is ownership of the locked tokens. However, it is non-trivial to solve the problem of the asymmetry of information. In the long term, if sufficient verified information comes on-chain it is possible to establish a source of truth. This makes project performance available to anyone. We are far from there today. Currently, the team is expecting sophisticated investors to be trading in WVTs. They are well equipped to carry out their due diligence.

Using Liquid & WVTs. There are two ways in which projects can use Capx liquid to issue WVTs. The first one is through a no-code interface. The team only needs to upload the token allocation details (addresses, amounts, price, schedules). In the background, the tokens get locked up in an escrow contract & WVTs are issued against them. This approach works well for teams that want out-of-the-box features. It minimizes development required from the project. The second option is to build on top of the liquid smart contracts. Because these are open source, anyone can use them. You don't need to speak to anyone from Capx (i.e. permissionless ). This works better for more custom use cases. Liquid is live on Ethereum, Polygon & Avalanche. Their focus on being multi-chain means that projects can issue WVTs across all networks they are deployed on in a single raise.

Capx Exchange & Lend are two other products the team is working on. These are logical extensions to liquid. Once you’ve created a new asset you want to create infrastructure to enable its trading & lending. You are not restricted to using just their exchange or lending platform. Like any tokens, these can be traded or used as collateral across the Defi ecosystem. You can also build on top of these smart contracts for any custom implementation you may need. These projects are yet to be fully launched.

Broader Applications of WVTs. The infrastructure for pricing & trading locked-up positions opens up a lot of use cases for projects. For E.g. projects prefer to provide governance rights & revenue share only to holders of time-locked positions. The fact that these positions can now be traded makes it easier for people to hold them without worrying about liquidity needs. A great example of a project that has independently implemented such a mechanism is the Lifinity DEX. Their main token is LFNTY, but if you want a share in revenue you need to hold veLFTNY (locked for up to 4 years). You can convert 4-year locked LFNTY to xLFNTY and trade it. It is non-trivial to implement this but using Liquid & WVTs projects can do this out of the box. (This is not financial or investment advice to buy Lifinity tokens.)

A multi-chain tool. The team at Capx believes that in the long run products and services won’t be confined to a single chain. Just like we don’t care whether an app today is hosted on AWS, Azure, or some other service, we won’t pick and choose products based on their underlying blockchains. This is why they’ve been focused on launching their products across many different chains which have developers, projects, and users.

Now we’ll look at their newest product & the focus of today’s essay - community bonds.

Community Bonds

Community bonds (CBDs) are a financial instrument designed to enable projects to raise early capital from their community. These provide fixed returns (paid in project tokens) & limit the impact of price volatility.

A tradFi analogy for CBDs is to think of them as convertible notes. These are hybrid instruments that provide a fixed return against investment. But also come with the option to be converted to company equity before maturity. This allows investors to observe and measure company performance before taking on the risk that comes with equity. The key difference, however, is that convertible notes are paid out in cash by default, reducing exposure to project risk significantly. That isn’t the case with CBDs.

The initial price of a CBD is determined by the total funds to be raised & the # of CBDs to be issued. For example, if you are raising $10k and issuing 100 CBDs then the starting price per CBD = 10,000 / 100 = $100. The project also needs to specify the lock-up period & the promised return. CBDs can be issued by projects before or after they have conducted token generation & sales. Let’s look at each of these cases.

Before Token Generation & Sales

Funds raised by a project without a token are deposited in an escrow smart contract. The founder/core team can set redemption milestones. This specifies what % of total funds raised can be withdrawn after a particular goal is achieved. CBD holders vote to confirm that a milestone is achieved. If the vote passes, those funds are accessible to the project.

Token Generation & Lock-up

Now let’s look at what happens once a project issues tokens. This could happen either after or with the sale of CBDs. The project is required to lock-up tokens in an escrow contract to guarantee that CBDs are redeemable. The tokens locked up cover not only the principle but also the return owed, i.e. if you sold CBDs at $100 with a 200% return, you need to lock up $300 worth of tokens in the contract.

A working example

Let’s work through a few possible scenarios to better understand the returns CBDs provide. Assume a project has issued a CBD with the following specifications:

Issue price: $100
Lockup period: 1 year
Return: 200%

This means, that at the end of one year the CBD holder is entitled to $300 worth of project tokens. The exact number of tokens you receive will depend on the token price at the time of maturity. Assume that the token was trading at $10 when you bought the CBD. Here’s what happens if the token price goes up, down, or stays the same.

The fixed nature of the return means that you get fewer tokens if the price goes up and more tokens if the price goes down. Here’s what the return profile of CBDs looks like compared to just holding the token.

As you can see, a CBD reduces the volatility of returns given fluctuations in the token price. If the token price goes down or remains the same, you’re better off holding a CBD. If the token price increases, your upside is capped to the return promised by the CBD.

CBDs help balance exposure

The best way to think about CBDs is as a way to manage risk. If you’re a retail investor bullish on a project or a contributor earning from a project - you don’t want to only hold CBDs. Just like you don’t want to only take a cash/stable-coin or token compensation. You can read more about risk management in a previous post on earning in web3 by Kash Dhanda.

Product Walkthrough

Now that we’ve understood how CBDs work conceptually, let’s go through the process a project will need to follow to create its own CBDs.

Step 1. Specify 2 out of 3: how much you want to raise, how many CBDs you want to issue & the price per CBD.

Step 2. Specify the locking period(s), the corresponding rate of return & the number of CBDs to be allotted per configuration. This means projects can issue CBDs with multiple configurations in a single drop.

For example: out of 1000 total CBDs,

300 can have a 3-month lock-up with a 100% return
700 can have a 1-year lock-up with a 300% return

Step 3. Make them truly unique and special to your community by adding custom artwork.

Step 4. You’re good to go!

Risks & Safeguards

Nothing is entirely risk-free. While CBDs help manage volatility, there are a few things to consider.

Funds in escrow: Initial funds raised from the sale of CBDs are deposited into an escrow contract. The project team can define the milestones for redemption & the community votes to verify whether these milestones were achieved or not.
Source: Capx team
Furthermore, when the project wants to lock up tokens and redeem the funds they need to deposit sufficient tokens to cover the returns. For example, if a project raised $1m and promised a 200% return, they will need to deposit tokens worth $3m dollars in the escrow contract. This secures the return value of the CBD.
Liquidation: If the escrow contract has project tokens deposited, there is a risk that the token price drops below what is required to provide the promised return. There is an oracle that will check for this condition and trigger the liquidation of the contract. This unlocks the CBDs & opens up the tokens to holders. These can then be sold in the open market. This isn’t a happy scenario because sell pressure on tokens will increase driving the price further down. But, it is some protection to community holders where there would be none otherwise (i.e. you can exit with some % of your capital). Keep in mind this protection is even more meaningful because the CBD escrow has not just the principle but the interest deposited as well (i.e. it is over collateralized).
Token Deposit: A crucial element here is ensuring the project deposits sufficient tokens into the escrow smart contract. This step is currently not enforceable but works on trust and a reputation-based system. The downside to the project is FUD & loss of trust from the early community. The Capx team is building tools to enable the project & its community reach a consensus in such scenarios by sending off-chain reminders to both the project as well as the community (project’s CBD holders) that the token lock-up is due once information around the token is public. They will work to make this enforceable on-chain as the ecosystem matures.
Project risk: CBDs provide fixed returns in project tokens. Ultimately if the project doesn’t succeed, your CBD will be worth nothing.

The Capx CBD Launch

The Capx team is going to be the very first customers of CBDs. They are launching a collection on Solana. You can learn more about it here. Given that Capx doesn’t have a token yet, this is the first opportunity for retail and community participation. (Not financial advice).

There are opportunities to earn CBDs by carrying out micro-tasks. You can find these in the Capx Discord. And there’s a bunch of them exclusively set aside for SuperteamDAO members.

Towards Open Capital Formation

The ability to have a share in the real fruits of your labor is fundamental to capitalism. It is what drives people & fuels growth. This system is not perfect. We’ve entered a new phase where ownership is more accessible than ever. There will be mistakes along the way. Building the infra for this journey is not easy. It requires an acute awareness of both short & long-term trends, a focus on building the right safeguards & relentless execution. Rooting for the Capx team to succeed as they take on this journey.

You can read this essay & follow me on-chain via wordcel.club

Thanks to Yash for designing the cover image for this essay.

The Superteam Blog: Project Deep Dives

Indexing on Solana

What is Indexing?

How to Index: Yellowstone & Geyser

Understanding the Architecture

Available RPC Providers

Pricing and Access

The Problem with Naive Payment Flows

Broken Flow:

Critical Problems:

The Solution: Memo Program + Indexing

Secure Architecture:

Implementation Example:

Why This Works:

Required Memo Extension for Token Accounts

Creating Token Account with Required Memo:

Transferring to Required Memo Account:

Deposit Architecture Patterns

Pattern 1: Memo-Based Deposits (Recommended)

Pattern 2: Unique Deposit Addresses (Binance-Style)

The Sweeper Problem

Withdrawal Architecture and Security

The Withdrawal Problem

Naive Withdrawal Flow (DANGEROUS):

Critical Problems:

Robust Withdrawal Implementation

Queue-Based Processing

Idempotent Withdrawals

Advanced Security: Defending Against Insider Threats

Attack Vector 1: Stolen JWT Secrets

Attack Vector 2: Internal System Bypass

Implementation Example:

Multi-Party Computation (MPC) for Fund Security

MPC Architecture:

MPC Workflow:

Proof of Reserves: Building Trust

Core Components:

Implementation Considerations:

Cost Optimization Strategies

Cheap Indexing for a Single Address

When to Use Expensive Indexing

Production Deployment Checklist

Infrastructure Requirements:

Security Measures:

Operational Procedures:

Conclusion

Deep Dive of the State of Developer Tooling on Solana

Table of Contents

1. Introduction

2. The Tooling Evolution (2020–2025)

3. Anchor and Rust Foundations

4. Python and Solidity Support

4.1. Seahorse: Python for Solana

4.2. Solang: Solidity on Solana

5. Frontend SDKs and Wallet Integration

5.1. @solana/kit (the successor to web3.js)

5.2. Wallet Adapter SDKs

5.3. Kinobi & Umi

6. RPCs, Indexers, and Dev Infra

6.1. RPC Providers

6.2. Indexers and APIs

7. Local Testing and Simulation Tools

7.1. Solana Test Validator

7.2. Surfpool

7.3. Pinocchio

7.4. Other Tools

8. Account Abstraction and Smart Accounts

8.1. PDAs: Core Building Blocks

8.2. Squads v4: Powerful Smart Account Framework

8.3. Pinocchio: Lightweight Abstraction Testing

9. Real-World Adoption

9.1. Gaming: GameShift API + Custom SDKs

9.2. DePIN: High-volume, live-data use cases

9.3. Consumer Apps

10. Tooling Ecosystem Map

Smart Contract Layer

Language & SDK Layer

Wallet Integration

Local Dev & Testing

Account Abstraction / Smart Accounts