Fake WASM Transactions (TXS)

Important announcement: Yesterday, there was content regarding transactions that took place on WASM, and we had shared this report through Sota and Maarten, as well as in some places opened on the Forum under the name of Neurolanche, drawing attention to the figures mentioned there.

Until yesterday, there had been 13,412 WASM activities, and we had revealed that 16.26% of these activities were related to Neurolanche projects, thereby showing some individuals the false accusations made against us. As Neurolanche, we are analyzing daily activities and monitoring transactions every second to oversee activities happening on Astar Network. Less than 24 hours after the report we made and shared yesterday, we started noticing a difference on WASM. While there have been 13,412 activities up to today, now there is one transaction per 2-4 minutes around taking place.

Here, as the Neurolanche team, we believe that fake transactions are being carried out following the report we presented on WASM, and that there is a counterattack intended to render our report meaningless in the future. However, we do not know who is behind these actions and are not accusing anyone in this matter.

Now I will send you the two reports I presented on the forum yesterday, along with the text I shared with Maarten and Sota.

Report 1:

Report 2 - Shared with Sota and Maarten:

———————————————

I would like to share the data occurring on WASM by Neurolanche.

Unfortunately, due to the lack of dApp rader support, this process took some time.

1- Total number of transfers on Astar Network WASM:

In 2023, Astar Network focused all its capabilities on developing on WASM. During this period, significant campaigns were conducted, but a total of 13,441 transactions occurred on WASM.

Considering these issues, it has been observed that other projects like *****, which have focused on developing on WASM, have not been successful.

It is said that Astar Network plans to undertake development processes on WASM in 2023 with the revenues obtained from dApp staking, but when asked about their latest development areas, it has been mentioned that they have been removed from their roadmaps.

I commend ***** here. Unfortunately, developments on WASM were not only stopped by a single dapp but also Astar Core’s priority has been Astar ZkEvm. Therefore, when we asked the ****** team, they mentioned that their development processes have changed.

That’s why Firolauss is building on Astar ZkEvm, and we plan to publish ZkStrike (formerly known as Astar Strike) on Astar ZkEvm along with our whitepaper that we will release tomorrow.

As the Neurolanche team, we have tried to lead in the development process on WASM’s side for Astar Network, but unfortunately, the lack of sufficient tools in this area is making us move to ZkEvm.

In addition, ****** here is just a small example. We support their roadmap change.

2- Data on Neurolauncher NFT collection:

The Neurolauncher NFT collection was released on May 31 in collaboration with PARAS Nft marketplace. During this process, it has been noted as the first WASM NFT collection with a collection value created by the community.

A total of 1628 transactions have occurred instantly. With this rate, it has played a significant pioneering role in the Astar Network WASM network with a rate of 12.21%.

Neurolauncher NFT collections will always remain on the WASM infrastructure to demonstrate WASM’s leadership and pioneering role.

3- Data on Astar Strike:

The development of Astar Strike has been carried out in collaboration between Neurolanche and Illumates Studio. One of the purposes of creating Astar Strike is to create a gamefi Hub on Polkadot and add utility to NFT collections.

Astar Strike, still in the development process, will soon be moved to Astar ZkEvm and will enter the Account Abstraction infrastructure, escaping from the tokengate part. During this period, the entire development cost of Astar Strike is formed by Neurolanche’s dApp staking revenues.

Astar Strike, still in development, has undergone 7 closed beta processes.

Each closed beta process takes place between 12:00 PM UTC and 01:00 PM UTC on Saturdays.

Having gone through 7 closed beta processes, Astar Strike is an early-stage game with a total of 7 hours of playtime.

Recently, we have spent a $40,000 investment obtained from our dApp staking revenues here, signing a new contract, and a strong FPS game has been designed with a total investment of $53,400.

You can find the investment contracts made to date below:

First contract: $2900 payment (Completed)

Second contract: $10,500 payment (Completed)

New contract: $40,000 payment ($38,000 payment remaining)

Roadmap:

Step 1.0 Performance + New Map⚙️

January 16, 2024 → February 17, 2024

In our first update, we will address significant optimization issues in Astar Strike and ensure the game reaches a seamless user experience.

Along with our work on graphic engines, we aim to primarily optimize the battle royale mode to ensure our game operates smoothly.

Performance : 3 week

URP Asset settings

• Ez Pooling

• Materials (Gpu Instancing, Shader)

• Textures

• Quantum (Input compression)

• Remove Graphy (FPS counter)

• Kinemation, remove leg rotation animation

New Map : 1 week // performance, art style changed.

Step 2.0 Mobile & Voice Chat📱

February 18, 2024 → March 24, 2024

Mobile devices have become a significant part of our daily lives. As Neurolanche, we aim to reach millions of users by integrating Astar Strike into mobile devices. In addition, we will provide a unique experience to users by adding in-game voice chat areas.

• Mobile integration: Building and optimising for android and IOS devices: 3 week

• Voice Chat: Chatting in game: 2 week

Step 3.0 Gamification🙌🏼

March 24, 2024 → April 28, 2024

This update will be one of the most important updates for Phat Contracts and the NEROX token. With this update, we will offer a variety of entertaining experiences for users, ranging from CS:GO-like chest systems to in-game missions in Astar Strike.

Achivements : Achivement system and chests, database connection: 2 week

Weapon: Customization, store, custom skins: 3 week

Step 4.0 Clans - Flag Mode🏰

April 28,2024 → June 10, 2024

With the upcoming clan system and flag mode in Astar Strike, users and NFT communities will be able to form their own clans. In this clan system, which also includes a dApp Staking mechanism for NEROX, communities will be able to create their own Staking pools. Additionally, with the new flag mode, we will offer new tournaments to users and clans.

• Clan system: Creating, joining clans etc: 3 week

• RedFlag Mode: 3 week

The game is set to receive a massive update, making it available for mobile platforms with extensive optimization. Players will now have the ability to create clans, engage in clan chats, and compete against other clans. Additionally, a new league system called “Flag Mode" will be introduced, offering exciting competitive gameplay for players.

Step 4.0 Survival of Astar & NFT marketplace🔫

June 9, 2024 → August 3, 2024

With this latest major update, Astar Strike will have a battle royale mode similar to Fortnite and PUBG. This mode will significantly elevate the game’s status in the gaming world. Additionally, with the introduction of an NFT marketplace within the game, users will be able to trade their items in-game.

• Survival of Astar Mode: 5 week

• Store Web3 connection: Tradeable weapon, skins etc. Playfab and Web3 integration: 3 week

During the 7-hour closed beta gameplay period, 568 transactions (TXS) occurred on WASM. This means an average of 81 transactions per hour. Additionally, 513 different users participated in our 7-hour process.

You can check these details from our smart contracts.

WASM:

EVM:

Moreover, with the upcoming release of the new whitepaper for the Astar Strike game tomorrow, you will see how the Astar ZkEvm infrastructure will be effectively used and how it will appeal to Web2 users with the release of our mobile app.

In conclusion: As Neurolanche, we have tried to do significant work on the WASM side. However, with Astar Network’s focus on Astar ZkEvm, we are updating our projects to be a part of this process. Our main goal under the umbrella of Dapp Labs is to make significant achievements on the ZkEvm side and reach thousands of users.

Best regards,

Leo

CEO of Neurolanche X Labs!

—————————
Note: The parts marked with stars(******) were made to avoid any futility in other projects. This text was privately shared with Sota and Maarten via DM on Telegrand yesterday and cannot be altered in any way. Furthermore, upon examination, it has been understood that the second report was shared after these fake transactions had started. We declare that we shared this report in the interest of transparency. We express that we have made no accusations against Sota and Maarten. However, it has been observed that these fake transactions began following the publication of the data in the first report. We will see this in the technical report by Ahmet Öztürk, CTO of Neurolanche X Labs.
—————————

After this writing, we addressed the problems on WASM and responded on the forum, stating that we had 16.26% of the transaction activities, in light of the attacks against us that have been ongoing for several days.

Subsequently, a meaningless fake contract was created, initiating transaction activities on WASM. We are announcing this publicly to inform everyone and to have it as a reference in case of any future issues.

We have continued to develop until today and will keep supporting the Astar Network ecosystem.

You can find details about the fake contract here;
—————————————————————————

AHMET (CTO of Neurolanche) REPORT:

#![cfg_attr(not(feature = “std”), no_std, no_main)]

#[ink::contract]
mod firepeanut {

/// Defines the storage of your contract.
/// Add new fields to the below struct in order
/// to add new static storage fields to your contract.
#[ink(storage)]
pub struct Firepeanut {
    /// Stores a single `bool` value on the storage.
    value: bool,
}

impl Firepeanut {
    /// Constructor that initializes the `bool` value to the given `init_value`.
    #[ink(constructor)]
    pub fn new(init_value: bool) -> Self {
        Self { value: init_value }
    }

    /// Constructor that initializes the `bool` value to `false`.
    ///
    /// Constructors can delegate to other constructors.
    #[ink(constructor)]
    pub fn default() -> Self {
        Self::new(Default::default())
    }

    /// A message that can be called on instantiated contracts.
    /// This one flips the value of the stored `bool` from `true`
    /// to `false` and vice versa.
    #[ink(message)]
    pub fn flip(&mut self) {
        self.value = !self.value;
    }

    /// Simply returns the current value of our `bool`.
    #[ink(message)]
    pub fn get(&self) -> bool {
        self.value
    }
}

/// Unit tests in Rust are normally defined within such a `#[cfg(test)]`
/// module and test functions are marked with a `#[test]` attribute.
/// The below code is technically just normal Rust code.
#[cfg(test)]
mod tests {
    /// Imports all the definitions from the outer scope so we can use them here.
    use super::*;

    /// We test if the default constructor does its job.
    #[ink::test]
    fn default_works() {
        let firepeanut = Firepeanut::default();
        assert_eq!(firepeanut.get(), false);
    }

    /// We test a simple use case of our contract.
    #[ink::test]
    fn it_works() {
        let mut firepeanut = Firepeanut::new(false);
        assert_eq!(firepeanut.get(), false);
        firepeanut.flip();
        assert_eq!(firepeanut.get(), true);
    }
}


/// This is how you'd write end-to-end (E2E) or integration tests for ink! contracts.
///
/// When running these you need to make sure that you:
/// - Compile the tests with the `e2e-tests` feature flag enabled (`--features e2e-tests`)
/// - Are running a Substrate node which contains `pallet-contracts` in the background
#[cfg(all(test, feature = "e2e-tests"))]
mod e2e_tests {
    /// Imports all the definitions from the outer scope so we can use them here.
    use super::*;

    /// A helper function used for calling contract messages.
    use ink_e2e::build_message;

    /// The End-to-End test `Result` type.
    type E2EResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;

    /// We test that we can upload and instantiate the contract using its default constructor.
    #[ink_e2e::test]
    async fn default_works(mut client: ink_e2e::Client<C, E>) -> E2EResult<()> {
        // Given
        let constructor = FirepeanutRef::default();

        // When
        let contract_account_id = client
            .instantiate("firepeanut", &ink_e2e::alice(), constructor, 0, None)
            .await
            .expect("instantiate failed")
            .account_id;

        // Then
        let get = build_message::<FirepeanutRef>(contract_account_id.clone())
            .call(|firepeanut| firepeanut.get());
        let get_result = client.call_dry_run(&ink_e2e::alice(), &get, 0, None).await;
        assert!(matches!(get_result.return_value(), false));

        Ok(())
    }

    /// We test that we can read and write a value from the on-chain contract contract.
    #[ink_e2e::test]
    async fn it_works(mut client: ink_e2e::Client<C, E>) -> E2EResult<()> {
        // Given
        let constructor = FirepeanutRef::new(false);
        let contract_account_id = client
            .instantiate("firepeanut", &ink_e2e::bob(), constructor, 0, None)
            .await
            .expect("instantiate failed")
            .account_id;

        let get = build_message::<FirepeanutRef>(contract_account_id.clone())
            .call(|firepeanut| firepeanut.get());
        let get_result = client.call_dry_run(&ink_e2e::bob(), &get, 0, None).await;
        assert!(matches!(get_result.return_value(), false));

        // When
        let flip = build_message::<FirepeanutRef>(contract_account_id.clone())
            .call(|firepeanut| firepeanut.flip());
        let _flip_result = client
            .call(&ink_e2e::bob(), flip, 0, None)
            .await
            .expect("flip failed");

        // Then
        let get = build_message::<FirepeanutRef>(contract_account_id.clone())
            .call(|firepeanut| firepeanut.get());
        let get_result = client.call_dry_run(&ink_e2e::bob(), &get, 0, None).await;
        assert!(matches!(get_result.return_value(), true));

        Ok(())
    }
}

}

Contract Code: Subscan | Aggregate Substrate ecological network high-precision Web3 explorer

Caller Address:

Transactions: Subscan | Aggregate Substrate ecological network high-precision Web3 explorer

The code described above delineates a simplistic WebAssembly (WASM) smart contract deployed on the Astar Network, assigned the address “ZRyBBFhACujFhbpNgW1wvGtWjMYQSai1ytDEFVxzatUjDAL”. Named “Firepeanut”, this contract offers basic functionality: it records a boolean value and enables the toggling of this value via a flip function. Although the contract appears harmless and technically straightforward, it has experienced an excessive number of repetitive calls from the same account address “WokZS6HqFxNPfaakFmsuVTKe1C64ueNmKQ8KMUFJ6JFXEhq” since approximately 1 day and 7 hours ago (2024-01-30 15:15:18 UTC), shortly after a report was published on the Astar forum (Neurolanche | 🚨 a project that is cause for alarm - #37 by Leo). This pattern of activity has led to an artificial increase in the volume of WASM transactions on the network, indicating potential malicious intent.

Further compounding this issue, the address “WokZS6HqFxNPfaakFmsuVTKe1C64ueNmKQ8KMUFJ6JFXEhq” received a transfer of 2000 ASTR to cover transaction fees from the address “WEo9Gi7T28niGb3pTwcHFDgGW4PjKDQvcS1stTxa68v73nQ”.

The timing and nature of these actions raise significant concerns, especially since they began following Neurolance X Labs’ public dissemination of transaction data related to WASM smart contracts. The likely aim of these maneuvers is to diminish the ratio of meaningful and significant transactions, particularly those associated with Neurolance X Labs, within the total transaction volume on the network. Employing such tactics not only compromises the integrity of the Astar ecosystem but also seeks to damage the reputation of organizations like Neurolance X Labs, which strive to contribute valuable applications and services.

Ahmet Öztürk - CTO of Neurolanche X Labs
———————

Conclusion: In the report prepared above, no one is accused, and no references are made to any individuals. We want to present to you our report prepared in a transparent manner. This report will definitely not be shared on our social media tools for any potential FUD. We are publishing this to ensure our own security and to declare that such situations are occurring on the Astar Network.

The report we prepared and presented on WASM may have disturbed some people. However, we will continue to work for decentralization on the Astar Network.

With love,
Leo

Hello @Leo,

I’m going to close this topic for two reasons:

  • Please keep all Neurolanche related topics in existing threads and stop creating multiple threads :
    Transparency- Txs (Neurolanche)
    Neurolanche X Labs dApp Staking apply

  • There are no “fake transactions”. When fees are paid, a transaction on a blockchain is a transaction, regardless of the transaction’s utility. Bots are part of blockchain ecosystems, and bots pay fees to create transactions, so they are still transactions at the blockchain level.
    If someone wants to “have fun” making meaningless transactions such as loops, they’re free to spend their ASTR on it, because a blockchain is permissionless.

4 Likes