How Laconic Radically Improves the NFT Experience

10.05.2022-By — Joshua Eustis
  • Product
post image

Part 1 of this two-part series discussed the five major implementation and integration issues plaguing DApp developers, along with an overview of how Laconic addresses each one:

1. NFT data lacks consistency and integrity.

2. NFT data is fragmented and scattered.

3. For both NFTs and equivalent token formats, data types vary from blockchain to blockchain.

4. NFT games require lightning-fast retrieval and scalability.

5. Data retrieved from multiple locations is difficult to verify. 

Now, in Part 2, we'll explore how these problems are playing out in the real world—and how Laconic tools and processes shield both users and developers from the effects of shifting and conflicting standards, radically reducing everyone's list of problems.   

Apes, witches ... tax fraud? The power of caching.

Let's start by looking at a current cornerstone of the industry. Arguably the most popular use case for NFT artwork is 10k PFP collections, collections of (typically 10,000) relatively simple anthropomorphized cartoon jpegs, generated by combining variations on a large but limited set of defined metadata “traits,” each of which correlates to a physical attribute of the generated character drawing. Bored Ape Yacht Club, for example, uses this model. 

In the case of another popular collection, Crypto Coven, a smart contract is called to mint tokens based on a similar list of randomly generated traits. To gather each piece of this data and display it, a wallet client or platform makes an API call to an RPC provider. To retrieve the data, the client or platform must sift through an extraordinary amount of data to find just a few essential pieces. And all that searching eventually adds up. More serious problems could also arise, from sandwich MEVs to lowball ape sales as a front for tax shenanigans.

Luckily, there's an easier (and less easily abused) option. A Laconic Watcher could cache all data related to a given smart contract—in this case, the brilliant Crypto Coven `counters.sol` variant—making it instantly available at any DApp request while preserving proof of authenticity. Because Laconic can prove metadata at the current block height, not several blocks behind like most current centralized data providers, all NFT data received is guaranteed correct. That makes for faster queries, lower costs, easier updates—a quality-of-life upgrade for developers. For a particularly busy smart contract such as Bored Ape Yacht Club, Laconic's data cache could also drastically improve the daily experience of thousands of users. And let's not forget the damage done to industry reputation by the successful exploits of every "fat-fingered" Ape owner.

Where we’re going, we don’t need standards.

Smart contracts are incredibly popular for good reason. But there are countless variations out there, even on Ethereum. In fact, entire Web2 and Web3 developer communities view this aspect of NFT technology as where its real beauty is revealed: the developer as artist, Making It New. Limit contract and metadata standards, the argument goes, and you'll hamstring developers' creativity, starving the ecosystem of innovative ideas. (Unaddressed standards are, of course, nothing new. Think back to the browser wars of Web 1.0, when entire websites ... just didn't work on Internet Explorer, and at many design shops, ensuring IE functionality would cost you a good 20% extra.)

Laconic is uniquely suited to solve the problems associated with nonstandardized token data retrieval. By caching token data into microchains of IPLD blocks, and serving it directly to DApps from the resulting decentralized content-addressable database in a unified format, the Laconic Watcher makes the entire issue moot. It displays the precise data queried, confirms that it's correct—and does so more quickly and with a more current state than any standard RPC service.

An end run around fragmented and scattered metadata.

A Laconic Watcher makes it easy for developers to retrieve blockchain data from an indexed database; fetch off-chain data as needed; and correlate, merkleize, and cache the results. With a Crypto Coven smart contract, for example, there's no need to concern yourself with both the smart contract and the media the tokenURI points to—a Watcher can tie them together in ways standard RPC providers can't, with a terrific signal-to-noise ratio, perfectly up-to-date state, and persistent uptime.

Watchers define and expose precisely crafted APIs for DApps that consume specific data sets, such as a given smart contract. Allowing a DApp itself to focus solely on its primary mission of delivering the goods to the user eliminates the need for (often surprisingly heavy) query lifts.

Smooth token data retrieval and management, even from multiple blockchains.

Non-fungible tokens exist on multiple blockchains, in varying degrees of complexity, in a range of programming languages, in line with wildly varying (if any) metadata standards. The result is, unsurprisingly, significant friction when it comes to token management. Laconic removes much of the drag by unifying and extending the possibilities of metadata once it’s been retrieved.

To maintain a unified format regardless of chain or data source, Laconic stores all blockchain data in content-addressable data formats. This allows for a level of global availability and extensibility that makes DApp development far more convenient. Our hypothetical on-chain Library of Alexandria in Part 1 is made possible by Laconic’s uniquely decentralized, content-addressable format and the Watcher's computationally light footprint. Think of this chain-agnostic view as a Rosetta Stone for Web3 data.

Laconic makes querying NFT data verifiable, fast, and affordable.

Laconic makes DApp access both faster and easier with its up-to-date, indexed, verifiable blockchain data and custom query and caching services; queries, too, become more affordable to develop and maintain. And in a time of ballooning NFT data stores and rapidly increasing demands on user experience, Laconic Watchers deliver data at a fraction of the cost of traditional data retrieval.

In short, the architecture of the Laconic Network delivers practical solutions to many of today's most pressing NFT challenges. Custom Laconic Watcher services can, for example:

  • Collect data from multiple blockchains

  • Process that data to make it consumable by DApps

  • Preserve data verifiability across transformations 

  • Keep data up to date

  • Streamline DApp data retrieval

With these capabilities, the Laconic Network becomes an indispensable data querying and verification layer for any NFT-related service—and, more than any other approach to querying blockchain data, a resource with the capacity to help the entire industry thrive.

Read more about Watchers and the Laconic Network here.

Got questions? Join us on Discord.