Openfort has successfully integrated XAI Network into its supported blockchain infrastructure, expanding its capabilities to support the rapidly growing gaming-focused Layer 3 blockchain. 

## Key Integration Features

**Infrastructure Support**
- Full compatibility with XAI Network's mainnet (Chain ID: 660279)
- Seamless integration with Openfort's wallet SDK and developer tools
- Support for game developers to build and deploy on XAI's gaming-optimized blockchain

**Benefits for Developers**
- Access to XAI's high-performance gaming infrastructure with transaction speeds of over 9 million daily transactions
- Integration with XAI's comprehensive web3 development environment
- Ability to leverage XAI's gaming-specific features, including abstracted wallet experiences and increased gas and contract limits

**Technical Details**
```javascript
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.

Openfort has expanded its reach by deploying its wallet technology to Xai network, a gaming blockchain platform. Let's delve into the specifics of what each platform brings to this collaboration.

medium_XAI_support.png

small_XAI_support.png

thumbnail_XAI_support.png

XAI_support.png

Openfort adds XAI Network 

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. 

medium_Unity-telegram.png

small_Unity-telegram.png

thumbnail_Unity-telegram.png

Unity-telegram.png

How to build Telegram mini-app with Unity WebGL

Last Friday marked the end of [Openfort Launch week 1](https://www.openfort.xyz/launch-week), our launch week focused on empowering developers to build better ecosystem wallets and cross-chain experiences.

In the last five days, we shipped five major features and improvements.

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.xyz/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.xyz/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.xyz/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.xyz/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.xyz/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.xyz/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.



medium_wrapup.png

small_wrapup.png

thumbnail_wrapup.png

wrapup.png

Openfort Launch Week 1: Wrap up

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

Openfort has successfully integrated XAI Network into its supported blockchain infrastructure, expanding its capabilities to support the rapidly growing gaming-focused Layer 3 blockchain.

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

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

Seamless integration with Openfort's wallet SDK 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 web3 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.

Openfort adds XAI Network

Key Integration Features

Openfort Launch Week 1: Wrap up

How to build Telegram mini-app with Unity WebGL

Product

Resources

Company