WE ARE REBRANDING NOW

Vist https://docs.zkcross.org to learn more our technology and how to use it.

Learn More

Effortlessly Submit Your First zkwasm Application

Working with zero-knowledge proofs (ZKPs) can be challenging, and developing applications that utilize ZKPs can be even more complex. Our team of engineers experienced these challenges firsthand while building ZKCross. To address this, we leveraged the contributions of the Rust community and integrated the Rust Playground with the ZKCross node to streamline the development of your zk applications.

Explore the ZKCross Playground, an intuitive platform that allows you to write code online, compile it into zkwasm-compatible bytecode, sign it with your private key, and upload it to the ZKCross node. From there, our node handles the remaining tasks such as proof generation, proof storage, and store tx and proof into the Data Availability.

Experience seamless zk application development with ZKCross by the link https://play.zkcross.org

First, lets guide you through how to use the playground to get your application submitted to zkwasm prover cloud.

1. Edit your Rust code in the code block. Put the logic you need to verify using zero-knowledge proofs into the function zkmain(). Put the private parameter inputs into the function zkexec().

2. Click the ‘SHOW WASM’ button to compile your code into WASM. Wait until the result appears at the bottom.

3. Click the ‘CONNECT WALLET’ button to connect your Metamask wallet. Make sure your wallet is on Ethereum Sepolia testnet.

4. Click the ‘UPLOAD WASM’ button and sign the transaction in Metamask. Then your WASM image is signed and uploaded to the ZKCross Node.

5. The ZKCross Node will automatically submit your WASM image to the zkWASM prover network. Then the setup is ready. You can see your setup appears as the latest setups in the zkWASM task explorer.

6. From now on, you can use any tools, languages to submit request to zkc node to use your wasm image, for example:

curl https://testrpc.zkcross.org/' -H ‘Accept: application/json, text/plain, */*’ -H ‘Content-Type: application/json;charset=UTF-8’ — data-raw ‘{“jsonrpc”: “2.0”, “method”: “submit-tx”, “params”: {“image_md5”: “FBE1ADD84935782493030FF335475D81”, “weight”: 100, “params”: [1,2]}}’ — compressed ;

This is a image already existing in both zkc node and DelphinusLab’s zk prover cloud. It will pass two parameters to the image on zkc node, zkc node has a wasm runtime builtin, it takes the parameters from the user, execute the code, submit it the execution combined with the parameters as private and public input to Delphinus’s zkwasm cloud.

7. After the proof generated by the zkwasm cloud, zkc node will call the batcher to process tx, submit to the settlement layer and DA.

What does the ZKCross Node do?

Provides an RPC interface for applications to interact with the prover network (such as Delphinus Lab’s zkWASM cloud).
Facilitates the execution WebAssembly bytecode on node, make it very similar to run services on server side.
Provide adaptor layers to provide components required by a rollup, like ordering transactions, batch processing proofs, data availability, proof generation, etc.

To know more about ZKCross node, we will provide a detailed documentation of our node

How to write a zkwasm compatible application with Rust?
Here is an example, this code carries two mandatory functions, which one is for zkwasm, the other is for executing the code on zkc node.

mod utils;

extern crate zkwasm_rust_sdk;
use self::zkwasm_rust_sdk::{require, wasm_input};

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub unsafe fn zkexec(a: u64, b: u64) -> u64 {
    a+b
}

#[wasm_bindgen]
pub unsafe fn zkmain() -> u64 {
    let a = wasm_input(1);
    let b = wasm_input(1);

    let c = wasm_input(0);

    require(a+b == c);

    0
}

Effortlessly Submit Your First zkwasm Application was originally published in zkcross on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introducing the zkWasm-service-helper Go SDK

Streamlining Zero-Knowledge Proof Development

In the constantly evolving landscape of blockchain and cryptography, zero-knowledge proofs (#ZKPs) have emerged as a game-changer, enabling secure and privacy-preserving transactions without revealing sensitive data. At the forefront of this revolution, the #zkWasm project from @DelphinusLab has been pushing the boundaries of #ZKP technology, providing a powerful and efficient platform for developers to build cutting-edge applications. Today, we are thrilled to announce the release of the #zkWasm

-service-helper Go SDK, a robust and user-friendly toolkit designed to simplify the integration of the zkWasm service into Go-based projects. This SDK empowers developers to harness the full potential of ZKPs, enabling them to create zero-knowledge probable applications with golang, which will widen the door for developers to bring applications beyond web browsers.

Unlocking the Power of ZKPs with Go

The zkWasm-service-helper Go SDK provides an all-encompassing interface for integrating with the zkWasm service backend and smart contracts. Its user-friendly API and design allow developers to seamlessly integrate ZKP functionality into Go applications, simplifying the task of adding and gathering information.

The SDK is built on the latest version of Go (1.20 or later), adhering to best coding practices and the idiomatic Go programming style for maximum efficiency. Its main features include:

ZkWasmServiceHelper struct: A powerful interface for communicating with the zkWasm service backend, enabling developers to add new WASM image tasks, submit proving tasks, query task details and status, and more.
Smart Contract Integration: Seamless integration with the zkWasm smart contract, allowing developers to check balances, send transactions, and leverage the full capabilities of the zkWasm ecosystem.
Utility Functions: A suite of utility functions for tasks such as signing messages with private keys, converting between different data formats, handling MD5 hashes, and more.

Accelerating ZKP Development With Go

The zkWasm-service-helper Go SDK significantly lowers the barrier to entry for developers seeking to leverage the power of ZKPs in their Go applications. By abstracting away the complexities of interacting with the zkWasm service backend and smart contracts, the SDK enables developers to focus on building innovative solutions without getting bogged down in low-level details.

Whether you’re working on decentralized finance (DeFi) applications, supply chain management systems, or any other use case requiring privacy and trust, the zkWasm-service-helper Go SDK provides the tools you need to seamlessly integrate ZKP functionality into your projects.

Getting Started

To get started with the zkWasm-service-helper Go SDK, simply import the repo

github.com/zkcrossteam/zkWasm-service-helperpackage

in your Go code:

go get -u github.com/zkcrossteam/zkWasm-service-helper

From there, you can create a new ZkWasmServiceHelper instance and start leveraging its powerful methods and utilities. For detailed usage examples, code snippets, and comprehensive documentation, please refer to the project’s README file on GitHub.

Contributing and Community

The zkWasm-service-helper project is open source and welcomes community contributions. If you encounter any issues or have suggestions for improvements, feel free to create an issue or submit a pull request. When contributing, please adhere to our coding style guidelines and ensure that your changes are thoroughly documented and tested.

Join us on this thrilling journey as we push the limits of zero-knowledge proof technology and unlock new possibilities for secure and privacy-preserving applications. Together, we can build a future where trust, transparency, and privacy are inherent in the digital world

Join our communities to stay updated on our Web3 journey!

Website: https://www.zkcross.org/

Discord: https://discord.com/invite/aJNjfRvgam

Twitter: https://twitter.com/thezkcross

Telegram: https://t.me/ZKCross

Medium: https://blog.zkcross.org/

Introducing the zkWasm-service-helper Go SDK was originally published in zkcross on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Dawn of Transparent Gaming

Fully on-chain gaming with ZKCross

The evolution of gaming has witnessed numerous incidents that underscore the frailties and flaws of centralized systems. Take, for instance, the unforgettable “Martin Fury Incident” from the famed World of Warcraft during its Wrath of the Lich King expansion. This mishap resulted in a player inadvertently receiving an overpowered item. This item had the potential to disrupt the entire game ecosystem because it gave the player the power to one-shot almost everything.

How, one might wonder, could a simple error threaten the balance of a massively multiplayer game? it’s the inevitable outcome when pivotal decisions are solely at the discretion of a centralized entity, even when actions are unintended. This serves as a crucial reminder that even in gaming, transparency, trust, and decentralization are paramount.

To Web3, or not Web3

The move towards ‘Web3 gaming’ carried the promise of a decentralized gaming future. But as with every upcoming technology, there are growing pains. One significant issue is that most proclaimed ‘Web3 games’ aren’t fully Web3. While they might use blockchain to verify transactions or store assets, the actual gaming logic — the heart and soul of the game — remains off-chain. This renders the game validation process a black box, which is neither transparent nor verifiable.

Given the meteoric rise in the popularity and value of NFTs within games, this opacity becomes even more concerning. Since these NFTs carry tangible monetary worth, they introduce financial incentives for malicious actors. If the drop rates of these NFTs are determined off-chain, there’s no way to verify their legitimacy. The potential for foul play is both real and alarming and, as demonstrated, can significantly impact the game ecosystem.

Enter ZKCross: Gaming’s Transparent Future

Addressing these concerns, ZKCross presents a solution that could revolutionize the gaming landscape: the capability to execute games fully on-chain. As proof of this groundbreaking feature, we’ve developed a showcase game, taking inspiration from the widely adored 2048 game. The solution has been presented at this year’s zk summit in Lisbon, you are welcome to checkout the presentation

https://www.youtube.com/watch?v=dLZbfTWLGNI&t=154

So, how does it work?

Our version of the 2048 game is intricately coded in C and meticulously compiled into WebAssembly. It is then seamlessly integrated with the ZKC SDK and the sophisticated Fusion Layer API. Players can run the game logic directly within their browsers via WebAssembly. Every swipe, every tile merge, and every new number spawned is not just a part of the game but also a piece of information that generates cryptographic proofs for the entire session. This approach means that everything — and we mean every single move — performed within the game is being posted on-chain via a Zero-Knowledge Proof (ZKP). This ZKP ensures that all actions are verifiable without revealing unnecessary details, a crucial element for preserving privacy while maintaining transparency. An on-chain contract, operating in real-time, verifies these proofs. Depending on the player’s performance and game outcome, this contract processes rewards or, in some cases, penalties. It’s a fusion of gaming and advanced blockchain tech, ensuring unmatched transparency and fairness.

Why Does This Matter?

Beyond the technological prowess, there’s a broader implication. Gaming is not just about pixels and leaderboards; it’s a medium that brings people together, tells stories, and often involves financial transactions. In an era where digital assets have real-world value, and players invest time, emotion, and money, the importance of fairness and verifiability cannot be overstated. By adopting a fully on-chain approach, ZKCross is setting a gold standard. Players can now be confident that their efforts, strategies, and potential rewards are processed justly. They can view, verify, and validate their entire gaming journey.

In Closing: The Future is Transparent

The Martin Fury Incident may be a relic of the past, but it’s a potent reminder of the inherent vulnerabilities of centralized systems. As we venture deeper into the realm of digital gaming and embrace NFTs and blockchain, the emphasis must shift from merely adopting new technologies to understanding their ethos.