CCC: Cryptocurrency Course slide set

## What is a Token
- A *token* is an entry on a blockchain that represents *something* other than a "monetary" transaction
  - The *something* that it represents could be:
    - Ownership of a single item (physical or digital)
    - Membership in some organization
    - Amount of votes one has
    - Shares of an equity, such as another cryptocurrency 
  - Form of the entry:
    - In Ethereum, this would be a smart contract
    - Other blockchains (Tezos, Ravencoin) have native support for tokens

## E-Z Tokens
- This would do it:
```
contract EZTokens {
    mapping (address => uint) public ownership;
    function addQuantity(address,uint) public { ... }
    function removeQuantity(address, uint) public { ... }
}
```
- This provides:
  - The ability to see how much an address owns
  - The ability to add or remove quantity
- Obviously we want a more robust contract...

## Anybody can use a token
- With the ABI and the contract address, any *programmer* can interact with one
- But how to ensure that non-programmers can?
  - And that wallets can?
- The Ethereum solution: create a standard way to interact with them
  - Via an `interface`
- Other cryptocurrencies:
  - Either have the equivalent of a standard interface
  - Or natively support them on the blockchain
- Then any wallet software can interact with tokens

## Ethereum Improvement Proposals
- [ethereum.org](https://ethereum.org/en/) allows submissions of EIPs
  - EIP = Ethereum Improvement Proposal
- There are three types (as described by [EIP-1](https://eips.ethereum.org/EIPS/eip-1))
  - Standards track EIP, which has 4 categories:
    - Core: changes to Ethereum itself, requiring a consensus fork
    - Networking, such as the P2P aspect of Ethereum
    - Interface, such as of the ABI (*not* Solidity interfaces)
    - ERC: Ethereum Request for Comments: contract interfaces and code
  - Meta EIP: a change to a process, such as governance
  - Informational EIP: educational

## List of EIPs / ERCs
- See https://eips.ethereum.org/erc
- We'll be covering 5 of those in this lecture:
  - ERC-165: `supportsInterface()`
  - ERC-20: fungible tokens
  - ERC-721: non-fungible tokens
  - ERC-777: improved fungible tokens (briefly)
  - ERC-1155: improved non-fungible tokens (briefly)
  - ERC-6551: NFT bound accounts

## OpenZeppelin
- [OpenZeppelin](https://openzeppelin.com/) is a source for freely available implementations of many ERCs
  - All code released under the MIT license
    - Which means you can use it for both commercial and non-commercial purposes
- Available in their [github repo](https://github.com/OpenZeppelin/openzeppelin-contracts)
- We'll use this code in our assignments
  - No need to reinvent the wheel!

## Trust
- Anybody can download the OpenZeppelin code
  - And then compile it to see the bytecode
  - And then compare it to what is on the blockchain
- Thus, with the original source we can verify that a given smart contract on the blockchain is a known contract
- If we make a new one, and we want people to trust it, we likely will have to release the source code
  - Otherwise a call to `selfdestruct()` would allow us to steal all the ETH that the contract holds

## Fungability

- Which is worth more?
  - Other than convenience
- Images from [Wikipedia](https://en.wikipedia.org/wiki/United_States_dollar)

##  Fungibility
> fungible (adj): being something (such as money or a commodity) of such a nature that one part or quantity may be replaced by another equal part or quantity in paying a debt or settling an account

> fungibility: the state of being fungible

## Fungible tokens
- A *fungible* token can be exchanged for an equal amount of the same token
  - Examples: tokens that represent cryptocurrencies, shares of a *thing* such as a stock or equity, or weight of votes
- A *non-fungible* token cannot be split; it's atomic
  - Examples: tokens that represent real-world items (artwork), digital assets, membership in an organization, etc.

## Transaction types
- I claim there are four overall types of transactions:
  - Unofficial transactions where there is no receipt needed
    - One individual selling something to another, bartering, cash payments, illegal transactions, etc.
  - Buying something from a business
    - A receipt is generated, possibly electronically
  - Buying items with special tax status
    - Houses, cars, boats, planes, equities
  - Buying a digital asset
    - A digital image, etc.
- The first three either don't need or already have receipts, and so have no need for an NFT
  - NFTs thus are only useful for the last one

## How buy an NFT
- OpenSea at [opensea.io](https://opensea.io)
  - And their [Bored Ape Yacht Club page](https://opensea.io/collection/boredapeyachtclub)
- Let's take a look!
- We'll be seeing MetaMask later this semester

## What does an NFT give you?
- So unclear
- Anybody can download the image
- But you "own" the "thing"
- There is no legal basis for recognizing "ownership" of a thing based on an NFT
  - You could take them to court and claim that since you paid for it, you now own it
  - You'd probably win, after a court battle
- So what does an NFT give you?

## What does ownership mean?
- I suppose you have the rights to publish that picture
  - But how many people who buy NFTs want to do that?
  - Some NFTs explicitly prevent you publishing the image!
- Sports networks want to sell NFTs for "moments" in a game
  - They don't give up their broadcasting rights to that "moment"
  - And you can't broadcast it yourself

## Jet pack analogy

## Scams
- Consider DeviantArt user LiamRSharp
  - He had to shut down [his DeviantArt gallery](https://www.deviantart.com/liamrsharp) because of NFT theft
  - See [this twitter post](https://twitter.com/liamrsharp/status/1471940531554959360?lang=en) and [this reddit post](https://www.reddit.com/r/KotakuInAction/comments/ritysg/twitter_sadly_im_going_to_have_to_completely_shut/)
  - Once this went viral, DeviantArt did something about it, and he was able to re-open it
- What prevents somebody from selling an NFT multiple times?
  - Or making minor modifications and re-selling it?
  - *Some* auction sites check for this, but not all, and not reliably

## The future for NFTs
- They could have a real role to play in the future
- But laws and policy would have to support their use
- But not if their perception is poisoned by all these scams

## Function selectors
- You can get individual function selectors via either:
```
  this.funcName.selector
  myInterface.funcName.selector
```
  - The first one is only to get a function selector of a function in the current contract
- An *interface selector* is just the XOR of all the contained function selectors
  - But just the outward-facing ones: public and external only
- You can get the interface selector via:
```
  type(myInterface).interfaceId
```

## Solidity Type Information
- Given a type `T`, a contract `C`, or an interface `I`, you can get information about that type:
  - `type(T).min`: the minimum value
  - `type(T).max`: the maximum value
  - `type(C).name`: the name of the contract
  - `type(I).interfaceId`
    - A `bytes4` value that is the xor of the function selectors of the (non-inherited and outward-facing) functions in the interface
  - (two others we won't see here)
- Reference is from [this page](https://docs.soliditylang.org/en/latest/units-and-global-variables.html#meta-type) of the [Solidity programming reference](https://docs.soliditylang.org/en/latest/)

## Interface / function selectors
<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.24;

interface ISelectors {
    function doesNothing(uint,bool) external;
    function onlyReverts(string memory) external;
    function triad(bytes4) external;
}

contract Selectors is ISelectors {
    function doesNothing(uint u, bool b) external override { }
    function onlyReverts(string memory s) external override { }
    function triad(bytes4 b) external override { }
    function onlyMe() internal { }

constructor() {
        require (type(ISelectors).interfaceId ==
                 ISelectors.doesNothing.selector ^ 
                 ISelectors.onlyReverts.selector ^ 
                 ISelectors.triad.selector);
    }
}
</code></pre>

## ERC-165 Code
- The interface:

<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>interface IERC165 {
    function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
</code></pre>

- The contract implementation:

<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>function supportsInterface(bytes4 interfaceId) external pure override 
            returns (bool) {
  
  return interfaceId == type(IERC721).interfaceId ||
         interfaceId == type(IERC165).interfaceId;
}
</code></pre>

- Some implementations use `view`, some use `pure`
- Function and interface selector: 0x01ffc9a7
- [OpenZeppelin source code](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol)

## `supportsInterface()`
- Code provided in the [Gradebook assignment](../hws/gradebook/index.html):

<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
        return interfaceId == type(IGradebook).interfaceId || 
               interfaceId == 0x01ffc9a7;
}
</code></pre>

- 0x01ffc9a7 is the interface selector for IERC165
  - Hard-coding the value prevented the need to include that interface
- But we'll include the full version in future assignments:

## Known interface selectors
- Our blockchain explorer contains a list of the known function and interface selectors used in this course
  - Click on the "View the known ABIs and interface IDs" link at the bottom of the main page

## Overview
- Created in 2015, this standard allows for creating *fungible* tokens
  - Shares in a cryptocurrency, voting power, membership level, equity amount, reputation / karma, etc.
  - See [here](https://ethereum.org/en/developers/docs/standards/tokens/erc-20/#introduction) for other uses
- Notably, it was written *before* ERC-165
  - So it does *not* have the `supportsInterface()` function
- Reference: [ERC-20 Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-20/) from [ethereum.org](https://ethereum.org/)
  - And the formal [ERC-20 EIP](https://eips.ethereum.org/EIPS/eip-20)

## ERC-20 Interface
- [OpenZeppelin source code](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) and [contract source code](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)

<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>interface IERC20 {

function totalSupply() external view returns (uint);

function balanceOf (address account) external view returns (uint);

function transfer (address recipient, uint amount) external returns (bool);

function allowance (address owner, address spender) external view 
                    returns (uint);

function approve (address spender, uint amount) external returns (bool);

function transferFrom (address sender, address recipient, uint amount) 
                    external returns (bool);

event Transfer(address indexed from, address indexed to, uint value);

event Approval(address indexed owner, address indexed spender, uint value);

}
</code></pre>

## Why `approve()` & `transferFrom()`?
![](images/tokens/graphs/tokens.dot.1.svg)
- You only want to make one call to the DEX
  - The TokenCC needs to know that the DEX can transfer some of your TC
- Protocol:
  - `approve()` the DEX for a certain amount (say, $x$) of the cryptocurrency
  - Send *one* transaction to the DEX that also contains ETH
    - The parameters in that transaction include the transferred cryptocurrency info

Our Usage

For the Tokens assignment, we will use the ITokenCC.sol interface:

interface ITokenCC is IERC20Metadata, IERC165 {

    // inherits from IERC20Metadata (name(), symbol(), decimals())

    // inherits from IERC20 (6 functions)

    // inherits from IERC165 (supportsInterface())

    function requestFunds() external;

}

Our TokenCC code contract will implement that interface
The contract line will be:
```
contract TokenCC is ITokenCC, ERC20 {
```

## Token Cryptocurrencies
- See a list at https://etherscan.io/tokens
  - 1,257 such token cryptocurrencies (as of March 2024)
- [Token cryptocurrencies on etherscan.io](https://etherscan.io/tokens)
- Consider [Atomic Wallet](https://atomicwallet.io/)
  - A wallet that can store [1,430 cryptocurrencies](https://atomicwallet.io/prices) (as of March 2024):
    - 83 blockchain cryptocurrencies
    - 1,069 ERC-20 token cryptocurrencies
      - 278 BEP20 tokens: runs on Binance, not Ethereum
      - 6 TRC20 tokens: runs on TRON, not Ethereum
  - You can see an (older) list on the next slide

## [![shib logo](../slides/images/logos/shib-coin-symbol.svg)](https://coinmarketcap.com/currencies/shiba-inu/) Consider SHIB
- As of March 18, 2024:
  - [SHIB's value](https://coinmarketcap.com/currencies/shiba-inu/) is `$`$0.00002497 (40k per USD)
  - ETH's value is `$`3,167
  - [ETH gas](https://etherscan.io/gastracker) is 32 gwei, which means `$`2.13 per transaction
- To buy SHIB, you have to spend at least `$`2.13 for transaction fees
  - Or over 85,000 SHIB
- All token cryptocurrency exchanges with the ERC-20 contract have to pay the Ethereum fees!
- Exchanges such as Coinbase do it differently
- SHIB is #11 on [coinmarketcap.com](https://coinmarketcap.com/)
  - Because the ERC-20 token minted 589,289,410,812,691 shares (yes, $5.9 \ast 10^{14}$ or about 589 trillion) coins
  - Total market cap: `$`14 *billion* dollars

## Python code for DAI & WETH
<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;height:120%"
>from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com"))

dai_token_addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"     # DAI
weth_token_addr = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"    # Wrapped ether (WETH)

acc_address = "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11"        # Uniswap V2: DAI 2

# This is a simplified Contract Application Binary Interface (ABI) of an ERC-20 Token Contract.
# It will expose only the methods: balanceOf(address), decimals(), symbol() and totalSupply()
simplified_abi = [
    {
        'inputs': [{'internalType': 'address', 'name': 'account', 'type': 'address'}],
        'name': 'balanceOf',
        'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
        'stateMutability': 'view', 'type': 'function', 'constant': True
    },
    {
        'inputs': [],
        'name': 'decimals',
        'outputs': [{'internalType': 'uint8', 'name': '', 'type': 'uint8'}],
        'stateMutability': 'view', 'type': 'function', 'constant': True
    },
    {
        'inputs': [],
        'name': 'symbol',
        'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}],
        'stateMutability': 'view', 'type': 'function', 'constant': True
    },
    {
        'inputs': [],
        'name': 'totalSupply',
        'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
        'stateMutability': 'view', 'type': 'function', 'constant': True
    }
]

dai_contract = w3.eth.contract(address=w3.toChecksumAddress(dai_token_addr), abi=simplified_abi)
symbol = dai_contract.functions.symbol().call()
decimals = dai_contract.functions.decimals().call()
totalSupply = dai_contract.functions.totalSupply().call() / 10**decimals
addr_balance = dai_contract.functions.balanceOf(acc_address).call() / 10**decimals

#  DAI
print("===== %s =====" % symbol)
print("Total Supply:", totalSupply)
print("Addr Balance:", addr_balance)

weth_contract = w3.eth.contract(address=w3.toChecksumAddress(weth_token_addr), abi=simplified_abi)
symbol = weth_contract.functions.symbol().call()
decimals = weth_contract.functions.decimals().call()
totalSupply = weth_contract.functions.totalSupply().call() / 10**decimals
addr_balance = weth_contract.functions.balanceOf(acc_address).call() / 10**decimals

#  WETH
print("===== %s =====" % symbol)
print("Total Supply:", totalSupply)
print("Addr Balance:", addr_balance)
</code></pre>

## Python code for DAI & WETH
- We'll see how to access blockchains via Python in future assignments
- Output (from a while ago):

```
===== DAI =====
Total Supply: 6306220677.598089
Addr Balance: 6801805.628786693

===== WETH =====
Total Supply: 4071131.476204834
Addr Balance: 5149.944966727369
```

## Attacks
- Consider [this attack](https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/) on an ERC-20 token:
  1. Alice allows Bob to transfer $n>0$ tokens via `approve()`
  2. Later, Alice changes that to $m>0$
  3. Bob notices (2) in the mempool, and quickly spends all $n$ tokens
  4. Alice's transaction from (2) goes through, allowing Bob to transfer $m$ more tokens
- Thus, Bob controlled $n+m$ of Alice's tokens, which was never her intent
- Solutions:
  - Alice makes 2 transactions: first change Bob's approval to zero then to $m$ (requires two transactions & fees)
  - Change the ERC-20 standard such that the new approval only happens if the current approval is not yet spent

## Upcoming Assignments
- In the Tokens assignment, you will be creating a token cryptocurrency
  - With a name, symbol, and logo
  - You have to design the logo via [GIMP](https://www.gimp.org/) or similar
- In the DEX (Decentralized Exchange) assignment, you will be creating an smart contract to exchange your cryptocurrency for our (fake) ETH

## Overview
- Created in 2018, this standard allows for creating *non-fungible* tokens
  - Membership in an organization, a representation of a physical or digital asset, etc.
  - See [here](https://ethereum.org/en/developers/docs/standards/tokens/erc-721/#popular-nfts) for other uses
- Notably, it was written *after* ERC-165
  - So it *does* have the `supportsInterface()` function
- Reference: [ERC-721 Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-721/) from [ethereum.org](https://ethereum.org/)
  - And the formal [ERC-721 EIP](https://eips.ethereum.org/EIPS/eip-721)

## ERC-721 Interface
<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>interface IERC721 is IERC165 {

function balanceOf(address owner) external view returns (uint balance);

function ownerOf (uint tokenId) external view returns (address owner);

function safeTransferFrom (address from, address to, uint tokenId) external;

function safeTransferFrom (address from,address to, uint tokenId, 
                               bytes calldata data) external;

function transferFrom (address from, address to, uint tokenId) external;

function approve (address to, uint tokenId) external;

function getApproved (uint tokenId) external view returns (address operator);

function setApprovalForAll (address operator, bool _approved) external;

function isApprovedForAll (address owner, address operator) 
              external view returns (bool);
}
</code></pre>

## ERC-721 Optional Interface
- There are three *optional* metadata functions, as described [here](https://eips.ethereum.org/EIPS/eip-721) and defined in the `IERC721Metadata` interface:

<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>interface IERC721Metadata is IERC721 {

function name() external view returns (string _name);

function symbol() external view returns (string _symbol);

function tokenURI(uint256 _tokenId) external view returns (string);
}
</code></pre>
- Note that ERC-721 is more of a non-fungible token *manager* rather than just the token itself

## Our Usage
- For the tokens assignment, we will use [INFTManager.sol](../hws/tokens/INFTManager.sol.html):

<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>interface INFTManager is IERC721Metadata {

// This creates a NFT for `_to` with the pased file name `_uri`.  Note
    // that `_uri` is just the filename itself -- the prefix is set via
    // overriding _baseURI()
    function mintWithURI(address _to, string memory _uri) external returns (uint);

// This also creates a NFT, but assumes `msg.sender` is who the NFT is
    // for; it can just call the previous function.
    function mintWithURI(string memory _uri) external returns (uint);

// This is just a count of how many NFTs have been minted with this
    // manager; it can be a public variable.
    function count() external returns (uint);

// Additional functions to implement / override:
    // supportsInterface(): for the interfaces specified in the HW writeup
    // _baseURI(): the part of the full path name before the filename itself
    // tokenURI(): get the file name (with _baseURI() before it) for the passed 
    //             NFT ID

}</code></pre>

## Starting Source Code
- We will all start with the freely available implementation by [OpenZeppelin](https://openzeppelin.com/)
- Specifically that for ERC-721 tokens:
  - https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.0.0/contracts/token/ERC721/ERC721.sol
- Let's go over that code...

## Inheritance Tree
![](../hws/tokens/inheritance.dot.2.svg)

## Upcoming Assignments
- In the Tokens assignment, you will be creating an NFT manager
  - This is in addition to the cryptocurrency part of this assignment
- In the Auction assignment, you will be creating an auction smart contract to allow bidding on your NFTs
- In the MetaMask assignment, you will create a web page that allows easy interaction with your Auction smart contract on the blockchain
- We'll look at the [Tokens assignment](../hws/tokens/index.html) now

## Overview
- Created in 2017, this standard improves upon the ERC-20 (FT) standard
  - That was 2 years after the ERC-20 standard
- They can be written to be backwards-compatible, so any such ERC-777 token fulfills the ERC-20 token interface
- Notably, it was written *after* ERC-165
  - So it *does* have the `supportsInterface()` function
- Reference: [ERC-777 Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-777/) from [ethereum.org](https://ethereum.org/)
  - And the formal [ERC-777 EIP](https://eips.ethereum.org/EIPS/eip-777)

## Improvements: decimals
- `decimals()`
  - This was optional in ERC-20
  - If not included, how many decimals to use?  The standard defaulted to 18, but the standard implied 0 was also acceptable
- For ERC-20 backward compatibility, an ERC-777 token's `decimals()` *must* return 18
- If you don't want it to be backward compatible, make it any (reasonable) value

## Improvements: hooks
- A hook is a function that is triggered when a token is sent or received
  - They are registered and discovered as described in [ERC-1820](https://eips.ethereum.org/EIPS/eip-1820)
    - We won't see that ERC in this course
  - They can even reject transactions
- Example usage:
  - In pure ERC-20, sending tokens to a contract and then notifying said contract was two steps (`approve()` then `trasnferFrom()`)
  - With a hook in an ERC-777 token, this is a single call
    - Saves gas!

## ERC-777 Interface
<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC777/IERC777.sol)

pragma solidity ^0.8.0;

interface IERC777 {

function name() external view returns (string memory);

function symbol() external view returns (string memory);

function granularity() external view returns (uint256);

function totalSupply() external view returns (uint256);

function balanceOf(address owner) external view returns (uint256);

function send(address recipient, uint256 amount, bytes calldata data) external;

function burn(uint256 amount, bytes calldata data) external;

function isOperatorFor(address operator, address tokenHolder) external view returns (bool);

function authorizeOperator(address operator) external;

function revokeOperator(address operator) external;

function defaultOperators() external view returns (address[] memory);

function operatorSend (address sender, address recipient, uint256 amount, bytes calldata data, bytes calldata operatorData ) external;

function operatorBurn (address account, uint256 amount, bytes calldata data, bytes calldata operatorData ) external;

event Sent (address indexed operator, address indexed from, address indexed to, uint256 amount, bytes data, bytes operatorData);

event Minted (address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);

event Burned (address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData);

event AuthorizedOperator (address indexed operator, address indexed tokenHolder);

event RevokedOperator (address indexed operator, address indexed tokenHolder);
}</code></pre>

## Backwards compatibility
- To make it backwards compatible, just have it implement the ERC-20 interface also:

```
contract FTplusplus is IERC777, IERC165, IERC20 {
  // ...
}
```

## OpenZeppelin Implementation
- OpenZeppelin code for:
  - [IERC777.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC777/IERC777.sol): the interface
  - [ERC777.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC777/ERC777.sol): the implementation
- We won't go over that in detail, though

## Overview
- Created in 2018, this standard improves upon the ERC-721 (NFT) standard
  - That was half a year after the ERC-721 standard
- They can be written to be backwards-compatible, so any such ERC-1155 token fulfills the ERC-721 token interface
  - The function names between the two are all different
- Notably, it was written *after* ERC-165
  - So it *does* have the `supportsInterface()` function
- Reference: [ERC-1155 Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-1155/) from [ethereum.org](https://ethereum.org/)
  - And the formal [ERC-1155 EIP](https://eips.ethereum.org/EIPS/eip-1155)

## Improvements
(from the [ERC-1155 Token Standard](https://ethereum.org/en/developers/docs/standards/tokens/erc-1155/))
- Batch transfer: transfer multiple assets in a single call
- Batch balance: get the balances of multiple assets in a single call
- Batch approval: approve all tokens to an address
- Hooks: receive tokens hook
- NFT support: if supply is only 1, treat it as NFT
- Safe transfer rules: set of rules for secure transfer

## ERC-1155 Interface
<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:120%"
>// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC777/IERC777.sol)

pragma solidity ^0.8.0;

interface IERC1155 is IERC165 {

event TransferSingle(address indexed operator, address indexed from, 
                         address indexed to, uint256 id, uint256 value);

event TransferBatch(address indexed operator, address indexed from, 
                        address indexed to, uint256[] ids, uint256[] values );

event ApprovalForAll(address indexed account, address indexed operator, 
                        bool approved);

event URI(string value, uint256 indexed id);

function balanceOf(address account, uint256 id) external view 
                        returns (uint256);

function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) 
                        external view returns (uint256[] memory);

function setApprovalForAll(address operator, bool approved) external;

function isApprovedForAll(address account, address operator) external view 
                        returns (bool);

function safeTransferFrom( address from, address to, uint256 id, 
                        uint256 amount, bytes calldata data ) external;

function safeBatchTransferFrom( address from, address to, 
                        uint256[] calldata ids, uint256[] calldata amounts, 
                        bytes calldata data ) external;
}
</code></pre>

## Backwards compatibility
- To make it backwards compatible, just have it implement the ERC-721 interface also:

```
contract NFTplusplus is IERC1155, IERC165, IERC721 {
  // ...
}
```

## OpenZeppelin Implementation
- OpenZeppelin code for:
  - [IERC1155.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/IERC1155.sol): the interface
  - [ERC1155.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/ERC1155.sol): the implementation
- We won't go over that in detail, though

## NFT Limitations
- A NFT cannot "have" other things...
  - Own other NFTs
  - An ether balance
- Enter [ERC-6551](https://eips.ethereum.org/EIPS/eip-6551) which assigns an account number to any (ERC-721) NFT
- Stated use cases:
  - A character in a role-playing game that accumulates assets and abilities over time based on actions they have taken
  - An automobile composed of many fungible and non-fungible components
  - An investment portfolio composed of multiple fungible assets
  - A punch pass membership card granting access to an establishment and recording a history of past interactions

## How to compute the NFT address
- This is a somewhat simplified version
- Take a bunch of information in binary form:
  - implementation: the (often owned) account that is generating this address
  - chainId: 1 for mainnet, something else for us
  - tokenContract: the address of the NFT contract
  - tokenId: the uint256 ID of the token
- Concatenate all these together, take the (SHA3) hash, and use the last 20 bytes

## Registry
- Create a single smart contract registry where any NFT can have such an account created
  - `createAccount()`: to create (and register) such an account address
  - `account()`: to compute such an address

## Registry Interface
<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:150%;margin-left:-200px"
>interface IERC6551Registry {
    /**
     * @dev The registry SHALL emit the AccountCreated event upon successful account creation
     */
    event AccountCreated(
        address account,
        address indexed implementation,
        uint256 chainId,
        address indexed tokenContract,
        uint256 indexed tokenId,
        uint256 salt
    );

/**
     * @dev Creates a token bound account for a non-fungible token.
     *
     * If account has already been created, returns the account address without calling create2.
     *
     * If initData is not empty and account has not yet been created, calls account with
     * provided initData after creation.
     *
     * Emits AccountCreated event.
     *
     * @return the address of the account
     */
    function createAccount(
        address implementation,
        uint256 chainId,
        address tokenContract,
        uint256 tokenId,
        uint256 salt,
        bytes calldata initData
    ) external returns (address);

/**
     * @dev Returns the computed token bound account address for a non-fungible token
     *
     * @return The computed address of the token bound account
     */
    function account(
        address implementation,
        uint256 chainId,
        address tokenContract,
        uint256 tokenId,
        uint256 salt
    ) external view returns (address);
}
</code></pre>

## Account Interface
- Problem: how do you get the NFT account to sign anything? 
  - Any type of transaction requires an ECDSA signature
  - If the private key is in the contract, anybody can see it
- Solution: each TBA's (Token Bound Account's) owner is allowed to sign for the NFT
- To implement this, all NFTs that want an account number need to implement the `IERC6551Account` interface

## Account Interface
<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:150%;margin-left:-200px"
>/// @dev the ERC-165 identifier for this interface is `0x6faff5f1`
interface IERC6551Account {
    /**
     * @dev Allows the account to receive Ether
     *
     * Accounts MUST implement a `receive` function.
     *
     * Accounts MAY perform arbitrary logic to restrict conditions
     * under which Ether can be received.
     */
    receive() external payable;

/**
     * @dev Returns the identifier of the non-fungible token which owns the account
     *
     * The return value of this function MUST be constant - it MUST NOT change
     * over time
     *
     * @return chainId       The EIP-155 ID of the chain the token exists on
     * @return tokenContract The contract address of the token
     * @return tokenId       The ID of the token
     */
    function token()
        external
        view
        returns (
            uint256 chainId,
            address tokenContract,
            uint256 tokenId
        );

/**
     * @dev Returns a value that SHOULD be modified each time the account changes state
     *
     * @return The current account state
     */
    function state() external view returns (uint256);

/**
     * @dev Returns a magic value indicating whether a given signer is authorized to act on behalf of the account
     *
     * MUST return the bytes4 magic value 0x523e3260 if the given signer is valid
     *
     * By default, the holder of the non-fungible token the account is bound to MUST be considered a valid
     * signer
     *
     * Accounts MAY implement additional authorization logic which invalidates the holder as a
     * signer or grants signing permissions to other non-holder accounts
     *
     * @param  signer     The address to check signing authorization for
     * @param  context    Additional data used to determine whether the signer is valid
     * @return magicValue Magic value indicating whether the signer is valid
     */
    function isValidSigner(address signer, bytes calldata context)
        external
        view
        returns (bytes4 magicValue);
}
</code></pre>

## Doing "things" via an NFT account
- To perform an operation from an NFT account...
  - The account holder has to perform said action, but it has to be "though" the NFT
    - Formally through the Token Bound Account
- A new interface is provided to allow these actions to be performed
- The NFT must declare this in `supportsInterface()`

## Execution interface
<pre class="code-wrapper"><code class="hljs awk small" style="height:auto;width:150%;margin-left:-200px"
>/// @dev the ERC-165 identifier for this interface is `0x74420f4c`
interface IERC6551Executable {
    /**
     * @dev Executes a low-level operation if the caller is a valid signer on the account
     *
     * Reverts and bubbles up error if operation fails
     *
     * @param to        The target address of the operation
     * @param value     The Ether value to be sent to the target
     * @param data      The encoded operation calldata
     * @param operation A value indicating the type of operation to perform
     *
     * Accounts implementing this interface MUST accept the following operation parameter values:
     * - 0 = CALL
     * - 1 = DELEGATECALL
     * - 2 = CREATE
     * - 3 = CREATE2
     *
     * Accounts implementing this interface MAY support additional operations or restrict a signer's
     * ability to execute certain operations
     *
     * @return The result of the operation
     */
    function execute(
        address to,
        uint256 value,
        bytes calldata data,
        uint256 operation
    ) external payable returns (bytes memory);
}
</code></pre>

## Use cases
- Gaming: one item can hold other items
  - This would likely be on a game blockchain, not on Ethereum mainnet
- Communities, such as DAOs, or reputation systems
  - Their membership NFT could accumulate other "things" as they continue to be a member (awards, promotions, etc.)
- Transferring a set of NFTs at once

## Closing thoughts
- There are other involved EIPs:
  - ERC-165: We've seen that one
  - [ERC-1167](https://eips.ethereum.org/EIPS/eip-1167): proxy delegation to another contract
  - [ERC-1271](https://eips.ethereum.org/EIPS/eip-1271): allow smart contracts to verify a signature on behalf of that contract
- [ERC-6551 page on etherscan.io](https://etherscan.io/token/0x8b69b7e42e1c5998dad7c560aca5a1df7e804bf8)