TrueCanvas

Problem Statement/Motivation

Digital artists who create original works manually or with traditional digital tools like Adobe Illustrator or Photoshop face significant challenges in proving the authenticity of their creations. The rise of generative AI and sophisticated digital manipulation tools has made it increasingly difficult for viewers and other artists to discern whether a piece of art is genuinely original or partially generated by AI. This skepticism undermines the value and credibility of authentic digital art, making it challenging for artists to showcase their hard work and for viewers to trust the originality of the pieces they admire. Moreover, artists are concerned about privacy issues, as they may not want to disclose the intricate details of their creative process or reveal proprietary techniques that constitute their "secret sauce" in art creation.

Solution:

To tackle the challenge of proving the authenticity of original digital artworks without compromising the artist's privacy, we developed TrueCanvas. This platform allows artists to notarize their creations using zero-knowledge proofs (ZKPs), ensuring that their work is original and unaltered by AI without revealing sensitive details of their creative process.

Generating a Proof Workflow

Artist Generates Creation Logs

The artist creates their digital artwork using tools like Photoshop and exports the command logs (.psd logs) that record each creative action taken during the artwork's development.

Uploading Artwork and Requesting Proof

The artist uploads their artwork (e.g., a PNG file) along with the associated .psd logs to the TrueCanvas frontend application. They then make a request for proof generation through the application's interface.

Proof Request Processing

The frontend application sends the proof request to the backend server, which is responsible for handling the proof generation process.

Log Verification and Proof Generation

The backend server verifies the uploaded logs to ensure they meet specific criteria, such as confirming that less than 10% of the pixels are copy-pasted. If the logs pass verification, they are fed into the zero-knowledge proof generator written in Rust using RISC Zero.

Receiving Proof and Verification

The generated proof and verification details are returned to the artist. This proof attests to the authenticity and originality of the artwork without disclosing any proprietary information or revealing the artist's creative techniques.

Publishing to Blockchains

The proof and a reference to the artwork are securely stored using Walrus, a decentralized storage solution. They are then published to various blockchains, such as the Story Protocol, via smart contracts written in Solidity. This ensures that the proof is immutable and publicly accessible for verification by anyone.

Verifying Proof

Accessing the Proof

Anyone interested in verifying the authenticity of the artwork can access the verification link provided by the artist. This link might be shared in an Instagram description, on an online gallery, or through other platforms where the artwork is showcased.

Proof Verification

The verifier reads the proof directly from the blockchain and can independently verify the authenticity of the artwork on any device. This process does not require specialized software or access to the artist's private creation logs. By verifying the proof, they are assured that the artwork is original and not generated or heavily modified using AI tools.

Technology Stack

To implement TrueCanvas effectively, we integrated a comprehensive technology stack that ensures security, scalability, and a seamless user experience. Here's how the various technologies work together:

At the frontend, we utilized Next.js and React to build a responsive and intuitive application where artists can upload their artwork and request proof generation. This user-friendly interface allows artists to interact with the platform effortlessly.

The frontend communicates with a backend server developed in Go, which handles proof requests and orchestrates the interactions between different system components. Go's efficiency and concurrency support make it ideal for managing these operations reliably.

For the core logic of zero-knowledge proof generation, we employed Rust in conjunction with RISC Zero, a zero-knowledge virtual machine (zkVM). Rust provides high performance and security, which are crucial for cryptographic computations. RISC Zero enables us to create off-chain zero-knowledge proofs that verify the artist's creation process without revealing sensitive information. This ensures that the proofs are both secure and efficient.

To securely store the generated proofs and associated artwork, we used Walrus, a decentralized data availability storage solution. Walrus ensures that the data is tamper-proof and remains accessible, leveraging the benefits of decentralized storage to enhance security and reliability.

The proofs and references to the artwork are published to multiple blockchains to guarantee transparency and immutability. We wrote smart contracts in Solidity and deployed them on platforms like Polygon and Story Protocol. Polygon provides a scalable and decentralized blockchain platform, ensuring cost-effective transactions and fast confirmation times. The Story Protocol facilitates the registration of NFTs and offers a provenance system, which is essential for tracking the history and ownership of digital artworks.

To enable cross-chain interoperability, we integrated Layer Zero. This technology allows proofs to be published and verified across multiple blockchain networks, enhancing the system's flexibility and reach. It ensures that artists and verifiers can interact with the platform regardless of their preferred blockchain.

For secure authentication, we incorporated Dynamic, which provides wallet-based authentication for artists. This enables artists to securely log in and manage their proofs using their digital wallets, adding an extra layer of security and convenience.

By combining these technologies, TrueCanvas offers a cohesive system where each component plays a vital role:

The frontend provides an accessible platform for artists to interact with. The backend manages proof generation requests and system coordination. RISC Zero and Rust handle secure and efficient proof generation. Walrus ensures secure and decentralized storage of proofs and artworks. Solidity smart contracts on Polygon and Story Protocol handle blockchain interactions, providing transparency and immutability. Layer Zero enhances interoperability across different blockchain networks. Dynamic secures user authentication and session management. This integrated technology stack ensures that TrueCanvas operates smoothly, providing artists with a secure and private way to authenticate their digital artworks, and offering verifiers a reliable method to confirm authenticity.

ZK Proofs

At the heart of TrueCanvas is the use of advanced cryptographic techniques involving zero-knowledge proofs (ZKPs) to verify the authenticity of digital artworks without revealing any sensitive information about the creation process.

Canvas Representation as a Two-Dimensional Merkle Tree with Action Logs

The digital canvas is modeled as a two-dimensional Merkle tree, a cryptographic data structure that efficiently represents and verifies large datasets. Each pixel or group of pixels acts as leaves in the tree, and the root hash uniquely represents the current state of the canvas. Any modification to the canvas, such as altering pixels through an action, updates the Merkle root, serving as a secure fingerprint of the artwork at any given time.

Artists export detailed action logs from Photoshop, which record every action performed and the specific pixels modified. These logs provide the necessary data to understand how the canvas evolves with each action, forming the foundation for our proofs.

Base Proof Generation

Using RISC Zero, we generate base proofs that verify the correctness of the canvas's transition from the initial state to the updated state after each action. The function inputs for the proof generation are:

Initial Merkle Tree (Before an Action): Represents the state of the canvas before a specific action is applied. Updates from Actions: The set of pixel modifications resulting from the action. This base proof ensures that the action is legitimate and consistent with the canvas's state changes without revealing any details about the action itself.

Recursive Proofs and Merkle Root Constraints

Each base proof is transformed into a recursive proof, which encapsulates not just a single action but the entire sequence of actions up to that point. Recursive proofs are combined by aligning the Merkle root hashes:

The output Merkle root of one proof becomes the input Merkle root of the next. This chaining ensures that all transitions between canvas states are valid and verifiable, effectively proving the integrity of the entire creation process.

We employ Scalable Transparent ARguments of Knowledge (STARKs) to construct these recursive proofs. STARKs provide scalability and transparency, making the proofs efficient to generate and verify without requiring trusted setups.

Enhancing Proof Succinctness with KZG Commitments

While STARKs are powerful, the proofs they generate can be relatively large compared to other proof systems. To further reduce the size of the proofs and enhance verification efficiency, we use Kate-Zaverucha-Goldberg (KZG) polynomial commitments.

Zero-Knowledge Proof of Verification: We create a zk-SNARK (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) of the STARK proof verification using KZG commitments. This process generates a succinct zero-knowledge proof that verifies the correctness of the original STARK proof without revealing any additional information. By making a zk-proof of the verification process, we significantly compress the proof data. The combination of STARKs with KZG commitments results in highly succinct proofs that are practical for real-world applications, offering both transparency and efficiency.