storage int;
parameter (int %compute);
code { UNPAIR;
       PUSH int 3;
       MUL;
       SWAP;
       PUSH int 2;
       MUL;
       SUB;
       NIL operation;
       PAIR };

Properties to keep in mind​

As a resident of a decentralized blockchain, a smart contract has some unique properties:

• Eternal: it stays available forever!
  as long as enough people keep maintaining the blockchain.

• Immutable: no-one can ever change its code
  but the effect of the code depends on the data in its storage, which may change.

• Decentralized: its existence and availability don’t depend on any third party
  but it can use data provided by third parties.

• Public: anyone can read it, call it, and access its data,
  but it may contain encrypted data, and restrict access to its features.

A single NFT smart contract​

You may have heard about NFTs: Non-Fungible Tokens. An NFT can be summarized as a digital asset that is uniquely identifiable, contains some information (metadata), has an owner, and can be transferred.

Digital information such as text, images, or music can usually be duplicated at virtually no cost, with no way of distinguishing the “original” version from mere copies. A blockchain such as Tezos provides a way to create a digital asset that stays unique: the data itself may be copied, but a unique, unambiguous owner is digitally attached to it and has full control over what happens to it. Note that the ownership of an NFT of a digital asset such as an image doesn’t usually imply ownership of the image itself and associated rights.

One of the key features of Tezos that makes it very suitable for NFTs, is the on-chain governance that doesn’t rely on forks. Indeed, consider what happens to the uniqueness of an NFT if the blockchain that hosts it was to fork. On Tezos, there is always an unambiguous way to identify which is the official blockchain, and therefore which is the true NFT.

Many artists, game producers, or brands select Tezos for their NFTs, from Ubisoft with the Quartz project using Tezos NFTs to represent in-game collectibles, to RedBull Racing which proposes F1-themed collectibles for their fans. A number of marketplaces like Objkt, Hic et Nunc, and Rarible allow people to find, buy or sell NFTs.

Question: based on what you have learned so far about what a smart contract is, take some time to think about how you would build a simple one to create your own NFT.

Looking at our summary above, an NFT will need three pieces of information:

• a unique identifier
  we can use the identifier of our smart contract itself: its address.

• some metadata
  we can simply put a string in its storage.

• an owner
  we will put the address of an account in the storage.

We could deploy a smart contract that just has storage with two values: the metadata and an owner. But we wouldn’t be able to transfer it.

For this, we will need to add some code: a transfer entry point, that does two things:

• Verify that the current owner is the one requesting the transfer

• Replace the owner in the store with a new address.

Within a smart contract, we simply have access to the address of the author of the call, the caller or sender, with the guarantee that all verifications have already been done. For the transfer of our NFT, we simply need to include in our entry point, a single line of code that checks that this sender is the current owner of the NFT.

Here is the corresponding implementation in the SmartPy language:

import smartpy as sp

class Account(sp.Contract):
    def __init__(self, firstOwner, metadata):
        self.init(owner = firstOwner, metadata = metadata)

    @sp.entry_point
    def transfer(self, newOwner):
        sp.verify(sp.sender == self.data.owner, "Not the owner")
        self.data.owner = newOwner

In SmartPy, we generate a smart contract with a class that inherits from sp.Contract. Here, its constructor __init__ takes two parameters:

• the address of the initial owner of our NFT

• the content of the metadata.

self.init is then called, to put these two values in the initial storage of the contract.

In the transfer entry point, we can see how self.data.owner is used both to read and write the value of the owner to and from the storage.

Trust without a third party​

A very powerful benefit of blockchains, and of smart contracts in particular, is that they provide a mechanism to bring guaranteed trust into a transaction, replacing the need for involved parties to trust each other, and the need for introducing a third party.

This is done by making the exchange atomic: either the two steps of our transaction succeed, or neither of them happens.

This takes advantage of the property we presented earlier, that any error in the execution of a smart contract, causes everything previously done during this execution to be canceled as if it had never happened.

The previous version of our smart contract already included the transfer of the NFT, assuming that the payment was done off-chain or through a separate transaction. To ensure the atomicity of the exchange, we need the same entry point to manage both the transfer of the item and the transfer of tez.

Four new features of Tezos are needed:

• We need a new data type, tez, to represent the price.

• We need the buyer to send some tez. On Tezos, a call to a contract is a special type of transaction, and you always send a number of tez (potentially 0) to a contract, when you call its entry point. That amount is automatically added to the balance of the contract.

• We need to check that the transferred amount is correct. The code of an entry point has access to the amount sent by the caller, usually through an amount keyword.

• We need to send that amount to the seller. We will use an instruction that generates a new transaction, from the balance of the contract to a destination address.

We need two entry points in our contract:

• setPrice, for the seller, to indicate at what price they are willing to sell their NFT.

• buy, for the buyer to initiate the purchase.

Here is the corresponding implementation in the Archetype language:

archetype nftForSale(owner : address, metadata: string)

variable price : tez = 0tz

entry setPrice(newPrice : tez) {
  called by owner
  effect { price := newPrice; }
}

entry buy() {
  require { r1 : transferred = price }
  effect {
      transfer price to owner;
      owner := caller;
  }
}

Note that with this version of our contract, if the buyer doesn’t immediately call setPrice after buying this NFT, nothing stops anyone from buying it from them at that same price.

By this, you complete this workshop successfully!!