Jan 14
Introduction of Particle Protocol
The community, nowadays, has developed many projects and tabled plenty of EIPs relating to NFTs, including EIP721, EIP1155, EIP998, EIP1948, EIP2981, EIP3386, EIP3440, EIP3569,EIP3589, and EIP3664. It is not difficult to find that other EIPs are basically for supplementing some customized interface functions except EIP721. For example, EIP1155 and EIP998 provide batch processing capabilities; EIP1948 expands dynamic data storage capabilities under existing standards; EIP2981 increases the interface function of NFT royalties; EIP3440 adds author’s signature; EIP3569 offers an operation interface of NFT metadata sealing. These EIPs, or customized interface functions, are very fragmented. With the development of NFT, or with the development of Metaverse, there will inevitably be more EIPs for NFT. If each featured interface function tables an EIP, it may increase the cost of use for developers and users and become less comprehensible.
In fact, from a technical point of view, the purpose of adding various interface functions is to process NFTs with the EIP721 standard. From this perspective, we can consider all existing NFTs as raw materials and consider other interface functions as processing tools. These processing tools are essentially programs or scripts, and they should be diversified.
After analyzing products on the market, we realize that most NFT products are image-based and multimedia, such as music and a small animation and are relatively static and isolated. Therefore, these NFTs cannot add new elements, extend functions, synthesize and split, and of course, interact with other NFTs. This situation is like various atoms increasingly appearing in the universe, but these atoms cannot interact. They cannot combine into molecules and synthesize into objects. Thus, they are entirely isolated.
Suppose the static NFT gives people the imagination of design. In that case, creating the script can make the NFT have dynamic capabilities, and those interactive NFTs can create the NFT applet, which is the synthesis application. We believe everything can be Particle NFT. For example, the image is Particle NFT, the text is Particle NFT, the code is Particle NFT, the DeFi operation is Particle NFT, and the interface is Particle NFT. Therefore, we must make the NFT specification less fragmented and have infinitely scalable interaction capabilities through mutual synthesis. Our goal is to let NFTs become programmable so that some NFTs with black and white characters like Loot can also become colourful, thus adding a new dimension to the entire world of NFTs.
The definition of NFT, or the market’s understanding of NFT, is a static resource or asset such as an image, a piece of music, a small animation, or some rights. Developing smart contracts or external programs is needed if you want to use these static resources or assets. Therefore, we cannot distribute the NFT processing program well because they are unrelated and cannot wholly perform advanced operations such as synthesizing and disaggregating with NFT resources and processing programs. Just a bit like a variable in a programming language which variables define data types and processes that perform on types. For example, integer variables represent integer data types and define operations like addition, subtraction, multiplication, and division. Those variables are a complete whole and are indivisible; otherwise, we are unable to program.
In the EIP721 standard, there are only interface functions such as transfer and approval within smart contracts and are no processing methods for Metadata which is the core of NFT. Without Metadata, NFT can be meaningless. For example, game props NFTs need to describe level, colour, shape and even 3D object structure in Metadata; music NFTs need to describe duration, author and cover in Metadata. Therefore, our processing of NFT is essentially processing Metadata, and the smart contract only records some summary information and ownership.
The goal of Particle Protocol is to achieve the programming ability of Metadata, that is, NFT Meta- Programming. Through NFT Meta-Programming, we can process NFT resources any way we want. For example, we can flip, arrange, and stack image NFTs, synthesize music NFT with a music player NFT, aggregate DeFi operations into an NFT, and even add a UI NFT to create our unique DeFi applet.
Imagine that we need to create a singing doge NFT. At this time, we first need to prepare some raw materials, such as a doge image NFT, a piece of music NFT and a particular UI NFT. Assuming these NFTs are programmable and we can synthesize them according to the pre-defined procedure. Therefore, we can synthesize the dog image NFT with the music NFT and then synthesize it with the UI NFT. At last, we will get an NFT with a cute doge, and when we click on its belly, it begins to sing. And that is NFT Meta-Programming capability.
It is very flexible to call NFT Meta-Programming, as shown in the following figure:
After users have Meta Particle NFTs, they can write a program by calling the script in Particle NFTs they already owned. The calling process needs to pass the authentication of the owner’s private key. The script written by the user can be a purely external program, or it can be an independent Particle NFT. In this way, we can realize the distribution of works of NFT meta-programming and calling Particle is just like calling a program library. Thus, we can implement sealable, capitalized, and authentication-capable program calls.
When NFT has the ability of program interaction,, a new world will be opened. We can realize almost completely third-party server free applications, and you will see that this method is still very environmentally friendly. In the current DAPP development process, smart contracts can be directly deployed to the blockchain, which is very convenient and can enjoy the decentralization of the blockchain network. However, as an app, it is often necessary to provide a web service, which is usually deployed to AWS or other cloud servers.First of all, the deployment process is troublesome. You have to buy a server, configure the environment, upload the service program, and run the application. Second, it is hard to distribute this web service efficiently. For example, when you need to transfer the Web service to others for maintenance, You have to change the key, change the password, and sometimes even change the mobile phone number. If multiple people maintain the components, it almost requires a professional team.
Furthermore, running this web service in different environments is inefficient, which requires plenty of technical support, such as running a demonstration in an intranet or migrating to another heterogeneous network. Finally, whether the web service is temporary or permanent, and whether hundreds or thousands of people use the web service, we must design a load balancing architecture to support various maintenance tools and backups. This web service keeps running 24 hours a day which is eco-unfriendly, heavy and inefficient.
When NFT is programmable, NFT itself can be a service, for example, a Web service, or any other form of service, which can run uninterruptedly or temporarily start up and run, and be distributed to anyone needed. All we have to do is to transfer it once. Don’t forget that the NFT with service capabilities is an asset and can be traded and transferred arbitrarily in the market.
A schematic plot for NAAS (NFT As A Service):
Users can encapsulate various program services by synthesizing Particle NFTs, distributed as an independent service or a synthesis unit aggregating multiple program services. The user owns the right to use the service program and has ownership that truly owns this service program. This provides finer granularity encapsulation capability for rights distribution and collaborative design of various service programs and also convenient for users to perform peer-to-peer distribution.
Particle Protocol provides a new software component distribution method called Asset Oriented Script Distribution, referred to as AOSD. We know that every NFT is an asset, and with Particle protocol, every NFT can also carry programs. Therefore, every program held by NFT is also an asset. Through this synthetic method, we can achieve program distribution at any granularity. For example, we can distribute a player UI, a sorting algorithm program, a layer synthesis tool and, of course, complex software composed of various small programs.
This distribution process completes the transfer of ownership and right of use of a program asset. Users can claim or purchase corresponding NFTs with programs according to their needs and transfer them to each other. For instance, A can transfer one of his own Defi NFTs to B, B can transfer his own music player NFT to C, and C can continue his synthetical creation. Using this distribution method, users only need to manage assets through their private key to receive and transfer or use the Particle Protocol dedicated client to complete the asset-oriented, peer-to-peer distribution.
The NFT meta-programming capabilities implemented by Particle Protocol can release the massive productivity of the community. However, the Metaverse requires enormous content and huge participants to build, including artists, programmers, modellers, product designers, and innovators to participate in many roles to provide content together.
Take games as an example. Traditionally, a team or a company design and develop a game, and players are only the game users or experiencers. Even if in Gamefi, we can trade or transfer props in the form of NFT in the blockchain network instead of participating in constructing the game or changing the game’s elements. For example, players cannot synthesize names or logos to props unless the game itself supports it.
At the initial stage of GameFi design, props can be minted as NFT in the blockchain network, and we can trade and collateralize those NFTs through DeFi facilities. However, these are independent operations on props, and players cannot use those props back in the game after recreating them regardless of any forms of processing. For example, there is a horse prop, can a user continue using it after changing its fur colour from black to white? It is usually impossible because the horse NFT is just an image or a 3D object which is not programmable, and the game cannot recognize it after synthesizing the NFT.
Particle Protocol allows users to participate in constructing games. For example, a Loot holder can synthesize their Loot NFT with a 3D-prop-UI Particle NFT and join a game. Thus, this game is no longer designed and developed by a single fixed team but a decentralized and collaborative community. While developing a game, each user can create their script components through Particle Protocol, and multiple users can also collaborate. From music to props, from scenes to plots, each part is contributed by the user. We synthesize them piece by piece, layer by layer and finally complete a user-defined game.
In this way, we call it UGM, which is stands for User-Generated Metaverse.
Particle Protocol is a protocol specification that defines the interface standards and data formats that allow NFTs to become programmable. Particle itself complies with EIP721, which makes every Particle a standard NFT. If we want to extend the interface functions, we do not need to define a standard immediately. Instead, we can implement it by horizontally synthesizing the EIP721 standard. In Particle Protocol, we consider image, music and other NFTs as raw materials. We can generate new NFTs by processing with NFTs that carry scripts according to Particle specifications. The following figure shows the basic workflows:
As shown in the figure, after the Particle completes the processing of raw NFT and generates a synthetic NFT, the rendering engine then processes that NFT to present a rendered view with features. The rendering engine deals with the presentation layer through the rendering script in the Particle from the above chart, and it runs in a browser or a mobile App to render and display the synthesized NFT. Furthermore, the script of the rendering engine is synthesized from Particle. Moreover, Particle is divided into multiple types to deal with processing different resource types. For example, image flipping, coloring and layout; DeFi trading, lending and mining; music, short video, advertising and media. All of them provide a variety of direct- oriented raw materials NFT programmable processing. In addition, some provide configuration and service capabilities, such as commission, subscription and authorization.
Discord : https://discord.gg/AngMfsV6rS
