Blockchain and artificial intelligence are converging in groundbreaking ways, with **onchain AI agents** emerging as a transformative force in decentralized finance (DeFi), gaming, and digital asset management. These autonomous programs combine AI’s decision-making prowess with blockchain’s transparency, enabling 24/7 trading, yield optimization, and even social media engagement—all without human oversight. This article explores how onchain AI agents work, their real-world applications, and why they’re poised to redefine crypto’s future.  

## What are onchain AI agents?

Onchain AI agents are **self-operating programs** that execute tasks on a blockchain, governed by smart contracts and machine learning models. Unlike traditional AI, these agents:  
- **Control crypto wallets**, enabling them to buy, sell, or stake assets autonomously. 
- **Leverage oracles** to integrate offchain data (e.g., social sentiment, price feeds).  
- **Operate transparently**, with every action recorded onchain for auditing .  

For example, an agent might analyze Twitter trends to identify rising memecoins, then execute trades using predefined risk parameters—all while updating users via Discord. This blend of autonomy and accountability makes them uniquely suited to crypto’s fast-paced markets.  

## AI agents architecture

Onchain AI agents operate through a combination of smart contracts containing their core logic and instructions, and crypto wallets they control to execute transactions[1]. These agents typically follow a four-step process: perception, input processing, decision making, and action[2]. They gather data from the blockchain and external sources, analyze it using machine learning algorithms, make decisions based on their programmed goals, and then execute actions such as trading or deploying smart contracts.

Key components of onchain AI agents include:

* Smart contracts defining the agent's logic and objectives
* [Controlled crypto wallets](https://www.openfort.xyz/docs/guides/server/dev) for transaction execution
* Access to oracles for off-chain data
* Integration with AI models like large language models (LLMs)
* Connectors for interacting with platforms like social media

Advanced onchain AI agents can perform complex tasks autonomously, such as launching tokens, creating liquidity pools, and even controlling their own private keys for enhanced sovereignty. As the technology evolves, these agents are becoming increasingly capable of making sophisticated decisions and executing complex strategies in the decentralized finance ecosystem.


## 5 key benefits of onchain AI agents

1. **Hyper-Efficiency**  
   - Execute trades in milliseconds, capitalizing on arbitrage or price discrepancies humans might miss.  
   - Optimize gas fees by bundling transactions or timing operations during low-network congestion.  

2. **24/7 Market Monitoring**  
   - Track metrics like lending pool APYs, NFT floor prices, or memecoin social volume nonstop.  

3. **Democratized Access**  
   - Platforms like **ai16z** and **ElizaOS** let users create agents via natural language, bypassing coding expertise .  

4. **Cross-Platform Synergy**  
   - Manage portfolios across Ethereum, Solana, and Cosmos simultaneously, rebalancing based on cross-chain trends.  

5. **Community-Driven Growth**  
   - Agents like **Griffain** gamify participation, rewarding users who contribute data or liquidity to their strategies .  

## Use cases reshaping crypto 

### **1. Autonomous trading & portfolio management**  
Agents like **Kaito** analyze onchain whale activity and CEX order books to execute trades. For example:  
- **Trend Following:** Buy tokens trending on DexScreener.  
- **Arbitrage:** Exploit price gaps between Uniswap and Coinbase.  
- **Risk Mitigation:** Auto-sell if a token’s social sentiment drops 30% in an hour .  

### **2. DeFi yield optimization**  
Agents maximize returns by:  
- Shifting stablecoins between Aave, Compound, and Morpho based on real-time APYs.  
- Providing liquidity to volatile pools only during peak fee periods.  

### **3. Memecoin launches & marketing**  
Projects like **Bankr** use AI agents to:  
- Mint and promote tokens via Twitter/X bots.  
- Airdrop to influential accounts detected by sentiment analysis tools.  

### **4. Onchain gaming**  
- **NPCs with Agency:** AI-controlled characters in games like **Holoworld** trade in-game assets or form alliances.  
- **Auto-Farming:** Agents grind for rare NFTs while users sleep.  

## Top AI agents frameworks

Several notable projects and frameworks are leading the development of AI agents in the crypto space. These initiatives are pushing the boundaries of blockchain integration and autonomous decision-making. Here's a concise overview of some key players:

| Project/Framework | Key Features |
| ----------------- | ------------ |
| [Fetch](Fetch.ai) | Decentralized platform for autonomous agents, optimizing DeFi yields and supply chains |
| [ElizaOS](https://www.elizaos.ai/) | Open-source framework for deploying web3-friendly autonomous AI agents, supporting multiple networks |
| [Virtual Protocol](https://www.virtuals.io) | Enables users to create, deploy, and monetize AI agents without technical expertise |
| [Clanker](Clanker.io) | A robust framework designed to empower developers in building and managing onchain AI agents. |
| [G.O.A.T](https://ohmygoat.dev/introduction) Framework | GOAT Framework is a decentralized infrastructure designed to support the development of verifiable inference systems. |

These projects demonstrate the diverse applications of AI agents in crypto, from optimizing trading strategies to enhancing blockchain interoperability. As the technology evolves, we can expect to see more innovative use cases emerge, potentially reshaping the landscape of decentralized finance and blockchain technology.

## Conclusion

Onchain AI agents are not just automating crypto—they’re redefining how trust, efficiency, and creativity function in decentralized ecosystems. While risks like exploits remain, platforms prioritizing auditable code and user-controlled parameters are paving the way for mass adoption. As frameworks mature, expect these agents to become as ubiquitous as smart contracts, powering everything from your retirement portfolio to metaverse real estate deals.  


Discover how onchain AI agents are expanding to new use cases.

AI-agent-cover.png

Onchain AI agents: What you should know

Telegram Mini-Apps allow developers to integrate lightweight web-based applications within Telegram, providing a streamlined way to reach its massive user base. Unity WebGL, in combination with Openfort, enables seamless Web3 wallet integration, making it possible to build engaging and decentralized gaming experiences.

In this guide, we’ll explore how to integrate a Telegram Mini-App with a Unity WebGL application and Openfort’s SDK. This tutorial includes handling authentication via Telegram’s `initData` and enabling EVM-compatible wallet interactions.

**Reference Documentation:**
- Unity Resources for Telegram Mini-Apps: [Openfort Unity Guide](https://www.openfort.xyz/docs/guides/unity/resources/telegram-unity)
- Telegram Mini-App with React: [Blog Post](https://www.openfort.xyz/blog/telegram-mini-apps)

## Step 0: Overview and Architecture

Before diving into code, it’s important to understand the structure and flow of the Unity WebGL Telegram Mini-App integration.

### Key Components

1. **Frontend (Unity WebGL Client):**
   - Built using Unity’s WebGL export.
   - Communicates with Telegram Web Apps SDK to retrieve `initData` for user authentication.
   - Sends `initData` to the backend for validation.
   - Interacts with Openfort’s SDK for blockchain operations such as wallet creation and NFT minting.

2. **Backend (Server-Side):**
   - Built with Node.js and Express (or any other backend framework).
   - Validates `initData` to authenticate users.
   - Handles wallet generation and transaction sponsorship using Openfort.

![telegram-webgl.png](https://blog-cms.openfort.xyz/uploads/telegram_webgl_e6ec8646db.png)

### Authentication Flow

Telegram’s Web Apps SDK provides an `initData` object for user authentication within Mini-Apps. This data contains cryptographically signed user information, ensuring security and trust.

#### Key Concepts:
- **`initData` Flow:**
  - The `initData` object is provided when the Mini-App is opened within Telegram.
  - This object is sent to the backend for validation and serves as the authentication token for user interactions.
- **Unity WebGL Integration:**
  - Unity communicates with Telegram’s JavaScript SDK through Unity WebGL’s browser integration features.


## Step 1: Set Up Unity WebGL Project

1. **Install Dependencies:**
   - Open your Unity project.
   - Install the Openfort Unity SDK by following the [Unity Integration Guide](https://www.openfort.xyz/docs/guides/unity/).

2. **Enable WebGL Support:**
   - Go to **File > Build Settings**.
   - Select **WebGL** as the build target.
   - Click **Switch Platform** to enable WebGL for your project.

3. **Add Required Plugins:**
   - Include a JavaScript plugin for interacting with the Telegram Web Apps SDK. This will enable Unity WebGL to retrieve `initData` from Telegram.


## Step 2: Initialize Telegram in Unity

Use Unity’s browser integration features to fetch `initData` from Telegram.

```csharp
using UnityEngine;
using Openfort.SDK;

public class TelegramIntegration : MonoBehaviour
{
    void Start()
    {
        // Initialize Telegram Mini-App and fetch initData
        string initData = InitTelegramApp();
        Debug.Log("Init data: " + initData);

        // Use initData for Openfort SDK
        ThirdPartyOAuthRequest request = new ThirdPartyOAuthRequest(
            ThirdPartyOAuthProvider.TelegramMiniApp,
            initData,
            TokenType.IdToken
        );

        // Example: Validate and fetch wallet information
        Openfort.GetWallet(request, wallet =>
        {
            Debug.Log("Wallet Address: " + wallet.address);
        });
    }

    string InitTelegramApp()
    {
        // JavaScript integration to retrieve initData
        return "Telegram InitData Placeholder"; // Replace with actual implementation
    }
}
```


## Step 3: Backend Setup

The backend validates `initData` and integrates with Openfort for wallet management.

1. **Validate `initData`:**
   - Use Telegram’s cryptographic methods to ensure `initData` authenticity.
   - Refer to the [Telegram Documentation](https://core.telegram.org/bots/webapps#validating-data-received-via-the-web-app) for implementation details.

2. **Integrate with Openfort:**
   - Use Openfort’s API to create wallets and sponsor transactions.


## Step 4: Build and Test the Unity WebGL App

1. **Build the Project:**
   - Go to **File > Build Settings**.
   - Select **WebGL** and click **Build and Run**.

2. **Host the WebGL App:**
   - Deploy the build to a web server.
   - Ensure it is accessible via HTTPS, as Telegram requires secure connections for Mini-Apps.

3. **Test in Telegram:**
   - Create a bot using BotFather and link the Mini-App.
   - Open the Mini-App within Telegram to test functionality.


## Notes and Best Practices

- **Using `initData` as Access Token:**
  - In Telegram Mini-App integrations, the `initData` object serves as the authentication token. Traditional `GetAccessToken()` methods from Openfort are not applicable in this context.

- **Security Reminder:**
  - Always validate `initData` on the server-side to prevent tampering.

---

By following this guide, you can successfully integrate a Telegram Mini-App with Unity WebGL and Openfort, enabling powerful Web3 features within Telegram. For further resources, check out the [Unity Guide](https://www.openfort.xyz/docs/guides/unity/resources/telegram-unity).

In this guide, we’ll explore how to integrate a Telegram Mini-App with a Unity WebGL application and Openfort’s SDK. 

Unity-telegram.png

How to build Telegram mini-app with Unity WebGL

Telegram Mini-Apps are powerful tools for developers to reach over 950 million monthly active users directly within the Telegram messenger. These lightweight applications, built using web technologies like HTML, CSS, and JavaScript, provide a seamless, integrated experience without requiring separate downloads or installations. 

In this guide, you'll learn how to create a Telegram Mini-App integrated with Openfort's SDK to enable Web3 features like non-custodial wallets and NFT minting. This article is optimized for technical readers looking for a practical starting point, and you'll find a fully functional sample repository linked below.

**The repository for this tutorial can be found [here](https://github.com/openfort-xyz/sample-telegram-mini-app).**

Test it live via Telegram by chatting with **@OpenfortMiniAppBot**.

## Step 0: Overview and Architecture

Before diving into the implementation, it’s important to understand the high-level structure and flow of the Telegram Mini-App you’ll build.

### Key Components

1. **Frontend (Client-Side)**:
   - Built with **React** using the Telegram Web Apps SDK.
   - Handles the user interface and state management.
   - Processes `initData` received from Telegram for authentication.
   - Provides interactions for minting NFTs and viewing wallet information.

2. **Backend (Server-Side)**:
   - Built with **Node.js** and **Express**.
   - Validates `initData` for security and ensures the user is authenticated.
   - Integrates with Openfort’s SDK to manage smart wallets and sponsored transactions.
   - Exposes API endpoints for NFT minting and wallet generation.

### Telegram Authentication Flows

Telegram provides two distinct methods for authentication within Mini-Apps: 

1. **`initData` Flow**:
   - Used within the Mini-App environment.
   - Relies on Telegram to authenticate the user via the `initData` object.
   - No refresh token is involved, as Telegram handles re-authentication for subsequent sessions.

2. **OAuth Flow**:
   - More versatile and works in browsers or platforms outside the Mini-App context.
   - Returns an access token/refresh token pair, similar to logging in with Google.
   - Suitable for broader integrations where the user isn't already within the Telegram app.

**This guide focuses on the `initData` flow**, which is specially designed for seamless use in Telegram Mini-Apps.

### High-Level Flow

![telegram-screenshot.png](https://blog-cms.openfort.xyz/uploads/telegram_screenshot_601db8f889.png)

Here’s how the application will work end-to-end:

1. The user opens the Telegram Mini-App from a bot.
2. Telegram sends `initData` to the Mini-App containing signed user information.
3. The frontend sends this `initData` to the backend for validation.
4. The backend:
   - Validates `initData` using Telegram-provided cryptographic methods.
   - Creates a self-custodial wallet using Openfort.
   - Returns relevant user data and wallet information to the frontend.
5. The user interacts with the Mini-App:
   - Minting NFTs.
   - Viewing wallet details.
   - Executing blockchain transactions.

## Objectives

By the end of this tutorial, you will have:

1. Set up a **Telegram Mini-App** using React.
2. Integrated Openfort’s SDK for **embedded wallet creation**.
3. Built backend routes to handle Telegram authentication and Web3 interactions.

## Step 1: Set Up the Telegram Mini-App

### 1.1 Create a Bot and Mini-App with BotFather
1. Add BotFather to your Telegram and run `/newbot`.
2. Follow the prompts to name your bot and get its access token.
3. Add this token to the [Openfort authentication provider settings](https://dashboard.openfort.xyz/players/auth/providers).
4. Run `/newapp` to create a Mini-App linked to your bot. Use your ngrok URL as the app’s URL (we’ll set this up next).

## Step 2: Clone and Configure the Project

### 2.1 Clone the Repository
```bash
git clone https://github.com/openfort-xyz/sample-telegram-mini-app-embedded-wallet
cd sample-telegram-mini-app-embedded-wallet
```

### 2.2 Set Up Environment Variables
In the `/frontend` and `/backend` directories, copy and configure `.env.example` files:
```bash
cp .env.example .env
```

- **Frontend `.env`:**
  ```env
  NEXT_PUBLIC_TELEGRAM_BOT_TOKEN=<your-bot-token>
  NEXT_PUBLIC_OPENFORT_PUBLISHABLE_KEY=<your-publishable-key>
  NEXT_PUBLIC_OPENFORT_POLICY_ID=<your-policy-id>
  NEXT_PUBLIC_OPENFORT_CHAIN_ID=<your-chain-id>
  ```

- **Backend `.env`:**
  ```env
  BOT_TOKEN=<your-bot-token>
  FRONTEND_APP_ORIGIN=<your-ngrok-url>
  ```

## Step 3: Run the Application

### 3.1 Install Dependencies
```bash
# In frontend directory
cd frontend && yarn install

# In backend directory
cd ../backend && yarn install
```

### 3.2 Start Services
```bash
# Start frontend
yarn start

# Start backend
yarn dev
```

Use `ngrok` to expose your local server:
```bash
ngrok http 3000
```

Update the Mini-App URL in BotFather with your ngrok HTTPS link.

## Step 4: Key Integration Features

### Telegram Authentication
The app uses `initDataRaw` from the Telegram Web Apps SDK for third-party authentication. No additional refresh tokens are needed.

### Embedded Wallet
With Openfort’s SDK, users can:
1. Create a **non-custodial wallet**.
2. Mint NFTs using predefined policies.

### API Routes
The backend provides endpoints for:
1. `/api/createAuthConfig`: Configures authentication.
2. `/api/createEncryptionSession`: Sets up a session for wallet creation.
3. `/api/mintNft`: Facilitates NFT minting.

## Example Code Snippets

### Telegram Bot Integration
In `/backend/src/bot/features/openfort.ts`:
```typescript
feature.command('start', async (ctx) => {
  const keyboard = new InlineKeyboard().webApp(
    'Launch App',
    `${process.env.FRONTEND_APP_ORIGIN}/login/telegram`,
  )
  return ctx.reply('Click to launch.', { reply_markup: keyboard })
})
```

### Wallet Initialization
In `/frontend/src/app/login/telegram/page.tsx`:
```typescript
useEffect(() => {
  const initTelegram = async () => {
    const telegramSDK = Telegram.WebApp;
    telegramSDK.ready();
    const wallet = await openfort.createWallet({ user: telegramSDK.initData });
    setWallet(wallet);
  };
  initTelegram();
}, []);
```

## Conclusion

You’ve built a Telegram Mini-App with **React** that:
- Authenticates users via the Telegram SDK.
- Generates EVM-compatible **non-custodial wallets**.
- Facilitates Web3 interactions, such as NFT minting.

For further details, check:
- [Openfort Documentation](https://www.openfort.xyz/docs/guides/dashboard/custom-auth/telegram-mini-app)
- [Telegram Web Apps SDK Docs](https://core.telegram.org/bots/webapps)
- [Repository README](https://github.com/openfort-xyz/sample-telegram-mini-app-embedded-wallet)


Learn how to create a web3 telegram mini app in React.

telegram-mini-apps.svg

How to create Telegram mini-app with React

**Overview**
Openfort's UE 5 SDK enables developers to create embedded wallets and ecosystem wallet compatibility for their games and applications. The SDK provides a simple API to interact with wallets, login with email or socials, as well as create Smart Wallet session keys.

With this SDK, you can keep the onboarding of your users in-client and grant a session key to your Openfort powered backend to interact with the blockchain, no signature in sight.

Get started by following the documentation [here](https://www.openfort.xyz/docs/reference/unreal-engine).

![ue_screen.png](https://strapi-oube.onrender.com/uploads/ue_screen_c8c7d697f7.png)

**Features**

* **Onboard first time users** - ephemeral guest wallets.
* **Create and login to self-custodial wallets** - unlocking email and social authentication to create persistent, cross-platform, cross-device and cross-sdk signless embedded wallets.
* **Unlock the power of Account Abstraction** - unlock the ability to sponsor gas and interact on behalf of users by upgrading any wallet to a Smart Wallet, and using Session Keys to grant scoped access to your backend - fully compatible with solution.
* **Wide Compatibility** - the SDK is compatible with the Ecosystem SDK as well, allowing you to leverage the latest features and improvements across the chain's environment.

For more information visit https://github.com/openfort-xyz/openfort-unreal-engine

UE SDK enables developers to onboard and use smart accounts natively on the gameplay. 

unreal_logo.svg

Announcing Openfort Unreal Engine SDK

In-app purchases (IAP) for web3 games involve transactions for digital assets, such as non-fungible tokens (NFTs) and cryptocurrency tokens, within mobile applications. Developers working on blockchain-based games must navigate strict policies set by both Apple's App Store and Google Play Store, which have a significant impact on how these transactions are conducted. Here’s an updated guide on handling IAPs in Web3 games, with insights from the latest policies on both platforms.

### Understanding Platform Policies for IAP in Web3 Games

#### Apple App Store IAP Policies for Web3 Games
- **NFT Sales and Transactions:** Apple permits developers to list, mint, transfer, and view NFTs within apps, as long as these actions do not unlock additional features or functionality.
- **Mandatory In-App Purchase System:** All NFT transactions must go through Apple's in-app payment system, which subjects them to Apple's standard commission.
- **NFT Verification Requirements:** Apple requires comprehensive details regarding NFTs, including their origin, ownership, and provenance, for listing on the App Store.
- **Restrictions on External Links:** Apps cannot include links or calls to action that direct users to purchase NFTs outside of the Apple in-app payment system.

#### Google Play Store IAP Policies for Web3 Games
- **NFT Integration:** Google allows the integration of NFTs into apps but mandates full transparency about the nature of tokenized digital assets.
- **Transparency and Compliance:** Developers must clearly communicate the risks and details surrounding NFTs and are prohibited from promoting potential earnings from tokens.
- **Adherence to Gambling Policies:** Google Play enforces compliance with its Real-Money Gambling, Games, and Contests policy, ensuring that games with tokenized assets follow strict guidelines.

### Fee Structures for IAP in Web3 Games

- **Apple:** Apple charges a 30% commission on all NFT sales made through its in-app purchase system, regardless of the developer's revenue.
- **Google:** Google Play also applies a tiered fee structure, taking a 30% cut from developers earning over $1 million annually and a 15% fee from those making less than $1 million.

### Case Study: How STEPN Manages IAP in Web3 Games

![IAP-diagram-web3games.svg](https://blog-cms.openfort.xyz/uploads/IAP_diagram_web3games_f748621b79.svg)

STEPN, a Web3 game, offers an excellent example of how to navigate IAPs within a blockchain-based mobile game. The game uses multiple in-game currencies, including two ERC-20 tokens and a third in-game currency specifically for iOS:

1. **Sparks:** A soft currency available only through Apple Pay.
2. **$GMT:** The primary token for unlocking features and leveling up.
3. **$GST:** The secondary token for speeding up unlocks.

Here’s how the IAP process works on iOS:

1. Players purchase Sparks using Apple Pay.
2. They use Sparks to buy sneaker NFTs, which are priced 30% higher than market value to cover Apple's commission. The primary marketplace is on Magic Eden, where items are priced in SOL.
3. Players can optionally send $GMT, $GST, SOL, or USDC into the in-app wallet to use for unlocks and leveling up.
4. Players can list their sneaker NFT for sale.
5. If the NFT sells, players receive $GMT as the transaction currency.
6. Players can then swap currencies within the app and transfer funds to an external wallet.

STEPN has streamlined its IAP system, allowing users to transact easily across different currencies while maintaining compliance with Apple's policies. It also separates in-game and non-custodial wallets, giving users full ownership of their assets.

### Integrating IAP in you games using Unity

![Apple_IAP_Unity_Sample_4a667ba30f.png](https://blog-cms.openfort.xyz/uploads/Apple_IAP_Unity_Sample_4a667ba30f.png)

At Openfort, we provide two comprehensive [guides for integrating Unity IAP](https://www.openfort.xyz/docs/guides/resources/apple-iap-unity) with both Android and iOS platforms. These resources are designed to help developers navigate platform policies while maintaining Web3 functionality. 

_Note: Both Apple and Google frequently update their policies, so be sure to stay informed and adapt accordingly. If you have any questions, feel free to reach out to us._

In-app purchases (IAP) in Web3 games involve transactions for digital assets like non-fungible tokens (NFTs) and tokens within mobile applications. 

IAP-web3.svg

Navigating In-App Purchases in web3: A Comprehensive Guide in Unity

From the digital realm of [Farcaster](https://www.farcaster.xyz/) was revolutionized with the debut of Frames, a novel social construct, triggering a surge in daily active users, global hackathons, and unprecedented levels of innovation.

Openfort's co-founder, [Jaume](https://warpcast.com/jamalavedra), introduced [Smart Accounts Frame](https://warpcast.com/jamalavedra/0x6a50dc57) this weekend. The frame turns every Farcaster user as an owner of a smart contract wallet with an NFT minted inside, all within a frame.

Since the launch the demo Frame we had a fun couple of hours :)

![original.png](https://strapi-oube.onrender.com/uploads/original_580744904f.png)

## The Essence of Frames
It's crucial to distinguish between Farcaster's Frames and the traditional iFrame. Unlike embedded web pages, Frames, powered by the [Open Graph](https://ogp.me/) protocol and enhanced by blockchain technology, facilitate seamless app interactions within another app without direct coordination. This breakthrough allows for a comprehensive, user-driven graph of actions across various platforms, a feat not achievable even by giants like Facebook in their prime.

Frames have already found diverse applications, from job listings to gaming, showcasing their potential for widespread adoption as their functionality evolves.

## Technical Foundation and Use Cases
Modern consumer products blend with entertainment, prompting users to constantly seek and engage with new innovations. Frames exemplify this trend on Farcaster, where they're rapidly created with engaging features, though their presence is fleeting, making way for new experiences.

The appeal of Frames is undeniable, posing challenges in developing scalable and reliable applications swiftly. At Openfort we also offer a swiftly reference built atop the Openfort Transaction Cloud, simplifying the NFT minting process from Frames on any chain and ensuring smooth, reliable transactions regardless of user traffic.

## The Opportunity with Minigames
### Rising Popularity of Minigames
The revival can be attributed to the ability to offer quick, entertaining breaks from the routine, making them a perfect fit for today's fast-paced lifestyle. Minigames have found their way into social media, educational platforms, and even marketing campaigns, showcasing their versatility and wide appeal. Their simplistic yet addictive nature ensures they can be enjoyed by users of all ages, making them a potent tool for engagement in the digital realm.

### Minigames and Frames Synergy

The fusion of minigames with the dynamic display capabilities of frames heralds a new era in digital engagement, inviting users to interact with web content in a more meaningful and engaging manner. This innovative synergy captures the essence of modern web interaction by marrying the compelling draw of interactive games with the versatile presentation of digital frames.

**- Enhanced Engagement:** Frames transform the digital landscape into an interactive playground, where users are no longer mere spectators but active participants. Hosting minigames within these frames elevates user engagement, turning every click into an opportunity for discovery and enjoyment.

**- Broader Accessibility:** The appeal of minigames extends across a wide audience, making them a powerful tool for capturing attention. Embedding these games within frames ensures that they can be seamlessly integrated across diverse digital environments.
**- Innovative Content Delivery:** By utilizing frames as a canvas for minigames, content creators can craft tailored interactive experiences that resonate with their target audience. 
**- Real-time Interaction and Feedback:** The integration of minigames into frames enables a dynamic interaction where content responds in real-time to user input. This level of personalization enhances the user experience, making digital exploration a two-way conversation. 

## Start with Frames and Openfort

Amidst the excitement, it's vital to understand the significance of Frames and why their integration with Openfort's APIs elevates the experience. Openfort offers a platform that simplifies the creation and management of interactive frames, particularly those designed for hosting minigames and other dynamic content. It provides developers with the tools and resources needed to create engaging frames without starting from scratch.

Start by cloning the [Openfort FC Frames demo repository](https://github.com/openfort-xyz/openfort-fc-frames-demo) from GitHub. This gives you a base template that you can customize according to your project's requirements.

With the integration of Farcaster Frames, the ease of one-click mints and embedded blockchain experiences sets a new standard, with the Openfort endpoints now supporting a wider range of smart contract interactions.


In the evolving landscape of digital interaction, the concept of "frames" represents a groundbreaking approach to integrating dynamic, interactive content into various digital platforms.

Minigames.svg

Minigames, Frames and anything in between

Welcome to the final installment of our three-part series on Web3 gaming. In the first part, we introduced you to the transformative potential and challenges of Web3 in gaming. In the second part, we explored the essential tools and technologies you'll need to kickstart your Web3 gaming project.

- [Part 1: Introduction to Web3 Gaming Infrastructure](https://www.openfort.xyz/blog/introduction-to-web3-gaming-infrastructure)
- [Part 2: Tools for Web3 Game Development](https://www.openfort.xyz/blog/tools-for-web3-game-development)
- Part 3: Best Practices and Case Studies (You are here)

## Comprehensive Success Metrics for Web3 Games
Evaluating the success of web3 games requires a nuanced approach that includes both traditional gaming metrics and specific indicators unique to the web3 ecosystem. This dual measurement strategy allows developers to gain insights into both the general appeal of the game and its performance within the blockchain-based gaming market.

### Traditional Gaming Metrics:

**- Daily/Weekly/Monthly Active Users (D/W/MAU):** Track the number of unique players engaging with the game each day. This metric is crucial for understanding the game's daily engagement level.
**- Player Retention (Retention Curves):** Measure the percentage of players who return to the game over time, indicating the game's ability to maintain player interest.
**- Lifetime Value (LTV):** Calculate the total revenue expected from a player throughout their interaction with the game, which helps in understanding long-term profitability.
**- Average Revenue Per User (ARPU)** and **Average Revenue Per Paying User (ARPPU):** Assess the revenue generated on average by each player and by each paying player, respectively.
**- Player Ratings and Reviews:** Monitor user feedback across various platforms. This qualitative metric provides insights into player satisfaction and areas for improvement.
**- Conversion Rate:** The percentage of players who make in-game purchases or subscribe to premium features, indicating the effectiveness of monetization strategies.
**- Advertising and User Acquisition Costs (CAC):** Analyze the costs related to marketing efforts and compare them to the LTV of acquired players to evaluate the efficiency of these tactics.

### Web3-Specific Metrics:
**- Transaction Volume:** Look at the total number and value of blockchain transactions within the game. This metric can indicate the game's popularity and the level of player engagement with the blockchain elements.
**- Token or Item Holders:** Track the number of players holding in-game tokens or blockchain-based items. A high number can signal a strong player investment in the game's economy.
**- Secondary Market Statistics:** Analyze data from secondary sales, such as pricing and volume, and observe player behaviors in trading and utilizing their assets. This helps in understanding the external economic impact of the game.
**- Onchain Interactions:** Evaluate how players interact with blockchain features, such as smart contracts or decentralized finance (DeFi) elements. This can provide insights into how well these features are being received and used.
**- Cross-Game Interoperability:** For games allowing item usage across multiple platforms, assess the frequency and manner of these cross-game interactions. This can indicate the game’s reach and the value of its items beyond the primary gaming environment.

These metrics help you get a better sense of which building blocks to utilize for your game. However, understanding them in context can be challenging. Let's work through two hypothetical cases to illustrate these concepts more clearly.

![quadrantgames.png](https://strapi-oube.onrender.com/uploads/quadrantgames_22ac9b7502.png)

## Hypothetical Case Studies
### AAA PC RPG Game
For a AAA PC RPG game, traditional gaming metrics such as D/W/MAU, player retention, and LTV are particularly crucial due to the game's complex nature and high production value. These metrics will help you understand player engagement and long-term profitability.

#### Traditional Metrics Emphasis:

- Daily/Weekly/Monthly Active Users (D/W/MAU): Vital for understanding the daily and ongoing engagement levels in a game with rich, immersive content.
- Player Retention: Important for ensuring that players continue to find value and enjoyment over extended periods.
- Lifetime Value (LTV): Crucial for gauging long-term financial sustainability, given the significant investment in development.
#### Web3 Metrics Integration:

- Transaction Volume and Token Holders: These metrics can reflect the extent of player engagement with the game's economy and blockchain elements.
- Onchain Interactions: Reflects how effectively players are using blockchain features, crafting, updating metadata, apying in finantialization fo the game, etc.
 
### Mobile Card Collecting Game (Web2.5)
For a mobile card collecting game, simpler gameplay and likely shorter session times shift the focus toward metrics that reflect transaction volume and user accessibility.

#### Traditional Metrics Emphasis:

- Average Revenue Per User (ARPU) and Conversion Rate: These metrics are crucial due to the game's monetization strategy relying heavily on microtransactions.
- Player Ratings and Reviews: Useful for understanding player satisfaction and areas for improvement, especially important in a competitive market.
#### Web3 Metrics Integration:

- Transaction Volume: Key for understanding the frequency and value of card trades within the game.
- Secondary Market Statistics: Provides insights into the trading behavior and economic impact outside the primary game environment.
 
### Why only web3 data is not enough?
Existing Web3 tokenomics and play-to-earn (P2E) models come with significant challenges. These models often rely on continuous player influx, which can lead to lower lifetime value (LTV) and issues with player retention. Furthermore, these models can border on gambling, raising ethical concerns.

The first Web3 business model, centered around NFT collectibles and popularized by games like CryptoKitties, showed limited revenue potential as it relied heavily on new players. More recent tokenomics and P2E mechanics still depend on large numbers of new players, which can hurt retention and eventually kill the game.

In summary, successful Web3 gaming requires a balance of traditional and Web3-specific metrics, careful planning of game features, and an understanding of the limitations and ethical considerations of current models.


Evaluating the success of web3 games requires a nuanced approach.

Group 398.svg

Building a Web3 Game: Best Practices and Examples (Part 3)

Welcome to the first installment of our three-part series aimed at game developers interested in diving into the world of Web3. As blockchain technology continues to disrupt various industries, the gaming sector is no exception. This series aims to provide a comprehensive guide to understanding, adopting, and excelling in Web3 gaming.

- Part 1: Introduction to Web3 Gaming Infrastructure (You're here)
- [Part 2: Tools for Web3 Game Development](https://www.openfort.xyz/blog/tools-for-web3-game-development)
- Part 3: Best Practices and Case Studies

Whether you're a seasoned game developer or a newcomer curious about blockchain, this series has something for everyone. Let's start by laying down the foundation in Part 1: Introduction to Web3 Gaming Infrastructure.

## Why Blockchain? Reasoning 101
As a game studio, the first question you must grapple with is, "Why blockchain?" The gaming industry is already a melting pot of various trends—be it the Creator Economy, cloud gaming, or user-generated content. So, diving into blockchain technology isn't a decision to be taken lightly; the stakes are high.

At its core, blockchain technology offers a unique set of advantages that are revolutionizing various sectors, gaming included. These advantages can be categorized into four main pillars: verifiable ownership, immutability, decentralization, and security. 

In the context of gaming, these pillars translate into tangible benefits like transparent game operations, ownership of digital assets, and immutable gaming records.

**- The Importance of Cooperation**
The essence of Community Economics is cooperation. Traditional gaming models are often one-sided and sometimes even exploitative. Blockchain gaming, on the other hand, thrives on mutual benefits. By fostering a cooperative environment, everyone in the ecosystem stands to gain, encapsulating the idea that "a rising tide lifts all boats."

**- The Role of Interoperability**
Interoperability is crucial for the long-term sustainability of Community Economics. It allows for seamless interactions between different blockchain platforms, thereby preventing the formation of isolated ecosystems. This is beneficial for both developers, who can tap into a broader market, and players, who enjoy greater freedom and liquidity for their digital assets.

**- The Power of Composability**
Another noteworthy feature of blockchain is composability, which allows developers to build upon existing applications or smart contracts and players to create traceble content. This accelerates the development process and opens up new possibilities, akin to how compound interest works in finance.

## Onchain vs Offchain
In the evolving domain of web3 gaming, developers face a pivotal decision: whether to build their games on-chain, off-chain, or a hybrid of both. On-chain gaming, leveraging blockchain technology, offers unparalleled digital ownership, transparency, new design opportunities, and innovative monetization models. In contrast, traditional off-chain games rely on centralized servers and databases, with game systems controlled solely by the developer or publisher.

## Key Game Design Elements
### On-Chain Components:

Tokenization: Introducing digital tokens for in-game items, characters, or collectibles, ensuring genuine ownership and facilitating player-led economies.
Decentralized Governance: Implementing DAOs for player involvement in game development decisions, promoting community engagement.
### Off-Chain Components:

Game Mechanics and UI: Maintaining intricate game interactions and user interfaces off-chain due to blockchain limitations in processing speed and scalability.
Gameplay Dynamics: Processing dynamic gameplay elements off-chain to ensure seamless player experiences.

## What Obstacles Players and Developers Face?
### For Players
**1. Complex Onboarding Experience:** Players must navigate through multiple steps including installing browser wallets, potential undergoing Know Your Customer (KYC) verifications, purchasing native tokens, approving obscure transaction requests, and covering gas fees.
**2. Security Risks in Self-Custody:** Players shoulder the burden of safely storing seed phrases, facing the possibility of irreversible loss or compromise.

### For Developers
**1. Navigating Unfamiliar Terrain:** Teams grapple with complex topics like limited computational resources, adversarial circumstances, and smart contract security, which divert their attention from core game development.
**2. Absence of Best Practices:** The fast-paced advancements in technology, frequent updates to protocols, and continuously emerging problem-solving methods result in a volatile landscape.
**3. Balancing Open Economies:** Teams must safeguard the sustainability of token economies without undermining the gaming experience, while also defending against bot activity.
**4. User Outreach and Sustained Engagement:** In a digital realm filled with bots and pseudonymous identities, executing effective cohort analyses and targeted user acquisition (UA) strategies presents a formidable challenge.
**5. Regulatory Conformance:** Adapting to an ever-shifting regulatory landscape poses its own unique set of difficulties.

# Gaming Infraestructure: The Good, The Bad and the Ugly
![Screenshot 2023-09-27 at 17.24.12-min.png](https://strapi-oube.onrender.com/uploads/Screenshot_2023_09_27_at_17_24_12_min_5fcbf519f3.png)

## The Good: Shared Building Blocks
In the realm of blockchain gaming, many of the foundational tools remain consistent with traditional Web2 gaming. Whether it's asset creation, real-time engines, or cloud back-ends, the same companies and tools are often in play. For instance, [Lost Dungeon](https://lostdungeon.openfort.xyz) utilizes [PlayFab](https://www.openfort.xyz/docs/guides/unity/resources/backend/playfab) and Azure functions on the backend to host the onboarding and game logic. 

These shared building blocks—creative software, scalable servers, and data-driven optimization—are as vital to blockchain games as they are to any Free-To-Play mobile game.

## The Bad: The Complexity of Blockchain Integration
The landscape changes dramatically when you delve into the blockchain-specific aspects of game development. Every feature or decision you make necessitates a uniquely blockchain-oriented piece of software. 

Although the barriers of entry and exiting are being reduced across chains, the first and most critical decision is selecting your first blockchain, which sets the stage for other functionalities like gas fees, dev tooling, and community. 

With time this implementations would be as easy as selecting your right gaming backend. The maturity of teh dev tooling is in progress.

## The Ugly: The Uncertain Coexistence of Web2 and Web3
While Web2 isn't going away anytime soon, its relationship with Web3 is still evolving. Companies like Epic Games are opening up to blockchain, contrasting sharply with Valve's decision to ban NFTs from Steam. This creates a fragmented landscape where Web2 and Web3 technologies coexist but under varying degrees of acceptance and integration. 

At Openfort, we're doing the conscious effort to build integrations with well-known gaming backend providers or identity platform to simply how developers can build backends with Openfort in a blink of an eye. Integration with PlayFab, Firebase or starting with Railway it's today, a reality. 

This article aims to shed light on the importance of Web3 infrastructure in gaming, the challenges faced by players and developers, and how Web3 tools can enhance the Customer Acquisition Cost to Lifetime Value (CAC:LTV) equation.

Game02Article.svg

Building a Web3 Game: The Web3 Gaming Infra Stack (Part 1)

Welcome back to the second installment of our three-part series on Web3 gaming. In the first part, we laid the foundation by discussing what Web3 is and why it's a game-changer for the gaming industry. We also touched upon the challenges that come with this new paradigm. If you missed it, you can catch up here.

- [Part 1: Introduction to Web3 Gaming Infrastructure](https://www.openfort.xyz/blog/introduction-to-web3-gaming-infrastructure)
- Part 2: Tools for Web3 Game Development (You are here)
- Part 3: What we Learned and Examples

Building a Web3 game is not just about integrating a blockchain; it's about choosing the right tools and technologies that align with your game's vision. This article aims to guide you through the essential tools you'll need, from blockchains to wallets and beyond.

## Integration Considerations
- Audience Insight: Knowing your target audience is essential. Identify features that resonate with your players, such as seamless login, unique in-game items, or overall gameplay mechanics. Adapt your approach to integrate web3 elements in a way that enhances player experiences without alienating those unfamiliar with blockchain technology.

- Technical Evaluation: Consider the technical capabilities of your chosen blockchain, especially its transaction handling capacity and smart contract execution. Assess whether the blockchain can support the game’s expected transaction volume, and consider the impact of transaction costs on your game's monetization strategy. This assessment is crucial for games with frequent player interactions or those relying on microtransactions​​.

## Aligning Game Goals with Web3 Integration
Game developers should prioritize creating enjoyable and engaging gaming experiences. When integrating web3 elements, consider if each element enhances the game. For example, trading card games might benefit from tokenizing cards and collectibles, whereas complex genres like MMORPGs or FPS might not need every system on-chain.

The key is to strike a balance between leveraging the benefits of blockchain and maintaining the core gameplay experience.


# Choosing a Blockchain
## The Importance of Flexibility
The question of which blockchain to deploy your game on is a common one and largely hinges on your team's objectives. Given the ever-changing blockchain landscape, maintaining flexibility is often the wisest course of action, as it allows for greater adaptability down the line.

## The Tried-and-True: Ethereum Virtual Machine (EVM)
The Ethereum Virtual Machine (EVM) stands as the original smart contract platform and boasts widespread developer adoption. Due to its longevity and the Lindy Effect, it's often considered the most future-proof option.

## Emerging Contenders: Aptos, Solana and specialized platforms
However, newer ecosystems like Aptos, Solana and specialized blockchains like [Beam](https://www.openfort.xyz/blog/the-beam-subnet-merit-circle), Treasure or ImmutableX are also worth considering. The choice between these and more established options will depend on the specific needs of your game.

## Custom blockchains: App Chains/Rollups
If your game requires functionalities beyond asset ownership, you might consider launching on a dedicated blockchain, often referred to as an app chain. Options like Polygon Supernets, [Avalanche Subnets](https://www.openfort.xyz/blog/openfort-supports-avalanche-and-subnets), Cosmos, Arbitrum Orbit, and Rollup-as-a-Service platforms like Eclipse or the OP Stack provide the flexibility to tailor your infrastructure to specific needs, such as native tokens or ultrafast transaction finality.

## Financial Incentives: Grants and Support
Many blockchain platforms offer grants to incentivize development. While this can be appealing, it's crucial not to let short-term financial support overshadow long-term strategic considerations.

As the blockchain gaming space matures, we anticipate a trend toward consolidation and commodification. While the initial wave of Web3 games targeted crypto-native communities, the next phase will aim for broader appeal, necessitating platforms capable of serving mainstream audiences. 

EVM chains, with their extensive developer tools and liquidity, are well-positioned for this. However, it remains prudent to keep options open and only commit to a specific blockchain when absolutely necessary, keeping the developer experience as a key consideration.

## Onboarding Players to your Game

Onboarding is the first real test of your game's user experience. The process should be as frictionless as possible, accommodating both web3 enthusiasts and web2 newcomers. 

Consider using social logins for the latter, and ensure that the onboarding process educates new users about the blockchain elements they will encounter, such as gas fees and tokens. You can use existing providers like Firebase, Dynamic, [Web3auth](https://www.openfort.xyz/blog/openfort-and-web3auth-partnership), [Particle Network](https://www.openfort.xyz/blog/openfort-and-particle-network-partnership), build your own, or simply use Openfort's one. 

The important question here is: how is the newly created private key (pk) managed for non-crypto users? 
> Note: If the user come with their own wallet already (ie. Metamask, Dawn Wallets, Family, etc.) it's already self-custodial. 

- Non-custodial: Use an **MPC provider** to split the private key into parts (the key is shared and can only be executed with a majority), or store the pk on an **KMS** where only the user can control them. 
- Custodial: Storing the keys in your game's **KMS** or other external KMS providers.

### How to think about wallets
![Untitled-2023-09-01-1733.svg](https://strapi-oube.onrender.com/uploads/Untitled_2023_09_01_1733_2856ad9550.svg)

The wallet is the user's primary touchpoint with the blockchain and, unfortunately, the main source of friction. The ideal game wallet should be invisible to the user. 

It should handle onboarding smoothly and offer features like programmability for recovery and session keys, as well as gasless transactions and fiat onramps. The aim is to minimize friction while maximizing usability and security. 

Luckily, we're now deep into the UX concept of the blockchain, and with concepts like smart accounts (technically called account abstraction - erc4337, hello [Openfort](https://www.openfort.xyz/)!), we can finally hide this complexity from the end user. 

- Setting time-based spending limits
- Human-readable messages when requesting user signatures
- Defining access controls – whitelisting contract functions your account can call
- Creating session keys – removing the need for users to sign every transaction
- Gas abstraction – allowing users to pay gas in any token
- Gasless transactions – the studio or another entity, separate from the user, can subsidize gas fees
- Batching transactions to improve UX – e.g., rolling a uniswap approval and swap into a single transaction

> While the standard is a public good, the innovation happens at the implementation level. In here Openfort offers a server side solution that makes sure to manage nonces, optimize gas fees to ensure transactions reach the blockchain, prioritize transactions, handle retries, and more optimizations.

The best part is the diverse options when it comes to smart wallets. The type of smart account you can use range from Recoverable accounts, [Token Bound Accounts - erc6551](https://www.openfort.xyz/blog/technical-dive-combining-token-bound-account-tba-with-account-abstraction-aa), etc.)

### Improving the Gameplay Experience (GX)

![Untitled-2023-09-01-1733 (1).svg](https://strapi-oube.onrender.com/uploads/Untitled_2023_09_01_1733_1_3c335856d4.svg)

Once onboard, the player's experience should be seamless. This involves handling gas fees, transaction priorities, and even offering fiat onramps for purchasing in-game assets. The idea is to make the blockchain elements as unobtrusive as possible, allowing players to focus on the game.

Imagine building your own payment stack and making sure the user's purchase hits your bank account while also dealing with their credit cards. Well, that's what we do on the blockchain, and that's why a single API call makes it feel like magic. 

So before, we solved the seed phrase when onboarding the user, but now we solve the need for network tokens when interacting with the blockchain and the need to verify every single transaction we do onchain (because sometimes, not all transactions have a monetary value but rather we use them to build a gaming profile onchain). 

How do we solve them? Starting with [gas sponsorhip](https://www.openfort.xyz/blog/technical-dive-gas-sponsorship) and [session keys](https://www.openfort.xyz/blog/technical-dive-session-keys).

## Monetization: ARPU and LTV

crypto can not only increase ARPU Average Revenue Per Customer but preliminary data are already showing that it can increase loyalty and stickiness which means increasing retention to D30 and way way beyond. This means your average LTV will increase wit the right designs.


![RECOVERY1.svg](https://strapi-oube.onrender.com/uploads/RECOVERY_1_4b00af0f7d.svg)

## In-app purchases (IAP) and traditional payment railways
Purchases via stores like the Apple Store, Google Play, or other platforms like Steam, Epic Games, etc. are a traditional way to monetize the game. They have been the sole source of income for the most part. 

Many are looking at blockchain games differently and setting their TOS and policies in a friendly way for games to start incorporating blockchain technology into their gameplay while, of course, respecting the middleman fee.

### In-game shops to sell assets (NFTs)
The in-game shop is not just a revenue stream, but also a feature that can make or break the player experience. It should offer a smooth, intuitive interface for players to buy and own in-game assets, and it will be a main source of revenue for your in-game economy. 

## Gaming Marketplaces
When it comes to marketplaces, you have two main options: external marketplaces like OpenSea, which offer the advantage of network effects, and in-game marketplaces, which allow for more complex, game-specific integrations. 

The choice of having one or both will depend on your game's specific needs and the kind of player behavior you wish to encourage. But having an ingame marketplace has two major advantages: 1) Owning the player experience on your own platform; and 2) Forcing gaming royalties for the in-game assets.

PS. Are you thinking about making a casual web3 game? Then, we thought about how [ingame ads](https://www.openfort.xyz/blog/casual-gaming-in-the-context-of-web3) would look like in web3.

## Using Game Launchers/Aggregators
### The Rise of Web3-Native Launchers
With Valve's decision to ban NFTs and cryptocurrencies on Steam, Web3 game studios are exploring alternative platforms like Epic Games Store (EGS). While EGS provides access to a large traditional gamer base, it may lack specialized Web3 features. 

Launchers will be pivotal in shaping the Web3 gaming UX. Web3-native launchers like Elixir are a good way for games to reduce their CAC while increasing the optionality and network effects of getting new players to view and play their game.

### Tokenized Gaming Ecosystems
Gaming ecosystems like [Merit Circle](https://meritcircle.io/) or TreasureDAO are leveraging token economies to incentivize both studios and players. Tokenized ecosystems offer a unique, arcade-like digital experience that encourages cross-promotion and game discovery. 

## How to Think About (Web3) Player Acquisition
While the traditional gaming marketing playbook has been at large discussed during years (ie. perfomance marketing, etc.), in the Web3 gaming landscape where traditional metrics like LTV (Lifetime Value) and CAC (Customer Acquisition Cost) are still evolving, focusing on low-cost, crypto-native acquisition strategies is crucial. 

One effective starting point is your game's existing **community**. Thanks to crypto-economics, you can align incentives to transform early community members into your game's most passionate advocates and highest spenders, akin to the "golden cohorts" in traditional gaming.

The Web3 audience is often wary of conventional advertising due to the prevalence of scams in the space. **Partnerships** offer a more organic route to gain visibility. Guild collaborations, for instance, can assist in asset distribution, liquidity provision, marketing campaigns, esports events, and content creation. These partnerships not only expand your reach but also validate your game's credibility.

The rise of gaming and IP (**Intellectual Property**) collaborations in Web3 is noteworthy. Interoperability in Web3 allows game assets to be versatile across multiple projects. 

**Airdrops**, the distribution of free tokens to specific wallet addresses, may seem like a cost-effective strategy, but their actual impact is still up for debate. While the only immediate cost is the transaction fee, the long-term effectiveness of this method remains uncertain.

## Takeaways
The Web3 landscape is in constant flux, with new business models appearing and disappearing rapidly. It's vital for founders to remain flexible and aware of platform risks. As the Web3 infrastructure continues to evolve, so will the strategies for player acquisition. Being adaptable and staying updated on industry trends will be key to navigating this ever-changing environment.

This article aims to guide you through the essential tools you'll need, from blockchains to wallets and beyond.

Building a Web3 Game: Tools for Web3 Game Development (Part 2)

The gaming industry is diverse, ranging from AAA games to casual games. AAA games, known for their high development and marketing costs, have dominated the initial phase of web3 games. These games appeal to core PC and console gamers who are typically more tech-savvy and willing to spend more. 

However, the high cost and complexity of developing AAA games have led to a shift in focus towards casual games, which are cheaper to produce and have a broader, more diverse audience.

Could the blockchain gaming space take advantage of it?
## The Casual Game Market
Casual games are relatively inexpensive to create, can be distributed on any platform, and have a promising future with [$25B in revenue forecasted by 2027](https://www.statista.com/outlook/dmo/app/games/casual-games/worldwide). The average session length for casual games is 5-7 minutes, and the demographic skews older, with social casino games being primarily played by middle-aged women. 

Despite these advantages, casual games face challenges in monetization, with low ARPPUs and a conversion rate amongst the lowest of all game categories at ~1%. Web3 could increase the LTV for those that convert but there is still a 99% gamers who won't convert. 

That's mostly the reason why most casual and hyper casual games monetize via ads. 
## Setting the Foundation for Casual Web3 Gaming

![Custodianship.svg](https://blog-cms.openfort.xyz/uploads/Custodianship_35b2f716a8.svg)

### Onboarding
The onboarding process for web3 games has become significantly easier over time. Initially, the process was complex and time-consuming, requiring players to navigate through multiple steps to acquire crypto and buy items. This was particularly challenging for casual gamers, who typically have shorter gaming sessions and may not be as tech-savvy as core gamers.

However, with the advent of account abstraction and fiat on-ramps, the onboarding process has become much smoother. Players can now join and buy into web3 games as easily as connecting with a social login. This is crucial for casual games, as it allows users to get started quickly and easily.

Moreover, this smoother onboarding process opens up the potential for reaching crypto-naive players. These are players who have spent years spending in games without ever being able to earn back some of their losses. By offering these players the potential to earn back some of their money, web3 games could tap into a currently untapped audience.
### In-Game Ads
In-game advertising has traditionally been a challenge for game developers. Banner ads and interstitial ads were often seen as obtrusive and detracted from the gaming experience. However, the in-game ad tech world has changed considerably in recent years.

Brands have recognized the value of gaming's 3 billion players and have invested major ad dollars into the space. New companies have emerged to make the ad experience more native. For example, platforms like Anzu allow developers to build ad real estate into the game, such as corporate logos on racing cars or branded tattoos on avatars. This allows ads to be integrated seamlessly into the game without disrupting gameplay.

Casual games are particularly well-suited for in-game ads due to their short session lengths and the likelihood that they are played on devices with usable browsers. This makes it easier for users to follow an ad link and convert. In fact, data shows that gamers look at integrated game ads twice as long as they do other kinds of ads, leading to better engagement and ad revenue.

With the future of in-game advertising looking promising, estimated to reach [$20B by 2032](https://www.globenewswire.com/en/news-release/2023/05/17/2671210/0/en/In-Game-Advertising-Market-to-reach-USD-20-7-Billion-with-a-12-30-CAGR-by-2032-Report-by-Market-Research-Future-MRFR.html), it presents a significant opportunity for casual web3 games. By integrating seamless in-game ads, developers can enhance the gaming experience for players while also driving revenue.

If you have more questions/ideas/queries, join our [Developer Discord](https://discord.com/invite/t7x7hwkJF4) and let us know there. Furthermore, you can follow us on [Twitter](https://twitter.com/openfortxyz) for our updates as we keep shipping. 

The opportunity of casual and hyper casual web3 gaming sustainable in the future by exploring novel approaches to in-game ads monetization.

Group 345.svg

Casual Gaming in the Context of Web3

As the co-founder of a platform deeply entrenched in blockchain technology and gaming, my recent trip to Asia for various conferences was nothing short of enlightening. The region is a hotbed for innovation in both sectors, and the insights gleaned from these events are invaluable. 

In this article, I'll share our key takeaways, focusing on why Asia is poised to lead in Web3 gaming, impressions from the conferences, and intriguing conversations around innovation and business models.

## Why Asia Will Solve Web3 Gaming First
**- Pragmatic Utility Over Ideology**
In Asia, the focus is on the practical applications of Web3 in gaming. Companies like Nexon and NetEase are more concerned with how Web3 can solve real-world problems, such as enhancing player engagement and creating new revenue streams, rather than getting entangled in ideological debates about decentralization.

**- Learning from the Past**
Asian companies have a history of adapting technology to tackle industry challenges. For instance, Nexon pioneered the Free to Play model as a strategic response to piracy. Today, companies like Gumi and LINE are embracing Web3 to tackle the gray market in digital assets.

**- Strength in Adaptability**
The rapid iteration and focus on economic design by Asian developers make them the frontrunners in the Web3 gaming landscape. For example, the success of games like "Genshin Impact" from miHoYo demonstrates how well Asian companies can adapt to new technologies and market demands.

![IMG_3982 1.svg](https://strapi-oube.onrender.com/uploads/IMG_3982_1_3ca73d6b1c.svg)

## Takeaways and Impressions Over the Conferences
**- Investor Caution**
The investment climate in Asia is marked by a cautious 'wait-and-see' approach. VentureCapital firms are carefully evaluating the macroeconomic landscape before making any significant moves.

**- Web3 Skepticism**
The initial fervor around Web3 technologies like blockchain and NFTs has cooled. Both developers and investors are adopting a more measured approach, as seen in the cautious optimism of companies like Animoca Brands.

**- AI Takes a Backseat**
Contrary to expectations, AI was not a hot topic at conferences like Korea Blockchain Week and GameStart Asia. This could signal a shift in focus within the gaming industry or perhaps a momentary pause to reassess its applications.

**- Genre Fusion**
One of the most exciting trends is the blending of game elements from different genres. Games like "PUBG Mobile" are incorporating elements of survival and battle royale, signaling creative innovation in the industry.

**- Narrative Importance**
There's a renewed focus on storytelling and world-building in game development. Companies like Square Enix are investing heavily in narrative-driven games, indicating a strong market demand for compelling stories.

## Conversation Topics Around Innovation and Business Models
**- Tech as a Catalyst**
Groundbreaking technologies act as the initial spark for industry evolution. Blockchain and AI are often cited as transformative technologies, but it's companies like Samsung and Sony that are turning these technologies into practical applications.

**- Revenue Reimagined**
Once the technology sets the stage, the next phase involves rethinking business models. Companies like DeNA and CyberAgent are pioneering new monetization strategies that align with these new technological capabilities.

**- Gameplay Evolution**
The final stage in this cycle is the birth of novel games that fully leverage these new business models. Games like "Mobile Legends" from Moonton and "Honor of Kings" from Tencent are prime examples of how the industry is transforming to offer players new experiences.

## Takeaways
Our journey through Asia has been an eye-opener, revealing the region's potential to lead in Web3 gaming and beyond. The conferences were a treasure trove of insights, and the conversations were deeply enriching. 

As we continue to navigate the ever-evolving landscapes of blockchain and gaming, these learnings will undoubtedly guide our way.


From investor caution to Web3 skepticism, find out what's shaping the future of gaming and blockchain technology in Asia. Our conference takeaways offer a glimpse into what's next.




Group 396.svg

Unlocking Web3 Gaming: Lessons from Asia's Tech Hubs

There are many opportunities that new models like "free-to-own" and "play-to-earn" models can offer, but currently, most of the available projects simply don't live up to their legacy counterparts. This has led to many doubting that this new generation of games can penetrate mainstream interest. However, this may be short-sighted. It's not the first time that a new technology has been dismissed based on its earliest examples.

Web3 games incorporate blockchain elements, including smart contracts and non-fungible tokens (NFTs), to create virtual assets that can be verifiably owned and traded by players without the intervention of a third party. This innovation puts a high degree of power back into players' hands.

## Early productions don't define the future potential

While many Web3 titles have failed to galvanize their fanbase without their once-lucrative financial boons, this has led to many detractors of the blockchain gaming genre who assume that current offerings are the zenith of what's possible, with the sector dismissed as a fad. However, looking at the recent past -particularly the monolithic rise of mobile gaming- demonstrates that the earliest products should not define future potential.

The classic game Snake was among the most popular early mobile titles when Nokia ported it to its line of mobile phones, with millions playing worldwide. At that point in history, anybody using their phone for gaming could only be called a casual gamer, and a similar story emerged as what we are seeing today.

There are many parallels between the rise of mobile gaming and what we see now. What killer apps may break open the scene to a larger audience remains to be seen, but in 10 years, it's likely that these types of titles will simply exist alongside their home console and mobile brethren.

## How "Blockchain Gaming" got started

![Diagrams.png](https://blog-cms.openfort.xyz/uploads/Diagrams_fd6303fa69.png)

From Kryptokitties and their lack of user engagement (despite having breeding capacity) to P2E with Axie, onboarding thousands of new players to the upcoming third generation of games will start bringing in the larger mainstream gaming community as production value increasingly aligns with traditional AAA games (together with the economic incentives that come with play-to-earn).

The third generation of games is here with the next level free-to-own. Free-to-play started because of piracy. It was a first step to distribution, engagement, etc. then you start monetizing by buying upgrades and items, etc. and finally you are locked in the system with assets you don't really own. 

The next evolution, proposed by [Gabriel Leydon](https://twitter.com/gabrielleydon) is free-to-own, which is free with a step further. It's not only free to play, but you can also own items that have value even before playing the game. Essentially, this extracts the items that everyone is already paying for, with $120B of items sold every year on mobile phones alone. 

## Evolution beyond free-to-play and ownership of in-game items

Players are incentivized to own the item, so they now own the item and can develop further value to it. Essentially, this democratises the free-to-play economy and gives it out for free.

But why stop here? Because of the crypto programmability, you can do pretty much anything with payments, new token types, new timeframes, variables, etc. It's a mistake to look at today's state of crypto and think that's the only thing we'll be able to do. It's an imagination problem.

The world we're going to is not limited to digital land availability, but rather 3M NFTs given out for free to 3M different wallets. What will be the intrinsic value of these NFTs? Probably zero! (everyone is going to have one for free!), but the most successful ones will be the most desired ones despite the fact that there are millions of them.

Virtual items cost literally zero to create, why wouldn't you just give this for free? Attention is the ultimate currency! People expect they'll need some token to buy some stuff, but actually, they'll get something for free and eventually move to crypto. That's the most probable end-game.

If you have more questions/ideas/queries, join our [Developer Discord](https://discord.com/invite/t7x7hwkJF4) and let us know there. Furthermore, you can follow us on [Twitter](https://twitter.com/openfortxyz) for our updates as we keep shipping.

Explore the potential of Web3 games, which incorporate blockchain elements such as smart contracts and NFTs, to disrupt the traditional gaming industry.

Onchain AI agents: What you should know

Onchain AI agents: What you should know

How to build Telegram mini-app with Unity WebGL

How to create Telegram mini-app with React

Announcing Openfort Unreal Engine SDK

Navigating In-App Purchases in web3: A Comprehensive Guide in Unity

Minigames, Frames and anything in between

Building a Web3 Game: Best Practices and Examples (Part 3)

Building a Web3 Game: The Web3 Gaming Infra Stack (Part 1)

Building a Web3 Game: Tools for Web3 Game Development (Part 2)

Casual Gaming in the Context of Web3

Unlocking Web3 Gaming: Lessons from Asia's Tech Hubs

Beyond the Early Game Examples and the Rise of New Categories

Product

Resources

Company

Openfort blog

Onchain AI agents: What you should know

Onchain AI agents: What you should know

How to build Telegram mini-app with Unity WebGL

How to create Telegram mini-app with React

Announcing Openfort Unreal Engine SDK

Navigating In-App Purchases in web3: A Comprehensive Guide in Unity

Minigames, Frames and anything in between

Building a Web3 Game: Best Practices and Examples (Part 3)

Building a Web3 Game: The Web3 Gaming Infra Stack (Part 1)

Building a Web3 Game: Tools for Web3 Game Development (Part 2)

Casual Gaming in the Context of Web3

Unlocking Web3 Gaming: Lessons from Asia's Tech Hubs

Beyond the Early Game Examples and the Rise of New Categories