🗺️Technology and Infrastructure

5.1 Cross-Platform Support (WebGL and Mobile)

ZkStrike prioritizes one of the most crucial requirements of the modern gaming industry, which is cross-platform support, to reach a wide user base. This support ensures that players can have a seamless experience across different devices and platforms, allowing everyone to play ZkStrike in their preferred gaming environment.

WebGL Support

With WebGL support, ZkStrike can be played directly through web browsers. This means that players can experience the game in modern web browsers like Chrome, Firefox, Microsoft Edge, Brave, and more, without the need to download or install any additional software. This significantly enhances the accessibility of the game and makes it available to a broader audience. Players can enjoy ZkStrike's rich graphics and smooth gameplay mechanics through their preferred web browser, ensuring consistent performance on various platforms and devices.

Mobile Compatibility

Mobile compatibility is essential in today's world, where people heavily use mobile devices in their daily lives. ZkStrike has been optimized for Android and iOS operating systems and is available on Google Play Store and Apple App Store. This allows users to play the game flexibly, anytime and anywhere, using their mobile devices. The extensive reach provided by mobile platforms makes ZkStrike appealing to users of all ages and gaming preferences, expanding the game's community and introducing more people to the exciting world of ZkStrike.

Benefits of Cross-Platform Integration

Expanded Player Base: Cross-platform support brings together players with different preferences and habits, leading to a wider reach and popularity among various gaming communities.

Continuous Development: Being available on multiple platforms encourages developers to keep the game up to date and make performance improvements for all platforms. This supports the long-term success and player satisfaction of the game.

Community Building: Cross-platform support enables players from different devices to play together and interact. This fosters a stronger sense of community among players and strengthens social bonds.

ZkStrike's cross-platform support sets a standard in the modern gaming world for diversity and accessibility. This approach ensures that everyone can play the game on their terms, making the game more inclusive and providing a more comprehensive gaming experience.

5.2 Multiplayer Infrastructure

The multiplayer aspect of ZkStrike is powered by Photon Quantum, a robust solution designed to deliver maximum performance with minimal latency, making it an ideal fit for fast-paced FPS games. In the realm of first-person shooters, where even a fraction of a second's delay can significantly impact gameplay, the need for a powerful and efficient multiplayer server solution is paramount. Photon Quantum addresses this need effectively.

Photon Quantum is engineered to handle the high-speed demands of FPS gaming, ensuring that player actions and movements are synchronized in real-time with exceptional precision. This level of performance is crucial for maintaining the integrity and competitiveness of the gaming experience in ZkStrike. The technology minimizes lag, a critical factor in fast-paced gaming scenarios, thus ensuring that players have a fair and responsive gameplay environment.

Moreover, the integration of Photon Quantum into ZkStrike signifies a commitment to providing players with a high-quality, seamless multiplayer experience. This integration showcases the game's technical sophistication and its focus on player satisfaction. By choosing Photon Quantum, ZkStrike benefits from its advanced networking capabilities, which are essential for supporting the dynamic and interactive nature of multiplayer FPS games.

In essence, Photon Quantum's role in ZkStrike is to bridge the gap between high-performance demands and the real-time, interactive needs of an FPS game, ensuring that players have an uninterrupted and immersive gaming experience. This technology is a key component in delivering the fast, reliable, and engaging multiplayer gameplay that ZkStrike aims to offer.

5.3 Avatar System

ZkStrike harnesses the capabilities of Ready Player Me, a comprehensive avatar creation interface, allowing players to craft detailed and personalized characters when they enter the game. Through Ready Player Me, players have the freedom to choose their avatar's gender, facial features, and a wide array of outfits, accessories, and jewelry, enabling them to create a unique personal character. These avatars can be saved to a Ready Player Me account and are transferable across various platforms, making them usable in other games and experiences within the metaverse. Additionally, players can use selfie photos and leverage artificial intelligence technology to create avatars that closely resemble themselves. This feature enriches the gaming experience, allowing players to enter the game each day with distinct characters, adding to the dynamic, interactive, and vibrant competition.

The integration of Ready Player Me into ZkStrike offers several advantages:

Personalized Characters: Players can express their individuality through a wide range of customization options, crafting avatars that reflect their personal style or fantasy personas. Diverse and High-Quality Animations: The avatars are equipped with a variety of animations, enhancing the realism and engagement of the gaming experience. Cross-Platform Compatibility: Avatars created in ZkStrike via Ready Player Me can be used across different games and platforms within the metaverse, providing a consistent digital identity.

VR-AR Support: The avatars created using Ready Player Me are designed to be compatible with both virtual and augmented reality environments. This compatibility significantly enriches the interoperability experience of ZkStrike. Furthermore, this feature is particularly important considering that these avatars will also be utilized in Neuroverse, the flagship project of Neurolanche X Labs, in the future.

By integrating Ready Player Me, ZkStrike not only elevates the level of personalization and immersion for its players but also stays at the forefront of avatar technology, providing a seamless and enhanced gaming experience that bridges the virtual and real worlds. This approach is particularly significant in the evolving landscape of online gaming, where personal expression and cross-platform continuity are increasingly valued by players.

5.4. Database Management

ZkStrike relies on Playfab for the management and storage of player data, offering a robust and efficient database solution tailored for gaming applications. The integration of Playfab allows for detailed tracking and analysis of player statistics, which are essential for continuous game development and improvement.

The types of data stored in Playfab for ZkStrike include:

  1. Player's Blockchain Address: This critical piece of data links the player's in-game activities to their unique blockchain identity, ensuring a secure and verifiable record of interactions within the game.

  2. Number of Kills: The game tracks each player's kills, providing valuable data for gameplay balancing, skill assessment, and fostering a competitive environment.

  3. Number of Deaths: Tracking player deaths helps in analyzing game difficulty, player skill levels, and the effectiveness of various in-game strategies.

  4. NFTs Held by Players: This information is pivotal in a blockchain-based game, as it details the digital assets each player possesses, which influence their rewards.

  5. Stake Information: The details of players' stakes within the game's ecosystem provide insights into player engagement and investment in the game, Neurolanche, and Astar Network.

  6. Geographical Region of Player's Access: Understanding where players are accessing the game from can help in regional marketing strategies and server load balancing.

  7. Game Access and Match Dates: Tracking when players access the game and participate in matches aids in understanding peak usage times and player engagement patterns.

  8. Unique Player Count: This metric provides insights into the game's reach and player base expansion.

  9. Weekly Player Count: A measure of active engagement, helping in assessing weekly trends in player activity.

Additionally, the statistics of kills and deaths are utilized to maintain an in-game leaderboard. This leaderboard plays a significant role in the game's competitive landscape, as it is used for organizing tournaments and rewarding successful players with extra rewards.

An important aspect of Playfab's integration with ZkStrike is how it handles the connection between players' Ready Player Me avatars and their public blockchain addresses. This integration works as follows:

Digital Identity and Player Interaction: Avatars created by players through Ready Player Me are linked to their unique blockchain addresses and stored in Playfab. This linkage ensures that the player's in-game actions and digital assets are securely recorded and verifiable, enhancing the integrity and personalization of the gaming experience.

Customization and Ownership: This integration allows players to not only customize their in-game appearance through their avatars but also securely associate these avatars with their blockchain-based digital identity. This approach adds a layer of ownership and personalization, as the avatars become a unique representation of the players within the game.

Playfab's database solution for ZkStrike exemplifies how advanced data management technologies can be effectively employed in modern gaming. By meticulously tracking and analyzing these data points, ZkStrike developers can continuously refine the gaming experience, tailoring it to player behaviors and preferences. This data-driven approach is crucial for the dynamic and evolving world of online gaming, where player satisfaction and engagement are key to the success of the game.

5.5. Use of Blockchain Technology

ZkStrike aims to revolutionize the gaming industry by strongly integrating blockchain technology. ZkStrike operates on Astar zkEVM within the Ethereum ecosystem, offering players a unique gaming experience. Here are the details of ZkStrike's updated use of blockchain technology:

Integration with Astar zkEVM

ZkStrike seamlessly operates on Astar zkEVM, leveraging advanced features of the Ethereum ecosystem. This integration ensures that players have a smooth experience on the Ethereum blockchain. Astar ZkEVM combines Ethereum's security and compatibility with zk-Rollups' scalability advantages, providing high-performance and cost-effective blockchain transactions.

Account Abstraction

With the introduction of the mobile version of ZkStrike, players can access the game using Web2 login methods such as email or social media accounts. Account Abstraction, available in both the browser and mobile versions of the game, automatically creates a smart wallet in the background, allowing players to join the game seamlessly without dealing with blockchain transactions. Astar zkEVM technology ensures efficient and secure execution of this process, eliminating the complexity of joining a blockchain game for players.

Play-to-Earn Mechanism

In-game activities reward players with $NEROX tokens. This enables players to earn real value by playing the game, enhancing the game's appeal and player commitment. Thanks to account abstraction on Astar zkEVM, these rewards can be managed and distributed efficiently, further strengthening the play-to-earn mechanism of the game.

In-Game Digital Assets and Economy

In-game digital assets are presented as NFTs on Astar zkEVM and can be purchased in the game's Store or traded on the game's Marketplace, all using the game's native cryptocurrency, $NEROX tokens. This economic model provides players with the opportunity to earn value and convert their in-game assets into real-world value.

5.6. The Role of Smart Contracts

As a blockchain-based game, ZkStrike utilizes smart contracts for various crucial functions, including reward distribution, smart contract-based operational processes, and NFT transactions. The game executes these functions via the Astar zkEVM, which belongs to the Ethereum ecosystem.

Function of Astar zkEVM Smart Contracts

Astar zkEVM (Ethereum Virtual Machine) enables Ethereum-based smart contracts to run seamlessly on the Astar Network, allowing Ethereum developers and dApps to benefit from the advantages offered by Astar. Combining the security and compatibility of Ethereum with the scalability benefits of zk-Rollups, zkEVM provides high-performance and low-cost blockchain transactions.

Smart contracts automate and decentralize the distribution of rewards to users.

Examples and Codes of Smart Contracts

zkEVM Reward Collection Smart Contract: An example smart contract for zkEVM written in Solidity language is as follows. This contract enables players to claim rewards they have earned from weekly events.

solidityCopy codepragma solidity ^0.8.17;

contract RewardingContract {
    address public owner;
    uint public thresholdTime;

    struct RewardInfo {
        address recipient;
        uint amount;
    }

    RewardInfo[] public rewards;

    event RewardSent(address indexed to, uint value);

    constructor() {
        owner = msg.sender;
        thresholdTime = 0;
    }

    function deposit() public payable {}

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    function setRewards(address[] memory addresses, uint[] memory amounts) public onlyOwner {
        require(addresses.length == amounts.length, "Addresses and amounts arrays must have the same length");
        delete rewards;

        for (uint i = 0; i < addresses.length; i++) {
            rewards.push(RewardInfo({recipient: addresses[i], amount: amounts[i]}));
        }

        thresholdTime = getNextSaturday12PMUTC();
    }

    function claimRewards(address to) public {
        require(msg.sender == to, "Caller must be the reward recipient");
        require(block.timestamp <= thresholdTime, "Reward time has passed");

        for (uint i = 0; i < rewards.length; i++) {
            if (rewards[i].recipient == to) {
                uint reward = rewards[i].amount;
                require(reward > 0, "No reward available for this address");

                (bool sent, ) = to.call{value: reward}("");
                require(sent, "Failed to send reward");
                emit RewardSent(to, reward);

                rewards[i].amount = 0;
                return;  
            }
        }

        revert("Recipient not found in reward list");
    }

    function getNextSaturday12PMUTC() private view returns (uint) {
        uint dayInSeconds = 86400;
        uint timeToNoon = 12 hours; 
        uint dayOfWeek = (block.timestamp / dayInSeconds + 4) % 7; 

        uint daysUntilSaturday;

        if (dayOfWeek < 6) { 
            daysUntilSaturday = 6 - dayOfWeek; 
        } else if (dayOfWeek == 6) { 
            uint currentTime = block.timestamp % dayInSeconds;
            if (currentTime >= timeToNoon) {
                daysUntilSaturday = 7;
            } else {
                daysUntilSaturday = 0;
            }
        }

        uint nextSaturdayNoon = block.timestamp + daysUntilSaturday * dayInSeconds + timeToNoon - (block.timestamp % dayInSeconds);
        
        return nextSaturdayNoon;
    }

    function getBalance() public view returns (uint) {
        return address(this).balance;
    }

    function withdraw(uint amount) public onlyOwner {
        payable(owner).transfer(amount);
    }

    function getRewards() public view returns (RewardInfo[] memory) {
        return rewards;
    }

    function setThresholdTime(uint newThresholdTime) public onlyOwner {
        thresholdTime = newThresholdTime;
    }
}

Phat Contracts and Their Applications

Phat Contracts emerge as a pivotal technology bolstering the blockchain-based structure of ZkStrike. These advanced smart contracts amalgamate player experience and entertainment with decentralized and robust solutions, offering not just smart contracts but also a decentralized, programmable backend for contract calls and interactions with the external world.

Uses of Phat Contracts Phat Contracts play various roles within ZkStrike:

As Programmable Oracles: They transport necessary off-chain data to ZkStrike smart contracts, enriching the game with real-world data and dynamics such as randomness.

As Decentralized Backend: They store and process off-chain data for multiple blockchain connections and data flows according to specific logic. This is critical for managing player reward systems and connecting with ZkStrike smart contracts.

SDKs and Tools The SDKs and tools used for developing and implementing Phat Contracts include:

  • Phat Off-Chain Rollup: GitHub - Phala-Network/phat-offchain-rollup

  • Phat Contract Starter Kit: GitHub - Phala-Network/phat-contract-starter-kit

  • JS SDK: GitHub - Phala-Network/js-sdk

These tools facilitate the development of Phat Contracts and their integration into web3 games developed with the Unity game engine, like ZkStrike.

New Applications of Phat Contracts

Phat Contracts have exciting applications in ZkStrike:

As Decentralized Backend: They decentralize the storage and management of various user and game data, such as player addresses, types, leaderboards, achievements. They perform reward calculations based on players' off-chain social media interactions and other criteria.

For In-Game Play-to-Earn Mechanisms: They call smart contracts within Phat Contract to manage players' earnings, thereby allowing players to gain real value through gameplay.

Transforming NFTs into Dynamic Assets: Based on player achievements and on-chain ZkStrike activities, they transform NFTs on various Ethereum-based networks into dynamic NFTs within the game.

Below is an example Phat Contract code interacting with Filebase, a decentralized cloud storage solution, through a decentralized cloud system. This code enables data uploading, reading, and deletion processes:

rustCopy code#![cfg_attr(not(feature = "std"), no_std, no_main)]

#[ink::contract]
mod example {
    #[ink(storage)]
    pub struct Example {}

    impl Example {
        #[ink(constructor)]
        #[allow(clippy::should_implement_trait)]
        pub fn default() -> Self {
            Self {}
        }

        #[ink(message)]
        pub fn storage(&self) {
            use pink_s3 as s3;
            
             // Filebase-specific endpoint and region information.
             let endpoint = "s3.filebase.com";
             let region = "us-east-1"; // 'us-east-1' is also commonly used for Filebase, but it doesn't matter for this example.
             let access_key = env!("FILEBASE_ACCESS_KEY");
             let secret_key = env!("FILEBASE_SECRET_KEY");

             //Creating the S3 object for Filebase.
             let s3 = s3::S3::new(endpoint, region, access_key, secret_key)
                 .unwrap()
                 .virtual_host_mode();

             //Defining the bucket and object key.
             let bucket = "ZkStrike";
             let object_key = "myfolderx/myfilex.txt";
             let value = b"bar";

             // Loading the object into Filebase.
             s3.put(bucket, object_key, value).unwrap();

             // Checking the header information of the loaded object.
             let head = s3.head(bucket, object_key).unwrap();
             let mut head_content_length: u64 = 0;
             for (k, v) in head.headers {
                 if k.to_ascii_lowercase() == "content-length" {
                     head_content_length = v.parse().expect("expect length")
                 }
             }
             assert_eq!(head_content_length, value.len() as u64);

             // Retrieving the object from Filebase and validating the content.
             let v = s3.get(bucket, object_key).unwrap().body;
             assert_eq!(v, value);

             // Deleting the object from Filebase.
             s3.delete(bucket, object_key).unwrap();
        }
    }
}

Phat Contracts, integrated with Astar zkEVM smart contracts, expand decentralized solutions and allow transactions outside the scope of smart contract functionality to be executed in a decentralized environment.

NFT Collection and Marketplace Smart Contracts

For in-game digital assets and NFT transactions, ZkStrike features specially developed NFT collection and marketplace smart contracts. These contracts enable players to buy, sell, and trade NFTs, enriching the game's economic ecosystem.

In summary, smart contracts are a cornerstone of ZkStrike, managing various critical functions such as reward distribution, NFT management, and player interactions. Astar zkEVM smart contracts and Phat Contracts work in harmony with the game's blockchain systems, offering not just an entertaining gameplay experience but also creating an ecosystem with real-world value.

5.7. Token-Gate System and Interaction with NFT Communities

ZkStrike also adopts a Token-Gate system that allows players to log into the game through web3 wallets carrying their digital identities. This system supports various web3 wallets including Subwallet, Talisman, Polkadot.js, and MetaMask. Subwallet, Talisman, and Polkadot.js facilitate interaction with blockchain networks compatible with Polkadot's Substrate, while MetaMask is used for networks compatible with the Ethereum ecosystem.

Game Access Conditions

To access ZkStrike, players must meet at least one of the following criteria linked to their web3 wallets:

Owning an NFT: Players must own at least one NFT from various collections associated with Neurolanche X Labs partnerships. These NFTs are primarily hosted on the Astar Network and various Polkadot parachains or EVM-compatible blockchain networks and include:

  • Neurolauncher - Astar Network (Main NFT Collection)

  • Astar Degens - Astar Network

  • Astar Sign Witch - Astar Network

  • Astar Cats (Oden DAO) - Astar Network

  • Cult Bears DAO - Astar Network + Moonbeam (Cross-Chain)

  • DeGenerous DAO - Exosama

  • ApeXchimpz - Kusama

  • Kanaria Skybreach - Base Network

  • Talisman Spirit Keys - Kusama

  • xAlice - Astar Network

  • YoudleDAO - Kusama

  • PhalaWorld - Phala Network

  • DED Community - Polkadot

ASTR Staking: Players must stake at least 30,000 ASTR in the dApp staking program for the Neurolanche X Labs project on the Astar Network. The official site link for Neurolanche X Labs dApp staking is: https://portal.astar.network/astar/dapp-staking/dapp?dapp=bylgjmskwd4s4pteacf2snbwfem4bners27fgnvcc9sqre4

Players who meet at least one of these conditions gain access to ZkStrike and can participate in matches and tournaments held every Saturday between 12:00 PM and 1:00 PM UTC. Participation in these weekly events allows them to win rewards depending on the type of NFT they own or their ASTR staker status.

Interaction with NFT Communities

The Token-Gate system and NFT ownership encourage unique interaction and engagement among communities within ZkStrike. Players can access in-game advantages, special events, and community-focused interactions through owning specific NFT collections. This system ensures the game functions not only as an entertainment platform but also as a space for community and identity expression.

Alongside the NFT communities mentioned above, ZkStrike will also include various ethereum L2 networks like astar zkEVM, polkadot, polygon, and other NFT communities, allowing them to form their clans. The upcoming staking system, along with staking pools, will introduce a form of gamification for the $NEROX token, creating a new utility for it. Players will be able to use the $NEROX tokens earned from the staking system in the in-game store and marketplace, or transfer them out of the game to sell. The staking system is discussed in more detail under section 6.1.2.

5.8. Account Abstraction and Free-To-Play

After the launch of Astar zkEVM in February, ZkStrike plans to implement account abstraction and a free-to-play mechanism on mobile and WebGL platforms in collaboration with Gelato. This new approach aims to facilitate blockchain interactions for Web2 users and gamers, specifically targeting them to ease their entry into ZkStrike.

What is Account Abstraction?

Account Abstraction is an interface design approach that shields users from the underlying complexities of the blockchain when interacting with dApps and blockchain transactions. It allows users to engage with dApps and perform transactions without worrying about technical details like web3 wallets, native token requirements, and transaction signing. Managing complex processes behind the scenes enables users to focus on the practical use and benefits of the application.

Simplifying and Abstracting Blockchain Interactions and Transactions

User-Focused Interface Design: Account abstraction enables users to interact with dApps without understanding technical aspects such as smart contract functions or the complexities of the Ethereum Virtual Machine (EVM).

Abstraction of Complex Processes: Critical technical elements like gas fee calculations, wallet management, and cryptographic transactions are managed in the background without overwhelming the user experience.

Paying Transaction Fees by Sponsors Reducing Cost Burden: With ERC-4337, the responsibility for transaction fees can be shifted from users to sponsors, such as dApp developers. This model eliminates the need for users to pay for basic services.

Expanding User Base: Eliminating the need for users to pay gas fees makes blockchain technology more accessible to a broader audience.

Purchasing Web3 Assets with Popular Payment Methods and Fiat Currency

Integration with Common Payment Systems: Integrating with popular payment systems like Apple Pay, credit/debit cards, and online banking services allows users to directly purchase blockchain assets.

Using Fiat Currencies: This feature facilitates the direct purchase of blockchain assets using local currencies.

Improvements in UI/UX for dApps

Enhanced User Interfaces: Account abstraction significantly improves the UI/UX of dApps, making them as intuitive and easy to use as traditional applications.

Simplifying Account Security User-Friendly Security Measures: Simplifies account security by eliminating the requirement for traditional 12-word seed phrases.

Account Abstraction with Gelato and ERC-4337

Gelato offers an account abstraction solution compatible with ERC-4337 on Astar zkEVM, redefining users' interactions with Ethereum and compatible blockchains. ERC-4337 enables smart contract wallets to initiate transactions themselves, eliminating the need for users to manage a separate Externally Owned Account (EOA) and ETH balance. This opens the door to a range of exciting use cases.

What is a Smart Wallet?

Smart wallets are wallets controlled by smart contracts that secure and recover wallet information using code. Ethereum has two types of accounts: Externally Owned Accounts (EOA) and Contract Accounts (Smart Contracts). A Contract Account is managed by a Smart Contract instead of an EOA.

Benefits of Smart Wallets:

Fully Programmable: Smart wallets can perform any smart contract function and be upgraded to add new features. Flexible Authentication Logic and Recovery: Users can employ various authentication methods, such as social logins, session keys, and biometric data. Gasless Transactions: Transaction fees can be fully covered by sponsors, and payments can be made with ERC-20 tokens.

Why ERC-4337?

ERC-4337 allows for account abstraction without any changes to the consensus layer, increasing the likelihood of faster adoption.

Entry Point and Bundler

The Entry Point is a singular smart contract that manages the validation and execution of user operations. Bundlers collect multiple User Operations from an alternative mempool and relay them to the Entry Point as a single transaction. Gelato uses its existing infrastructure to sponsor transactions, thus reducing the financial burden on users.

Paymaster

The Paymaster is a service that covers transaction fees on behalf of the user. Gelato manages the transaction costs through the Paymaster post-transaction, avoiding overburdening users and reducing on-chain footprint.

This comprehensive account abstraction solution presents an ideal solution for users who want to play ZkStrike but do not want to deal with the complexities of blockchain technology. The integration of Gelato and ERC-4337 supports the game's free-to-play model, enabling access to a wide user base and significantly improving the user experience. This positions ZkStrike as a pioneer in shaping the future of blockchain-based gaming.

Free-To-Play Mechanism

Account Abstraction forms the foundation of ZkStrike's free-to-play mechanism. This approach allows players to directly access the game using common web2 login methods without needing any web3 wallet and eliminates the requirement to hold any tokens or NFTs. Blockchain transactions are abstracted from the user, striking a perfect balance between UI, UX, and the enjoyment of the game with the benefits of blockchain technology. Additionally, this system enables users to directly purchase the in-game digital currency, $NEROX tokens, using popular payment systems such as Apple Pay, credit/debit cards, and online banking services, making the in-game experience much smoother. Thus, players can purchase $NEROX tokens directly with fiat currencies (USD, EUR, GBP, etc.) without using traditional crypto exchanges, combining the strong gameplay experience of traditional games with blockchain-based solutions effectively.

PreviousZkStrike - General OverviewNextIn-Game Economy

Last updated