Moving NFT Checks Off Chain
I had the pleasure of giving a talk at the new NFT.nyc 2019 conference. I presented a 10 minute version of a much bigger idea that my team and I have been working on for Tupelo. The technique is applicable to other chains as well (such as ERC-721 tokens, using the metadata URI).
Tupelo is a new DLT platform for digital objects and allows users to write arbitrary data to a new data structure called a ChainTree. This structure offers trust and immutability to data, but Tupelo itself isn’t a smart contract platform.
There are good use-cases for smart contracts (eg. complex financial instruments), but our premise is that the 90% of real-world projects really only need trusted data and a way to prove ownership. That being said, we wondered: “how would you build CryptoKitties?” and “how would you create a system where regulatory rules can be enforced?”
Here’s what to do:
Embed code in your ChainTrees for validity, run that code in the wallets.
For example, let’s take the issuance of stock from a SaaS company: Insaasity™ “prices so low, it’s insaasity!” Since Insaasity is a US-based entity, it has to comply with a variety of rules around who can trade its stock. In general, many blockchain companies use complex smart contract rules from accredited investor lists to off-chain API calls in order to make sure that the tokens (stock) are traded in a regulatory compliant way.
But the implementation doesn’t have to be complex. In fact, it can be simple.
For illustration, let’s say Insaasity has two rules to trading its stock:
All equity must be transacted amongst accredited investors
The company must be able to revoke and reissue shares (tokens)
Currently, these rules are handled on-chain. There’s an accredited investor allowed-list that is kept in a smart contract and there are rules baked into smart contracts that allow for the burn of tokens.
We can simplify this! One, accredited investor lists are from trusted sources to begin with so we can keep those lists off-chain (and perhaps hash them on-chain for transparency). Two, we can use an Insaasity controlled ChainTree to keep a list of revoked shares.
What really makes this awesome though: link immutable code from the share (ChainTree) itself. This can be simple, readable code because it doesn’t have to run on-chain. This allows wallets to determine if a token is valid or not and allows us to skip any complex on-chain checks. A wallet can look at a token, run the immutable code (which can take on-chain inputs) and determine “is this valid?”
What’s really powerful here is that it matches the real-world.
I can take a piece of paper and write “1 share of Apple” but that doesn’t make it a valid stock certificate. We don’t need to waste our time making sure people can’t create invalid certificates, we only need to make sure that the real tokens are easily validated.