Openfort integrates with XAI Network to power game-first Layer 3 on-chain experiences using seamless wallet infrastructure and gas abstraction tools

Openfort integration with XAI Network gaming-focused Layer 3

Openfort adds the XAI Network


You can now build Telegram Mini-Apps using Unity WebGL. By combining Unity’s rendering power with Openfort’s smart wallet infrastructure, developers can create high-performance onchain games that run directly inside the Telegram messenger.

## How does Unity WebGL work with Telegram?

Unity WebGL allows you to export your 3D or 2D games to run in a web browser. When these games are hosted and linked to a Telegram Mini-App, they can interact with the Telegram Web Apps SDK to authenticate users. Openfort bridges the gap by providing a non-custodial wallet that syncs with the user's Telegram ID, enabling seamless NFT minting and transaction signing without ever leaving the Unity window.


**Reference Documentation:**
- Unity Resources for Telegram Mini-Apps: [Openfort Unity Guide](https://www.openfort.io/docs/products/embedded-wallet/unity/resources/telegram-unity)
- Telegram Mini-App with React: [Blog Post](https://www.openfort.io/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](/images/blog/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.io/docs/products/embedded-wallet/unity/quickstart).

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 onchain features within Telegram.

## Related reading

- [How to build Telegram Mini-Apps with React](/blog/telegram-mini-apps) -- a companion guide covering the same Telegram Mini-App integration using React instead of Unity
- [Embedded wallets explained](/blog/embedded-wallet-explained) -- a deep dive into how the self-custodial wallets powering this integration work
- [Cross-app wallets explained](/blog/cross-app-wallet-explained) -- learn how wallets can persist across multiple apps and platforms
- [Onboard users with guest accounts](/blog/guest-accounts) -- let Telegram users interact with your game instantly, without requiring a login step
- [Introducing global wallets with the Ecosystem SDK](/blog/gaming-ecosystems) -- discover how ecosystem wallets enable cross-game player experiences


Learn how to integrate Openfort into a Unity WebGL Telegram Mini-App. A practical guide to real-time wallet flows and onchain features in gaming apps

Unity WebGL Telegram Mini-App development with Openfort wallets

How to build Telegram mini-app with Unity WebGL


We’ve just wrapped up our first [Launch Week](https://www.openfort.io/launch-week)—five days of shipping features to help developers build better ecosystem wallets and cross-chain experiences.

## What was Openfort Launch Week 1?

Launch Week 1 was a series of daily product releases focused on scaling on-chain user experiences. We introduced the Ecosystem Customization Tool, Ecosystem SDK 2.0, Guest Accounts, a new React Native SDK, and a comprehensive Chain Abstraction framework. These tools are designed to remove the technical friction from blockchain interactions, allowing developers to create seamless, "invisible" wallet systems for their players.


Here's a quick recap of what we launched:

[Day 1: Ecosystem customization tool](##Day-1-Ecosystem-customization-tool)
[Day 2: Ecosystem SDK 2.0](##Day-2-Ecosystem-SDK-2.0)
[Day 3: Guest accounts and new samples](##Day-3-Guest-accounts-and-new-samples)
[Day 4: React Native SDK](##Day-4-React-Native-SDK)
[Day 5: Chain abstraction framework](##Day-5-Chain-abstraction-framework)
[Extra: ZkSync contract audit](##Extra-release-ZkSync-audit)

If you prefer watching instead of reading, **check out [this video](https://youtu.be/dPZB_6LvBwA)**

## Day 1: Ecosystem Customization Tool

On Monday, we introduced a new tool designed to make building ecosystem wallets more accessible to everyone. The Ecosystem Customization Tool simplifies the process of creating tailored wallet experiences through an intuitive interface.

Key features include:
- Pre-built theme selection
- Custom color palette configuration

[Read announcement](https://www.openfort.io/blog/ecosystem-customization-tool)

## Day 2: Ecosystem SDK 2.0

Tuesday brought a major upgrade to our SDK, focusing on developer experience and enhanced functionality. Ecosystem SDK 2.0 introduces several groundbreaking improvements:

- Removed API key requirements for simpler integration
- Added ERC5792 standard compatibility
- Implemented encrypted communication via Mobile Wallet Protocol (MWP)
- Streamlined package management

[Read announcement](https://www.openfort.io/blog/announcing-ecosystem-wallet-2)

## Day 3: Guest accounts and new samples

On Wednesday, we unveiled Guest Accounts, a feature designed to reduce friction in user onboarding. This powerful addition allows users to:
- Start using apps immediately without login requirements
- Maintain persistent access through local storage
- Seamlessly upgrade to full accounts when ready

[Read announcement](https://www.openfort.io/blog/guest-accounts)

## Day 4: React Native SDK

Thursday saw the alpha release of our React Native SDK, bringing Openfort's powerful wallet functionality to mobile development. The release includes:
- Full React Native compatibility with ecosystem SDK and embedded wallet
- Comprehensive Expo support
- Cross-platform authentication
- State synchronization across web and mobile

[Read announcement](https://www.openfort.io/blog/react-native-sdk)

## Day 5: Chain Abstraction Framework

We concluded the week with our most ambitious release yet: the Chain Abstraction framework. This revolutionary system enables:
- Cross-chain interactions using time-locked vaults
- Integration with MagicSpend++ and Polymer's Prove API
- Ecosystem-owned liquidity provision
- Trust-minimized execution with onchain proving

[Read announcement](https://www.openfort.io/blog/chain-abstraction)

## Extra release: ZkSync audit
A final suprise. We announced the ZkSync smart contract audit as well as the overall improvements in our infrastructure enabling us to speed the acount creation and processing for our clients.

[Read announcement](https://www.openfort.io/blog/extra-launch-1)

## Looking Forward

This launch week represents a significant step forward in our mission to make wallet development and cross-chain interactions more accessible and efficient. From simplifying wallet creation to enabling seamless cross-chain operations, each feature was designed with developer experience and user needs in mind.

See you in the next one!


Everything we launched during the first launch week at Openfort.  

Openfort Launch Week 1 feature releases and announcements recap

Wrap up: Launch Week 01

- [What is the XAI Network?](#what-is-the-xai-network)
- [Key Integration Features](#key-integration-features)
- [Related reading](#related-reading)

, bringing smart wallet infrastructure to this gaming-focused Layer 3. This integration allow developers to build fast, gasless experiences for players on the XAI mainnet.

Openfort now supports the [XAI Network](https://xai.games/), bringing smart wallet infrastructure to this gaming-focused Layer 3. This integration allow developers to build fast, gasless experiences for players on the XAI mainnet.

[What is the XAI Network?](#what-is-the-xai-network)

XAI is a Layer 3 blockchain built on Arbitrum, specifically optimized for high-performance gaming. It offers features like 1-second block times and low transaction costs, making it ideal for games that require frequent on-chain interactions. By integrating with XAI, Openfort provides the account abstraction tools needed to make these features invisible to the end user, enabling players to interact with digital assets as easily as they would in any traditional game.

[Key Integration Features](#key-integration-features)

Full compatibility with XAI Network's mainnet (Chain ID: 660279).

Seamless integration with [Openfort's wallet SDK](https://www.openfort.io/solutions/gaming) and developer tools.

Support for game developers to build and deploy on XAI's gaming-optimized blockchain.

Access to XAI's high-performance gaming infrastructure with transaction speeds of over 9 million daily transactions

Integration with XAI's comprehensive on-chain development environment

Ability to leverage XAI's gaming-specific features, including abstracted wallet experiences and increased gas and contract limits

import Openfort from '@openfort/openfort-js'

const openfort = new Openfort({
    baseConfiguration: {
        publishableKey: 'openfort-publishable-key',
    },
    chainId: 660279 // XAI Network Mainnet
});


This integration enables game developers to utilize Openfort's battle-tested wallet abstraction technology while tapping into XAI's gaming-optimized blockchain infrastructure. Developers can now build seamless gaming experiences that combine the security of blockchain technology with the performance requirements of modern games.

A beginner's guide to Web3 gaming infrastructure and where XAI fits in

[A beginner's guide to Web3 gaming infrastructure and where XAI fits in](/blog/introduction-to-web3-gaming-infrastructure)

How gaming ecosystems are evolving across chains like XAI

[How gaming ecosystems are evolving across chains like XAI](/blog/gaming-ecosystems)

Openfort powers gaming on Ancient8, another gaming-focused Layer 2 chain

[Openfort powers gaming on Ancient8, another gaming-focused Layer 2 chain](/blog/openfort-integrates-with-ancient8-chain)

Openfort adds the XAI Network

Table of Contents

Switch to Openfort

Table of Contents

Switch to Openfort

What is the XAI Network?

Key Integration Features

Keep Reading

Wrap up: Launch Week 01

How to build Telegram mini-app with Unity WebGL

Try Openfort Free