The world’s most advanced, secure, and decentralized blockchain for NFTs.
Pastel is the first fully decentralized, purpose-built platform for the creation, validation, and trading of provably rare digital assets. By digital assets, Pastel refers to a kind of cryptographically secured, digital collectible that is created in a similar way to how a traditional artist might create a set number of limited-edition physical prints. The concept of rare digital assets is going to change the world and revolutionize how creators and collectors interact in a peer-to-peer manner - without the high fees or intermediaries that currently impede the physical world and competitive platforms.
Pastel also allows for the development of third-party applications to sit on top of the Network. Developers can build their own application or marketplace directly on Pastel, enabling them to leverage the scalable registration features, storage components, and security of the broader network.
We believe that rare digital assets are important enough of an application to merit their own, purpose-built system that is highly optimized for specific requirements. Not only does this allow the system to work far more efficiently and with greater security guarantees - because the heavy computations can be done in native machine code instead of an abstract or inefficient virtual machine such as EVM - but it also makes the system much simpler and easier to interact with.
With this in mind, we focus on what really matters in the world of NFTs:
- User-driven flow: Pastel was designed and built with its target user in mind. As such, we encourage simplicity around establishing an identity on the blockchain, registering new assets, peer-to-peer trading of collectibles from other participants, and retrieving asset files from the network.
- Multi-layer structure: Our unique structure ensures that the full functionality is provided to the entire network in a scalable, secure, and redundant manner - without the need for centralized servers or off-chain constraints.
- Built for builders: The open design is high-suitable for developers to build their own third-party applications or marketplaces directly on Pastel - without sacrificing any functionality or scalability.
Origins on Bitcoin and zk-SNARKs
When initially launching the blockchain, we selected a foundation with the longest proven track record of security, reliability, and decentralization: Bitcoin. The intrinsic data integrity of Pastel is heavily based on the Bitcoin codebase, and the project has a similar orientation towards mining-based proof-of-work and maximum decentralization.
We designed PSL to be the native cryptocurrency on the Pastel Network which can be used to transfer and store value in a similar way as Bitcoin. However, PSL also has a special use within the system: to allow participants to securely register and store their assets on the Pastel Network. In this case, PSL is essentially a version of Bitcoin as the core cryptocurrency layer, with the rare asset-related functionality built directly on top. This is done by encoding the collectible-related data into special transactions using the coin itself. The benefit of this unique design is that the data written in this way inherits all the security properties of the Bitcoin-like cryptocurrency, providing a solid foundational layer.
Rather than develop this ticket system directly on top of Bitcoin, we determined that it was beneficial to add the cryptographic innovation represented by the zk-SNARK system introduced by Zcash, which allows for provably secure “shielded” (private) transactions that can be validated by the network without disclosing the receiving address. Aside from shielded transactions, Zcash is mostly similar to the Bitcoin codebase with various tweaks, most notably using Equihash as the Proof-of-Work algorithm rather than the SHA-256 algorithm used in Bitcoin.
The company behind Zcash raised significant amounts of venture funding and was able to hire some of the brightest minds in cryptography, as well as retain several leading third-party security researchers to conduct detailed security audits. The feedback of all these audits was then integrated in the system, hardening it in a way that goes well beyond the standard of care and rigor of 99% of cryptocurrency projects. That is why we decided that the Zcash codebase (as it existed in mid-2018) was the best starting off point for the Pastel codebase.
High-Level Ticket System
Once we developed this way of abstracting files as low-level coin transactions using a Bitcoin-like system, we created a system of a higher-level series of tickets to perform all of the necessary NFT-related information on the network. We designed a system that can store such information to the blockchain using UTXOs directly in a high-performance, memory backed database. We leverage Pay-to-Fake-Multisig, or P2FMS, as the method to write data of any kind to the blockchain, as it has been optimized for the highest level of storage efficiency while using the UTXO set. We then represent the underlying information in a simple and secure format, which can be easily transmitted and subsequently signed by relevant nodes on the network.
The benefit of this system is that it provides a powerful and generic framework for encapsulating various sorts of structure and functionality. It is analogous to the difference between a high-level programming language like Python and low-level machine code.
We design various tickets to implement all required functionality. For example, we make a ticket for generating a new identity on the Pastel Network creating a PastelID, which consists of a public and private key (specifically, we use the EdDSA scheme with the Ed448 curve). This allows artists and collectors to establish a unique identity in the system, where they can sign transactions using their private key known only to them, and anyone in the network can verify that a transaction or message is authentic by checking the signature against the public key. This is critical, because in a decentralized system, anyone can try to be an imposter and put their “name” in the system as, say, Banksy. But with the PastelID system, the real Banksy could share his PastelID public key on his website or social media accounts, and everyone could then see if an artwork is a genuine Banksy, because only the real Banksy would be able to sign the artwork with a valid signature.
Once we have identity establishing tickets in place, we turn to artwork registration tickets. These are tickets that contain various textual metadata fields related to a given artwork, such as:
- The name of the user
- The PastelID public key of the creator (this is what is used by the network to securely establish the identity of users)
- The name of the NFT and the number of rare copies of the NFT that the creator wants to create
- The file hash of the corresponding file for the NFT
- A robust visual fingerprint of the file used for duplicate detection
- The creator’s digital signature that proves cryptographically that the work is authentic
There are other kinds of tickets as well, such as trade tickets for handling the trading of registered NFTs between users. For each piece of proposed new functionality, we design a ticket for that purpose, as well as a standardized protocol for validating and securing these tickets by the Supernodes and regular full nodes in the network.
To handle the requirements of running a purpose-built, digital art cryptocurrency system while preserving maximal decentralization and ensuring that the system is scalable over the long term, we leverage the concept of a Supernode. The construct for Supernodes was based on the Masternode concept pioneered by the Dash cryptocurrency project, which was introduced in January of 2014. Supernodes represent an important extension of the core ideas of the Bitcoin system and provide a large amount of additional power and flexibility. Rather than having every full network node in the Pastel system independently verify and handle all the functionality of the system, we have a class of special Supernodes which are dedicated, high-performance machines that can handle the demanding storage and computational requirements of verifying and serving digital NFT files.
Supernodes are powerful servers backed by collateral held in PSL and are designed to provide advanced services, verification, and governance on the Pastel blockchain. Anyone around the world can launch their own Supernode - all they need is a fast, internet-connected computer, a modest level of technical knowledge for set-up, and 5,000,000 PSL to serve as collateral. This structure ensures that the system remains fundamentally permissionless: the user does not need to ask anyone’s permission to run a Supernode. The network can continue to achieve the decentralization of Bitcoin, with the capability of performing more work and being much more flexible. It is also certainly more decentralized than the centralized mechanisms relied upon as a crutch on Ethereum-based NFT projects.
The other benefit of Supernodes is that they create a healthy financial alignment between the custodians of the machines that operate the network and the owners of PSL coins, which creates a virtuous cycle of incentives. Supernode operators are provided with 20% of the block reward and are also given the opportunity to vote on up to 10% of the remaining block reward to fund community initiatives to support the Pastel ecosystem. Key PSL stakeholders have a direct incentive to make sure their Supernode is operating properly and not damaging the system.
We have also designed various mechanisms to detect, prevent, and harden against attack vectors. Furthermore, the system tracks the reputation of nodes over time in a decentralized way so that nodes observed manipulating or damaging the network can be voluntarily banned or ignored.
This approach of not trusting any network nodes, but instead always requiring multiple, randomly selected nodes to do computations and compare results independently in order to reach a secure consensus, is pervasive across the Pastel project. Supernodes are constantly checking up on each other to ensure that all other Supernodes are keeping up with their obligations to perform in the network promptly and accurately. For example, Supernodes periodically challenge one another to prove that they are really storing the file chunks that they are supposed to be storing. If the challenged Supernodes is unable to respond to the challenge quickly enough, it effectively costs them reputation points in the system. If their reputation gets too low, they are penalized by the network by excluding them from participating in the Supernode block rewards for a certain number of blocks.
The goal of this is to make the system such that, in order for an attacker to disrupt the network, they would need to control a high enough percentage of all Supernodes so that they could reliably count on all of the randomly selected Supernodes for each block being under their control. If any of the selected Supernodes are “honest” then their results will disagree with the malicious nodes and the network can reject the transaction as being invalid.
Truly Distributed Storage
Nearly every NFT project completely ignores the problem of storage for the underlying NFT asset. Users incorrectly believe that NFTs are minted and exist in a decentralized manner on the blockchain. However, NFTs are really only non-fungible to the extent they refer to the actual token, not ownership of the rare asset itself. Most platforms simply outsource the storage of the actual rare asset to a third-party. In this case, the owner only really owns the non-fungible token to authenticate the file stored on a distributed protocol like IPFS or even simply the URL pointing to where the file is stored, say on Google or AWS.
Storing an NFT’s metadata and assets on a centralized server or relying on IPFS for the maintenance of files makes any creator or owner highly vulnerable to the loss of assets if the centralized entity were to shut down or if the protocol links were to go dead.
Pastel is the first NFT platform to have its own completely integrated, decentralized storage layer based on advanced technology such as RaptorQ fountain codes. Pastel ensures that the digital asset itself is uploaded, verified, and registered on the Pastel blockchain — rather than just the token with which it is minted. Through a series of smart tickets living on the Pastel ledger, artists can store their masterpieces in a distributed fashion across a variety of Supernodes as opposed to just ensuring the token is non-fungible. Our goal is to ensure that even in 100 years, the world does not lose access to a single one of the NFTs entrusted to the Pastel network.
RaptorQ for Redundant Chunk Generation
This sophisticated storage layer, leveraging the RaptorQ fountain code algorithm, begins by breaking each asset up in a series of redundant chunks. Every chunk contains certain random fragments of the combined file and is distributed redundantly across participating Supernodes running on the network.
We specify 2 parameters that control how the data is encoded into chunks. The first is the size of each chunk, which is set at 2 megabytes in order to strike a balance between both bandwidth and volume of NFT files on the system. The second key parameter is the desired redundancy factor, which determines the total size of all the chunk files initially created. Thus, if the original data is 20 megabytes, and we use a desired redundancy factor of 12, we will create 20 x 12 = 240 megabytes worth of chunks. At a 2 megabyte chunk size, we start out with 120 chunk files.
Kademlia for Random Chunk Distribution
The sets of chunks are then auto-distributed across the network to randomly selected Supernodes using the Kademlia DHT algorithm. This provides a useful “distance metric” that can be computed for any binary string of data and automatically eliminates the need for any of the unnecessary architecture - no complex or centralized system for deciding which node is responsible for which chunk, no iteration through Supernodes to find one with the relevant chunk, and no complicated logic for handling chunk re-allocation in the case of Supernodes entering and leaving the network.
Each chunk is uniquely identified by a SHA3-256 hash, just as is done with each Supernode identifier (i.e. its public key). We determine the binary representation of each hexadecimal string (both the chunk and Supernode identifier) and compute the XOR distance between the strings. The smaller the distance in this computation, the ‘closer’ the chunk is to the Supernode in the network. Supernodes are responsible for storing chunks that are ‘closest’ to them in the network. As new chunks are created and as Supernodes enter and leave the network, this set of “closest” chunks to a given Supernode changes. What’s achieved is a completely distributed, deterministic way to self-organize into a particular network topology using random outputs.
Despite the redundancy and self-balance introduced above, in that a replacement Supernode is automatically found when an old Supernode leaves the network, it is still conceivable that a particular chunk could be lost forever. Possibly, a very large and sudden drop in the number of available Supernodes - as a result of market forces or an attack on the network - could wipe out all the Supernodes hosting that chunk before new Supernodes can take them over.
However, if this event were to occur, there is a solution. Each chunk is uniquely determined by two items: the original data and a random seed for a given chunk. The random seed is generated when the chunks are first created. The set of these random seeds, together with the file hashes for each chunk, is also contained in the artwork registration ticket. If Supernodes on the network determine that a given chunk is no longer available, then the highest-ranked Supernode can retrieve enough LT chunks to reconstruct the original file and then use the random seed corresponding to the missing LT chunk to generate from scratch the identical chunk. This process can be verified easily by computing the file hash of the “new” chunk and checking that it matches the file hash listed for that chunk in the original artwork registration ticket on the blockchain.
The standard way many crypto projects characterize NFTs is by taking the hash of the file as the ID or fingerprint of the underlying image. The problem with this method is that someone can then copy the NFT, say a piece of digital art, and reupload it to the system. This would cause the hash to completely change, even though the file is identical.
What is needed is a way of robustly characterizing the intrinsic nature or content of an NFT into a numerical fingerprint— one that doesn’t change materially when the same file is uploaded or even if an image is modified and re-uploaded in superficial ways such as through cropping, altering colors or brightness, or applying various photoshop-type filters like edge detection or warping.
Pastel’s approach to near-duplicate image detection leverages Tensorflow with Keras Applications. The method finds all the ways of transforming each image into a fixed list of around 8,000 numbers. This vector of numbers is the image fingerprint, and it allows us to compare two images by comparing their fingerprints, which take up a tiny fraction of the space of the actual images. We can think of each fingerprint as representing a point in space, where space is 8,000-dimensional versus 3-dimensional. Images with similar content have fingerprints that are “close” to each other in this 8,000-dimensional space. We find suspiciously similar images by looking at both the correlations between a given image fingerprint vector and the database of all previously registered image fingerprint vectors on Pastel that align with open databases of images (e.g. Google).
In order to intelligently generate these 8,000 numbers, we leverage the combined efforts of Google, Open-AI, and numerous other researchers in the machine learning community. We take 5 trained deep convolutional neural net models that have been proven to score well in the famous Imagenet computer vision recognition and classification competition (e.g. ResNet Model). We transform all candidate images to fit the same 225 pixel by 225 pixel resolution, and each model outputs a set of probability estimates for a collection of over 10,000 categories. The category with the highest probability is the model’s ‘best guess’ as to the content of the image.
Essentially, we take the output of the second-to-last layer of each of the 5 neural net models (each of which are based on different approaches and architectures), which are basically a bunch of numbers that summarize the internal state of the model when it is stimulated by the given image. We then take these 5 differentiated output vectors and combine them into a single string which serves as the final fingerprint. The neural networks are highly sensitive to the images they are shown and have “learned” the semantic content, and thus they are effectively able to characterize the essence of the content numerically - even if various changes are made to the original image. Even if every single pixel in the original image is different from the duplicate image, the system will detect a level of similarity that would be unlikely to occur by chance.
|Unknown Rarity||NFT is signed by the artist’s PastelID private key.|
|Rare to Pastel||NFT is signed and not similar to any images already registered on Pastel.|
|Highly Rare||NFT is signed, new to Pastel, and not similar to images on Google Images and other internet sources.|
Unknown Rarity: These are certified Signed by the Artist NFTs. The Low rareness level in Pastel corresponds to the typical Ethereum-based NFT use case. Anyone can check the artist’s PastelID public key on the artist’s social media sites or personal website and use that public key to verify that the NFT is in fact signed by the corresponding private key that only the artist would know. This establishes the provenance of the image, and the particular block it is included in on the blockchain establishes the order and timing of the artwork registration. The underlying image file itself is also stored directly in the Pastel Network’s native storage layer, which is a big difference from Ethereum based projects. But, the basic idea of how the NFT is registered and validated by nodes into a block is the same.
The next two levels of rareness are at the level of the image data itself - not just the metadata of the NFT or whether that metadata is signed by the artist’s PastelID private key.
Rare to Pastel: This designation includes NFTs that are New to the Pastel Network. If an image is completely new to the system, it earns this special designation meaning that the NFT is not excessively similar to another NFT that has already been registered on the network by any user. This information would be included in the original art registration ticket, and would be indicated in various ways in the wallet interface so that users could easily understand at a glance which images are certified new to Pastel.
Highly Rare: The highest designation is certified New to the Internet. This encompasses whether or not the NFT that a user is trying to get registered has been “seen” on the internet before, or something extremely close to it. The Supernodes take the candidate image file and perform a reverse image search using google images and other free, public services such as TinyEye or DupliChecker. They then take the top results from each of these services and apply Pastel’s near-duplicate detection system on each of them. If none of these are close enough to the candidate image, the NFT earns this designation, which is included directly in the original art registration ticket. This would also be clearly conveyed to the user throughout the Pastel interface.
Candidate NFTs that satisfy the Rare to Pastel and Highly Rare standards are given the highest status or level of rareness. In this way, a user can go ahead and register a photo of the Mona Lisa, but since it would only be signed by their PastelID private key, and not Leonardo’s signature, the market might not place significant value on it. Market participants could also conclude that the Pastel NFT of a particular image that was the first one registered on the system is the “best” and most valuable. If a user is the first one to register the Mona Lisa on Pastel, then they—and only they—will qualify for the Rare to Pastel designation, and so this version might be particularly valuable.
Collectors may prefer to spend more on an NFT that is rare at the level of the pixel patterns. Other users that are insensitive to the rarity of the NFT and view it as more of a digital collectable or as a way to support their favorite creators can buy the NFTs that are signed by the artist, even if they aren’t “rare” in this stricter sense.
All candidate NFTs are scanned at the time of registration by one or more “NSFW” such as Tensorflow with the open-source model from Yahoo Research OpenNSFW. When OpenNSFW is applied to an image file, the output is a number between zero (least pornographic/NSFW) and 1.0 (most NSFW). This score is included in the original artwork registration ticket and thus directly accessible in the Pastel blockchain.
Supernode Operators can decide in their settings which images they are willing to register on the network, and which images they are willing to store file chunks for in the Pastel storage layer. For example, a very careful, cautious Supernode operator living in the United States might decide to never register or store file chunks for any image with an NSFW score of over 0.95. A Supernode operator less sensitive to local regulations may be willing to register or store chunks for all images, even if they have a very high NSFW score.
Since NSFW scores are built into the system, from a user interface standpoint, default wallet settings allow for selecting an appropriate level to ensure that the platform accounts for local regulations and is “child friendly,” while also preserving the broader permissionless aspect of the system.
In addition to financial risk and waste, high transaction fees outside the control of the project undermine one of the core reasons why NFTs are so disruptive: the power to make a rare digital asset accessible to anyone in the world on the internet without permission.
A system where only artists who can spend $500 worth of ETH to make a single artwork NFT would end up excluding most digital artists in the world. We keep the cost to register an artwork minimally below $.05 - close to the level that offsets the real-world costs of providing such service (e.g., the cost of file storage in perpetuity) - ensuring that transacting is affordable irrespective of network exhaustion or the underlying price of PSL.
We ensure low fees in Pastel with a mechanism that automatically adjusts the required registration fees based on how much the mining difficulty has increased for PSL over time. For instance, if the network hashrate were to increase by a 10x multiple because of more miners competing, then the registration cost for a particular artwork measured in PSL would only cost 1/10th as much as it cost at the original, lower network hashrate. The network hashrate correlates highly with the underlying price of PSL over time (in the case of BTC, this has been estimated at a ~90% correlation), and thus provides a highly simple, effective manner of controlling the absolute cost of fees without introducing any external dependency.
Built for Builders
We understand why the world has gravitated towards Ethereum-based digital art solutions so far— it is very quick and easy to develop on the Ethereum platform as specialized Ethereum smart contracts. This allows such a rare art platform to “piggy back” on the existing security and infrastructure of Ethereum. Perhaps more importantly, it also provides a liquid and native currency, ETH, that can be easily used to purchase and sell the artworks registered on such a platform. However, we believe that this ease of use and speed/convenience come at an extremely high price, which ultimately makes it the wrong approach.
Over time, as developers understand these shortcomings they will be more inclined to adopt the competitive approach of Pastel. The cross-platform (Windows/Mac/Linux) C++ codebase communicates via API calls with the storage layer (which is written in Golang) and with the image verification logic, which is written in Python using the Pandas and TensorFlow libraries. These services are bundled together for ease of deployment on Supernodes using Docker and Ansible scripts. In addition, there is separate wallet software that is downloaded by users (creators and collectors) and installed on their computers. This design enables seamless adoption.
This wallet software exposes a user-friendly and intuitive interface that makes it easy for users to perform various tasks, including:
- Sending and receiving PSL coins.
- Registering a network user’s identity on the network. Creators, collectors, builders, and Supernodes all use the same PastelID system to establish their identities, which are used for all art-related transactions in the Pastel Network.
- Browsing and searching for NFTs on the network (using the Supernode network as the distributed servers). This includes features such as “trending” pages.
- Registering and trading NFTs as well as displaying transaction history.
Third parties are encouraged to build on Pastel to add various optional or convenience services to the system, or to directly deploy third-party applications. The Pastel team has open sourced a series of tools, well-documented APIs, and RPC functionality to help builders get started.
A third party talent agency could maintain a site for its clients, who could then access the network through the agency’s Pastel account. Such a system would automatically perform the various, underlying NFT actions on the Pastel blockchain via direct RPC and API calls. In effect, any platform can have the system perform actions on their behalf on the Network, such as generating a PastelID for the user and registering an artwork on the Pastel blockchain - with all settlement logic abstracted from the native builder.
We designed Pastel from the ground up with our target user in mind. Users can create a PastelID, which consists of a public and private key, to develop an identity on the blockchain. More importantly, the PastelID system ensures that creators and collectors can share their PastelID key on their website or various social media accounts - abstracting away the confusing string identifiers associated with pub/priv key pairs.
From user onboarding to navigating through the marketplace and trading NFTs, every aspect of the system was carefully designed to account for intuitive user-flow and understanding.
The above demonstrates an onboarding page in which a user has the option to add PSL through a variety of methods versus relying solely on abstract wallets like Metamask. In this manner, we open our doors to an entire world of users, creators, and adopters.