We are building the world’s most advanced, secure, and decentralized blockchain project for rare digital art.
Pastel is a decentralized cryptocurrency project for the creation, validation, and trading of provably rare digital artworks. By digital artworks, we mean a kind of cryptographically secured, digital collectible that is created in a similar way to how a traditional artist might create a set of 10 limited-edition physical prints. This same basic idea is also commonly referred to as NFT (which stands for non-fungible token), although most existing implementations as of 2021 are built as particular kinds of smart-contracts on the Ethereum blockchain.
We think the idea of rare digital artwork is going to change the world and revolutionize how art is created and consumed, allowing artists and collectors to connect directly without paying huge fees to gate-keeping intermediaries such as auction houses like Sotheby’s and famous art dealers. The thing is, we believe that Ethereum is fundamentally the wrong technology to build on, and that there is a much better way based on Bitcoin.
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 because it allows artworks to be represented 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. Basically, Ethereum allows you to get off the ground quickly with something that “works” in a minimal way for the application of rare digital artwork. **But we believe that this ease of use and speed/convenience come at an extremely high price, which ultimately makes it the wrong approach. Consider the following, which lists just a few of the biggest shortcomings of the Ethereum-based rare art projects:
Being built on top of Ethereum, rare digital art projects such as SuperRare, Makersplace, and KnownOrigin must react to changes in Ethereum which they have no control over, such as the contemplated change to Proof-of-Stake instead of the Proof-of-Work mining used currently by Ethereum. They are basically going along for the ride, kind of like a barnacle on a ship. And there are tons of useful features that you might want to add that would improve the performance or usability of the system, but there is no way to add these in a decentralized way using Ethereum because the transaction fees make it so expensive to do anything.
Ethereum’s power comes from its generality; it is basically a cloud computer that can compute any program if you can pay for the transaction costs. This generality comes at the cost of efficiency. Except for handling short, simple programs (such as creating or transferring an artwork NFT), Ethereum is far too expensive for most computing tasks compared to even a very slow dedicated machine. To compensate for this, these Ethereum based art projects end up introducing various forms of centralization. For example, they might have a regular website where users can register an account (using, say, their email address and password), where metadata about the various artworks and transactions can be presented to users in an appealing way. And they might have editorial control over which artists they promote on a “trending” or “hot” section of the site. That might be accessible, but it’s not decentralized— what happens if someone stops paying the hosting bill for the website, perhaps 10 years from now? Or what if the operator of the centralized site decides to ban an artist for some reason?
We don’t require complete generality like Ethereum offers for the specific use-case of rare digital art on the blockchain. We instead need a small number of critical services that are specific to the application, such as detecting near-duplicate images in a robust way so these can be prevented from being registered as new artworks, or for providing storage of the image files natively in the system. In fact, Ethereum based NFTs don’t actually store the art images in the blockchain, which would be prohibitively expensive and wouldn’t scale; instead, the NFT smart contract simply contains one or more links to external resources, such as Google Cloud or Amazon Web Services URLs that point to the image files. So, what exactly do you “get” as the buyer of that artwork? In Pastel, if you are the owner of a particular artwork in the system, that gives you the right to request the full resolution image from the network, something not available to people who don’t own the artwork. The problem again here is that there is an external dependency, so the system can no longer make any promises to users about the image files staying available over the longer term. People can stop paying the hosting bills, or Google could remove the file for other reasons, such as a copyright lawsuit or a government request. Suppose an artist has made an artwork that is critical of a repressive government; shouldn’t a decentralized system be censorship resistant for this reason? Just as no government representative of any country can “call up” somewhere to have a Bitcoin transaction reversed, artwork on the blockchain should be free of any central points of control.
The external file storage issue of Ethereum art projects is not just a theoretical risk. Articles on the web from just 10 or 15 years ago are already riddled with broken links. We still have artworks in good condition that were created 600 years ago (in some cases, 2,000 years ago). We should insist on a similar level of permanence and reliability for rare digital artwork. To do this, it must be decentralized, so that if you own artwork in the system, even if everyone else gives up on the project and moves on to other things, you can run the machines yourself to ensure that the artwork is always available and can be traded with others (assuming you can find someone to trade with).
Similarly, the lack of control over the Ethereum platform is not a theoretical risk. Although the Ethereum network has always been fairly expensive in terms of the cost to execute a simple machine instruction, during periods of high market volatility and excitement when the price of ETH is moving higher, transaction fees on the Ethereum network become so high that it makes the fixed overhead cost of doing anything in the system in a reasonable timeframe almost impossible for all but the most high-value transactions. What this means in practice is that, in February of 2021, artists creating NFTs on Ethereum must spend hundreds of dollars worth of ETH just to “mint” the artworks. But if the artwork sells for less than that amount, the artist can actually lose money on the transaction. This creates a significant financial risk to the artist, and the worst part is that it’s totally artificial and caused by the limitations of Ethereum and the fact that it’s not really built for this specific purpose. The hundreds of dollars of fees doesn’t benefit the system in any way—it’s just wasted overhead. Wouldn’t it be better if most of the money spent by the art collector could go directly to the artist? To see the contrast to Pastel, see how the Ethereum-based Makersplace project talks about transaction fees:
The Ethereum blockchain is considered a world computer, operated by many computers worldwide. Interacting with it incurs a fee called gas. When the demand for the Ethereum blockchain increases, the gas cost also increases. Since Makersplace is currently paying all of these fees, when the cost gets too high, we wait until the network becomes less busy. We ask you to be patient during this time. In most cases the transaction will process within 24 hours.
Why are we talking about a 24-hour settlement period for digital artworks in a world where we have ubiquitous 5G smartphones that can transfer 10 megabytes per second? You should be able to send someone a digital artwork faster than it takes to send a messenger to deliver a physical artwork to someone across town!
Besides creating financial risk and waste, high transaction fees that are outside the control of the project also undermine one of the core reasons why rare digital artwork is potentially so disruptive: the power to make art accessible to anyone on the internet without permission, even if they don’t know anyone in the art world or they are from a poor country. 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 believe the cost to register an artwork should be closer to $0.50, or at least close to the level that offsets the real-world costs of providing that service (e.g., the cost of file storage in perpetuity), and should be kept at an affordable level even if the price of PSL increases significantly. 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. Since the network hashrate correlates highly with the price of the cryptocurrency over time (in the case of BTC, this has been estimated at a ~90% correlation), this provides a good way of controlling the absolute cost of fees without introducing any external dependency.
To us, external dependencies of any kind are a big problem in a decentralized system, since they make it much harder to evaluate the security characteristics of the system and they introduce risks that cannot be effectively controlled. They make things quick and easy but brittle and centralized. For example, to control the affordability of registration fees in the Pastel Network, we could easily integrate a price feed from one or more exchanges directly into the wallet software that would tell us the average PSL to BTC exchange rate or the price of PSL in US Dollars. Then it would just be a simple division calculation to adjust the fees. The problem is that the feed is outside of the control of the Pastel network. Suppose the price data feed is coming from the bitcoin.com exchange website. If an attacker can hack the bitcoin.com server or perform a man-in-the-middle attack to supply incorrect data to the system, how can we safely rely on that? Instead, we try to find other solutions that only look inwardly to things that nodes can fully observe on the Pastel Network, such as the number of blocks mined per day.
We believe that rare digital art is important enough of an application to merit its own, purpose-built crypto system that is highly optimized for the specific requirements of visual artwork. Not only will 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 and super-inefficient Ethereum virtual machine—but it also makes the system much simpler and easier to reason about. The history of Ethereum is littered with people who shot themselves in the foot because it is so easy to make mistakes in the Ethereum smart-contract programming language, usually a result of the extreme flexibility and abstraction of Ethereum. Why introduce open-ended complexity for a rare digital art project when you only really need a few common workflows, such as:
Instead, we decided to build on the best possible foundation, which has the longest proven track record of security, reliability, and decentralization: Bitcoin. The design 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. The most basic part of Pastel is its native currency, called PSL.
In addition to being based on the Bitcoin code, PSL is similar to Bitcoin in other ways: instead of 21 million maximum Bitcoins, Pastel has 21 billion maximum PSL (we increased the number because we wanted artworks to sell for, say, 5,000 PSL instead of 0.000023 PSL). Bitcoin also targets a new block to be mined every 10 minutes, whereas Pastel has opted for a 2.5 minutes block time. And instead of using the SHA-256 mining algorithm, Pastel uses the well-tested Equihash algorithm that is used by Zcash and which has cheaply available ASIC mining hardware.
The coin-creation (emission) schedule for PSL is also similar to BTC, except we are starting out with around half of the coins already created. This is because Pastel is a fork of the Animecoin (ANI) cryptocurrency that was announced in 2018. Animecoin was a fairly-mined and widely distributed Bitcoin clone project, originally intended to serve the anime fan community, and was introduced way back in 2014, making it older than nearly all crypto projects today. It was mostly installed by gamers and anime fans who were also into Bitcoin, and had many hundreds if not thousands of users at one point. As shown in the bitcointalk.org link, ANI is based on Bitcoin with a different hash algorithm and faster block time, and most importantly, had zero pre-mine and was widely distributed in a totally decentralized way.
Various owners of ANI coins came together in 2018 to add art functionality to this coin, but we ultimately realized that restricting the project to the anime community was too limiting. As a result, we restyled the project as a more general rare art project under the Pastel name, and later conducted the fork transaction. In the fork, existing ANI balances were transformed into corresponding PSL balances. The forked PSL coins then inherit the intrinsic fairness in the distribution of PSL.
In addition to forking the ANI coins, we also forked the codebase. The software infrastructure of the existing Animecoin network was based on a very outdated version of Bitcoin from 2014, so we decided to start from scratch, building on top of the Zcash codebase (which is itself built on the Bitcoin codebase). The existing ~11 billion PSL coins today correspond to the ANI coins that participated in the fork. Importantly, the majority of these existing PSL are locked up by long-term contractual agreements and are not available for sale. They are owned by long-term oriented private individuals who believe in the vision of the project. The fork mechanism is a long-recognized tradition at this point in the cryptocurrency world, and a convincing argument can be made that it preserves the essential fairness and decentralized nature of an ideal cryptocurrency and is fundamentally different than a “pre-mine” where there is an unfair distribution of coins from inception.
Owners of ANI coins have collectively invested hundreds of BTC into the project in the form of acquiring the original ANI coins. Furthermore, various ANI owners have contributed to the development efforts and costs more than 50 BTC over the last 3.5 years, including the commisioning of nearly $100,000 worth of digital artwork for the project (for examples, see here and all the various other costs that go along with releasing a complex project like Pastel.
In addition to PSL serving as the native cryptocurrency in the Pastel Network, which allows them to be used to transfer and store value in a similar way as Bitcoin, the PSL coins also have a special use within the Pastel system, which is of course the whole point of the project: PSL can be used by artists to pay for securely registering and storing their artwork on the Pastel Network. PSL can also be used by collectors to purchase rare artworks created by others. We wanted to make PSL basically a version of Bitcoin as the core crypto-currency layer, and then implement all the art-related functionality on top of that Bitcoin code base. By this we mean that we literally encode the art-related data into special transactions using the coin itself. The benefit of this creative work-around is that the data written in this way inherits all the security properties of the Bitcoin-like cryptocurrency itself, providing a rock-solid foundational layer.
Once we have this way of abstracting ticket files as low-level coin transactions using a Bitcoin-like system, it frees us to think at this higher level of tickets instead of their actual implementation as coin transactions. It is analogous to the difference between a high-level programming language like Python and low-level machine code. It’s much faster and more efficient to program in a high-level language that takes care of all the low-level details for you.
Using the ticket concept, we can design various tickets that implement the required functionality. For example, there we can make a ticket for generating a new identity on the Pastel Network. This creates what we call 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:
There are other kinds of tickets as well, such as trade tickets for handling the trading of registered artworks 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 Masternodes and regular full nodes in the network.
Rather than build this ticket system directly on top of Bitcoin, we decided that it was worth it to add in the incredible cryptographic innovation represented by the Z-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.
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 used the concept of a Masternode as pioneered by the Dash cryptocurrency project, which was introduced in January of 2014. Although not as commonly found in newer cryptocurrency projects, Masternodes represent an important extension of the core ideas of the Bitcoin system and provide a large amount of additional power and flexibility at the expense of some additional centralization (and a moderate weakening of the proof-of-work security) as compared to the classic Bitcoin system. Essentially, instead of having every full network node in the Pastel system independently verify and handle all the functionality of the system (as is done with Bitcoin full nodes), we have a class of special nodes called Masternodes which are dedicated, high-performance machines that can handle the demanding storage and computational requirements of verifying and serving digital art files.
Aside from a fast, internet-connected computer and the modest level of technical knowledge needed to set it up, the only requirement to create a Masternode on the Pastel network is that you must own 5 million PSL coins. That’s what makes the system still fundamentally decentralized: you don’t need to ask anyone’s permission to run a Masternode— all you need to do is purchase or mine enough PSL and you can do it on your own. It’s not quite as decentralized as Bitcoin, where anyone can operate a full node without having any investment in the coin itself, but the network is also capable of doing a lot more work and is much more flexible. And it’s certainly more decentralized than the centralized mechanisms relied upon as a crutch in Ethereum based art projects.
The other benefit of Masternodes is that they create a healthy financial alignment between the owners of the machines that operate the network and the owners of PSL coins, which creates a virtuous cycle of incentives. If you have a big stake in the Pastel project (i.e., you own a lot of PSL coins) and you want it to be successful, then you have an incentive to make sure your Masternode is operating properly and not damaging the system. There are clearly attack vectors where a malicious Masternode can attempt to undermine the system, but we have designed various mechanisms to detect and prevent that from happening, as well as to track the reputation of nodes over time a decentralized way so that nodes which are observed manipulating or damaging the network can be voluntarily banned or ignored.
The basic organization of the Pastel code base is that it is a merger of Dash and Zcash; essentially, we ported over all the well-tested, proven Masternode logic from Dash into the Zcash codebase, which was extensively and professionally audited. We then built upon this base to implement various components in C++ that are basic to Pastel, such as the creation and processing of the various ticket files that control operations on the network, such as trade tickets and art registration tickets.
This 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. All these services are bundled together for ease of deployment on Masternodes using Docker and Ansible scripts. In addition, there is separate wallet software that is downloaded by users (artists and collectors) and installed on their computers. It is essentially a web application but appears as a standalone “Electron” application, which works by bundling a dedicated version of the chrome browser.
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 in various addresses in a familiar wallet interface.
Registering a user’s identity on the network. Artist, collectors, investors, and Masternodes 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 through the network in a decentralized way (using the Masternode network as the distributed servers) all the available artworks. This will include features such as a “trending” page based on recent network activity. These might show the most popular artists over the last 1,000 blocks, or the artworks with the largest changes in price in the last 100 blocks (we can’t use regular “clock time” because this a big external dependency, so instead everything is done in terms of blocks, which roughly correspond to a period of 2.5 minutes over time.
Displaying all the artworks available for sale from a specific artist or other user.
Registering new artworks on the system.
Trading artworks (for PSL) with other users of the system. We are looking into ways that we can possibly integrate some kind of stable-coin such as the Gemini dollar, where users can create agreement tickets with particular Masternodes where they agree to exchange a certain amount of the stable coin for PSL or for certain Pastel artworks. If we can find a purely voluntary/optional way of implementing this that is still relatively secure (for example, with a reputation tracking system that harshly penalizes dishonest Masternodes that “scam” users by taking the stablecoin and not delivering the agreed upon PSL or Pastel Artworks).
Other pieces of software infrastructure that are already in place include a web-based blockchain explorer as well as a mining pool.
Third parties are encouraged to build upon this initial infrastructure to add various optional or convenience services to the system. For example, if someone wants to make a centralized website with usernames and passwords as a frontend to Pastel (say, to make Pastel more accessible to less technical users), they could simply a hook up to the same API endpoints as the local wallet software uses and thus provide access on behalf their own users. For example, an art dealer could maintain a site for artists, who could then access the network through the dealer’s Pastel account— perhaps without the artist even realizing, since this would be happening on the back-end, and the artist would be presented with a web front-end that hides all the details from them. This sort of system is clearly less decentralized than if everyone were to run the node software locally and sync up with the blockchain, and thus represents a clear compromise. But since this would be optional and not an intrinsic or required part of the system, if it stops working for whatever reason, the damage would be isolated to the users of that centralized service, and Pastel would continue working without issue.
Going further, a third-party exchange service could be set up by anyone that would allow for faster-paced, stock-market like price action, at the expense of being totally centralized. In addition, we hope to see the issuance of a wrapped PSL coin so that PSL can be traded on decentralized Ethereum exchanges such as Uniswap as an additional source of market liquidity. Our policy of having no external dependencies means that Pastel won’t formally interact directly with other blockchain projects. However, we have no issue with including optional features that provide users with additional functionality.
For example, to supplement the native Pastel storage layer with extra protection and redundancy, it would be nice if users could easily sync up their art image files along with the relevant blockchain tickets with popular cloud services such as Dropbox. Another alternative is to offer a service such as Arweave, which provides “permanent storage forever”. This would require that the user purchase the required tokens to pay for Arweave, but it would be separate from the rest of the wallet software, so if Arweave ever stopped working for whatever reason, it won’t impact Pastel.
So why would anyone want to go through the trouble of running a Masternode? You have to lock-up your PSL (which prevents you from using them or selling them on an exchange) and pay the hosting fees for a relatively high-performance cloud computer (at a cost of at least $40/month in 2021 on a service such as Vultr or Linode). The answer, of course, is that you get paid to run a Masternode: the network itself pays you, which is implemented as a share of the mining block reward which is automatically sent out to certain Masternodes in a provably fair, decentralized way.
That is, instead of the miners getting all the mined coins as is done in Bitcoin and Ethereum, some of these coins are given to the Masternodes as a group to compensate them for a) running the network infrastructure, and b) for their commitment to keeping their coins locked-up as collateral for the Masternode and thus not available for sale on the market. This is implemented by a fixed amount of the mining rewards set aside by the network for the Masternodes, which is effectively divided by the number of Masternodes. Thus the implied “interest rate” earned by a Masternode (e.g., the number of PSL coins it generates per day as a % of the 5 million PSL required to create the Masternode) depends on how many of them are active on the network at any given moment, which means that the returns are higher when there are fewer active Masternodes.
In addition to this share of the mining block rewards, Masternodes in Pastel can also earn additional PSL as compensation for providing various services to users of the system. For example, Masternodes are automatically assigned in cleverly selected groups to act as agents on behalf of artists who want to register new Artworks on the Pastel Network. In return for handling this process (we will see below that it is a fairly involved process to validate new artworks), the selected Masternodes are paid a registration fee by the artist, which is dynamically determined based on the size of the art image file and the length of the corresponding metadata ticket as well as other factors such as the network hashrate to maintain affordability over time.
If the owner of a rare digital artwork on Pastel wants to sell that artwork to another collector (or back to the artist, or to anyone else), this cannot be done directly between users. This is different from transactions in PSL coin itself, which anyone with a wallet can send to any address directly just by submitting the transaction to the network. In the case of artwork trades, the buyer and the seller are each assigned a group of randomly selected Masternodes to act as their agents or “brokers” in the trade, and in return for doing this, the selected Masternodes receive a commission in PSL coins that is a small percentage of the selling price (on the order of 2% or less, or similar to what companies like Paypal and Stripe charge as processing fees). This is a far cry from the 20% or more that is routinely charged by art dealers and galleries to handle a resale of an artwork.
Art trades in Pastel work as follows:
First, the assigned Masternodes collectively verify the proposed trade, which they do by separately tracing the ownership of the relevant artwork through the Pastel blockchain history (e.g., starting from the original artwork registration ticket created by the artist and going through all the different trade tickets from previous buyers and sellers of that particular copy of the artwork) to validate that the seller really does own the required copies of the particular artwork they are attempting to sell, and that the buyer has already pledged the required number of PSL coins to pay for the copies of that artwork at the seller’s specified price (plus the commissions fees paid to the Masternodes acting as brokers to the trade.)
Once that is done, the assigned Masternodes prepare a trade ticket that describes the various the details of the art trade (e.g., the price and quantity, the PastelIDs of the buyer and seller, the PastelID of the artist, the hash of the particular rare artwork in the blockchain, etc.)
If this ticket looks correct to all the assigned Masternodes and the buyer and seller, then the ticker is digitally signed by all parties involved and the signed ticket is written by one of the Masternodes to the blockchain as a trade ticket.
This approach of not trusting any network nodes, but instead always requiring multiple, randomly selected nodes to independently do computations and compare results so that a secure consensus can be reached, is pervasive across the Pastel project. Masternodes are constantly checking up on each other to ensure that all Masternodes are keeping up with their obligations to perform in the network promptly and accurately. For example, Masternodes periodically challenge one another to prove that they are really storing the file chunks that they are supposed to be storing. If the challenged Masternode is unable to respond to the challenge quickly enough, it effectively costs them “karma” or reputation points in the system. If their karma gets too low, they are penalized by the network by excluding them from participating in the Masternode 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 Masternodes so that they could reliably count on all of the randomly selected Masternodes for each block being under their control. If any of the selected Masternodes are “honest” then their results will disagree with the malicious nodes and the network can reject the transaction as being invalid.
Back in 2018, we identified robust near-duplicate image detection as a critical requirement of any good blockchain art solution. We are the only decentralized project to even attempt to solve this difficult problem through purely algorithmic, objective means. The reason we think this is so important is that we think rareness should not just be at the level of hashes and signatures. If the same image can be called different names by different artists and registered on the same system, it creates doubt and confusion. Which is the “real” image? Even if you can verify this by using the real artist’s digital signature (a huge advantage), the existence of the other duplicate image effectively “cheapens” the value of the real one and creates risk that naive newer users of Pastel will be tricked into buying fakes.
Other crypto art project either don’t admit that this is even an issue, or instead rely on centralized procedures and entities in their attempt to manage this. For example, a project called Artory allows you to submit your digital artwork that you purchased anywhere (say, from the Sotheby’s auction house) and they will connect you with an “independent expert” who will verify that the art is genuine and that you can prove that you own it and its provenance. Once the expert signs off on the artwork, it is then registered on a blockchain, and can be traded with others. Obviously, such a system is absurdly centralized, and it’s almost laughable to describe it as a true blockchain project. In other crypto art projects, the issue is side-stepped entirely by ignoring the image itself and putting all of the emphasis on the signatures.
Not only does this signature-only approach increase the chance of users being misled and confused, but it also means that artists can undermine the rareness of their artwork themselves. Suppose an artist registers an artwork on Pastel and creates 10 limited edition “digital prints” in the artwork registration ticket. If that artwork later becomes famous and coveted, the price in PSL for those 10 copies could skyrocket. But if all that makes a rare digital artwork “authentic” is that it is signed with the correct digital signature, what is to stop that artist from making a new series of the same image (or just superficially modified to change the file hash that the signature is applied to) with 1,000 copies? This would flood the market with very similar “artworks”. Even if collectors could see that it was part of a later series (since it would be registered in a later block in the blockchain), it would still depress the value of the original series. Thus, by preventing near-duplicates, Pastel protects art collectors from greedy artists in addition to general counterfeits submitted by other malicious users.
Other crypto art projects make a big point of integrating some means of filing and mediating copyright disputes. It’s a natural question: what happens if someone takes a copyrighted image, like a classic picture of Bart Simpson, and tries to register that on the network? If the person gets there faster than the true owner of the legal copyright (in this case, Disney), what should happen? Tradition tells us that Disney should be able to request and force the removal of the copyrighted content. We believe that there is no way to bridge the divide between the real world and the blockchain world without dramatically undermining the decentralization and security of the system. Once you get lawyers and judges involved, and judgements are given, some person or entity has to be in a position to execute those judgements, and thus they are a single point of control.
Instead, we take a combination approach in Pastel: on the one hand we follow a “Wild West” mentality, which is that this is a digital art “landgrab”, and if you have digital artwork that you might want to register, then you should do that as soon as possible to “stake your visual claim” and prevent others from “cyber-squatting” with your images. This also creates a sense of excitement and urgency in the project, where there is a reason to get moving on the platform.
On the other hand, we want to avoid gross abuses, particularly if this can be done in an optional/voluntary basis by Masternodes. Our idea for this is to allow a user with a PastelID to register a special kind of “petition” ticket where the user requests a review of a particular artwork registered on the system. In the ticket, the user can include a textual narrative making their case. For example, they can tell link in the ticket to their social media accounts, which might contain some form of proof that they are the rightful “owner” of that image.
The petition ticket could then be reviewed by Masternode operators, who would be under no obligation to review or vote on anything. But if enough Masternodes could be convinced to review the case and vote in favor of the petitioner, then a new ticket can be written to the blockchain essentially canceling the original registration and transferring it to the petitioner. It’s a fine line to walk so that this doesn’t lead to censorship or abuse; the number of required Masternodes voting on it has to be high enough to make it hard for a malicious user to game the system, perhaps in a conspiracy with a malicious Masternode.
The reason the problem is so difficult is because most ways of characterizing an image are brittle. The typical way things like this are done in crypto projects is to take the SHA-256 hash of the file and use that as the ID or fingerprint of the image. The problem with doing it this way is that someone could take the image and edit it in photoshop and change just the lower left pixel very slightly and then save the file, and this would cause the SHA-256 hash to completely change, even though to the human eye the image is identical. What we really need is a way of robustly characterizing the intrinsic nature or content of an image into a numerical fingerprint— one that doesn’t change too much when the image is modified in superficial ways. For example, we should be able to spot it if someone takes an image that has already been registered on Pastel and then tries to re-submit the image after doing any of the following modifications:
When that happens, the Masternodes selected to handle that artwork registration will refuse to sign the registration ticket, and the artist who submitted the registration request will be notified that their artwork is too similar to an existing registered image, losing the PSL deposit that the artist sent to the Masternodes to start the process. This fee/penalty is necessary to prevent denial of service attacks, where users submit a flood of “spam” images to congest the system. If every registration attempt costs a real amount of money, people will use them more carefully.
Our approach to near-duplicate image detection in Pastel is basically to find a way to transform 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, but where space is 8,000-dimensional instead of 3-dimensional. Ideally, our fingerprinting system would make it so that images with similar content would have fingerprints that are “close” to each other in this 8,000-dimensional space. Then we can find suspiciously similar images by looking at the correlations between a given image fingerprint vector and the database of all the previously registered image fingerprint vectors.
The hard part of course is generating these 8,000 numbers intelligently. Luckily, we can rely on 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/classification competition (for example, the ResNet Model). Each model takes a low-resolution color image of a fixed resolution (to apply this generally, we need to transform all the candidate images so they fit in the same 225 pixel by 225 pixel resolution), and outputs a set of probability estimates for a collection of over 10,000 categories of images (e.g., dogs, airplanes, etc.). The category with the highest probability is the model’s best guess as to the content of the image it is seeing. 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. One way to think of this process is that each of the 5 neural net models is like a brain, and we can imagine that we are projecting the image into the eyes of each brain and then monitoring the electrical activity of various parts of the brain while it “sees” the image and processes it; the vector of numbers corresponds in the analogy to the set of brain activty measurements.
We then take these 5 differnt output vectors and combined them into a single very long vector which serves as the final fingerprint. Because the neural networks are so sensitive to the images they are shown and have “learned to understand” the semantic content, they are effectively able to characterize the essence of the content numerically, even if various changes are made to the original image. This is what gives the system the ability to have “X-ray vision” and see through superficial modifications. 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.