Caso práctico: activos digitales

Clase 6 de 11 • Curso de Casos de Uso de Smart Contracts

Contenido del curso

Identidad digital

Servicios financieros

Protección de activos digitales

Cadena de suministro

Ciberseguridad

Cierre

11
Continúa aprendiendo
01:10 min

Tomar examen

Resumen

El término NFT significa Non-Fungible Token. A lo igual que los tokens del estándar ERC20, en donde cada uno de una misma colección tiene el mismo valor que otro, los NFT también son tokens, pero no son intercambiables, no divisibles y no necesariamente con el mismo valor cada uno.

En una Blockchain puedes representar activos digitales a través de con estos NFT.

Características de los tokens NFT

Los tokens NFT también tienen su propio estándar. El estándar ERC721, especificado en la propuesta EIP721, describe una interfaz y características de cómo deben ser los tokens no-fungibles que viven en la Blockchain de Ethereum.

Implementando el estándar ERC721

El estándar ERC721 define una serie de funciones y eventos que el contrato inteligente debe cumplir.

function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function approve(address _approved, uint256 _tokenId) external payable;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);

event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

La implementación es más exigente y complicada que el estándar ERC20. La principal característica es la utilización de un TokenId para diferenciar un token de otro.

Desafío de los NFT

No deja de ser un gran reto para ti realizar tu propia implementación del estándar ERC721 y comprender cómo funciona por detrás. Aunque es recomendable en contratos de proyectos reales la utilización de implementaciones auditadas por la comunidad y completamente seguras como la de OpenZeppelin.

En Platzi, podrás desarrollar toda una plataforma de NFT con el Curso de Dapps: Introducción al Desarrollo de Aplicaciones Descentralizadas donde desarrollarás el contrato inteligente, y luego el Curso de Desarrollo Frontend de Aplicaciones Descentralizadas con Web3.js donde trabajarás en el front-end que se conecta a ese contrato.

Te animo a que te tomes el tiempo de realizar ambos cursos. El conocimiento derás de desarrollar todo un contrato inteligente profesional y una aplicación Web3 te dará las herramientas para estar listo o lista para trabajar en proyectos reales.

Contribución creada por: Kevin Fiorentino.

Comentarios

Kevin Fiorentino

student•

Aquí, en Platzi, podrán desarrollar toda una plataforma de NFT con este y este curso. Recomiendo mucho hacerlo ya que es una plataforma muy completa desde el desarrollo del contrato hasta el front-end.

Hugo Montoya Diaz

student•

Shanexon Ortiz

student•

Como solución del reto esta que dentro del contrato que nos da OpenZeppelin hay un parametro llamado **price ** que lo podemos usar para asignarle el precio a los NFT`s, pero hay que validar que la persona pague el precio de ese NFT con algo asi :

require(msg.value >= PRICE, "Debe pagar el precio del NFT");

Abidan Triguero Calle

student•

RESUMEN CLASE 6: CASO PRACTICO ACTIVOS DIGITALES

REMIX:

MyNFT.sol

//Contract based on 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract MyNFT is ERC721URIStorage {
    uint256 private _tokenIds;
    address owner;

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can authorize users");
        _;
    }

    constructor() ERC721("MyNFT", "NFT") {
        owner = msg.sender;
    }

    function mintNFT(address recipient, string memory tokenURI)
        public
        onlyOwner
        returns (uint256)
    {
        _tokenIds = _tokenIds + 1;
        _mint(recipient, _tokenIds);
        _setTokenURI(_tokenIds, tokenURI);

        return _tokenIds;
    }
}

Santiago Guzmàn

student•

Al compilar el contrato estoy recibiendo el siguiente error:

from solidity: ParserError: Source "@openzeppelin/contracts/utils/introspection/IERC165.sol" not found: Deferred import --> @openzeppelin/contracts/token/ERC721/IERC721.sol:6:1: | 6 | import "../../utils/introspection/IERC165.sol";

Saben cual puede ser el problema?

gracias

Dany R

student•

Comparte el código para ver donde esta el error.

Oscar Riojas

student•

Hasta el momento no e visto ninguna de las soluciones del profesor a los restos, si alguien lo a logrado podría compartirme el link por favor?

Andres Felipe Pardo Mesa

student•

Hola Oscar las encuentras en la sección de recursos, este es el repositorio

Sebastián Romero

student•

Podrías explicar las otras funciones al momento de deployarlo pls

Abraham Cutberto Rivera Ramírez

student•

tengo una duda, al momento de desplegar el contrato solo me salen las opciones de openzeppelin, no me aparecen la función de minNFT ni la que hice para ver el precio del NFT y si las puse en públicas alguien sabe como arreglarlo?

Kevin Fiorentino

student•

Compañero! Si están trabajando en Remix, asegúrate de estar desplegando el contrato correcto. Hay un select que te permite seleccionar cuál quieres desplegar y tal vez estás desplegando el de OpenZeppelin en lugar de tu contrato.

Es un poco molesto Remix en este sentido, hay que estar atento. Ojalá algún día mejoren la UX.

Anderson Eduardo Arévalo Ramírez

student•

Me paso lo mismo, me salian funciones super raras. el profe planteo una solución pero no me funcionó. Me siento un poco tosco con openzeppelin pero creo que puedo aprender en futuros cursos.

guillermo sanchez

student•

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract MemoryStorageNFT is ERC721, ERC721URIStorage {
    uint256 public TokenMintPrice = 0;
    address payable private owner;
    uint256 private tokenCounter = 0;
    constructor() ERC721("super Store", "P-NFT-example") {
        owner = payable(msg.sender);

    }

    event MintPriceUpdated(uint256);
    event Mint(uint256, address);

    // The following functions are overrides required by Solidity.
    function name(address _to, string memory _URI) public payable payMintAllowed returns (uint256 tokenID) {
        tokenCounter++;
        _safeMint(_to, tokenCounter);
        _setTokenURI(tokenCounter, _URI);
        emit Mint(tokenCounter, _to);
    }

    function reedimBalance() public onlyOwner {
        owner.transfer(address(this).balance);
    }

    function updateCostMint(uint256 tokenMintCost) public onlyOwner{
        TokenMintPrice = tokenMintCost;
        emit MintPriceUpdated(tokenCounter);
    }


    function contractFounds() public view onlyOwner returns(uint256) {
        return address(this).balance;
    }

    function howCost() public view returns(uint256) {
        return TokenMintPrice;
    }

    modifier payMintAllowed {
        require(msg.value >= TokenMintPrice, 'The cost of the Mint most be pay');
        _;
    }

    modifier onlyOwner {
        require(msg.sender == owner, 'Only owner can activate ');
        _;
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}
```// SPDX-License-Identifier: MIT// Compatible with OpenZeppelin Contracts ^5.0.0pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
contract MemoryStorageNFT is ERC721, ERC721URIStorage {    uint256 public TokenMintPrice = 0;    address payable private owner;    uint256 private tokenCounter = 0;    constructor() ERC721("super Store", "P-NFT-example") {        owner = payable(msg.sender);
&#x20;   }
&#x20;   event MintPriceUpdated(uint256);    event Mint(uint256, address);
&#x20;   // The following functions are overrides required by Solidity.    function name(address \_to, string memory \_URI) public payable payMintAllowed returns (uint256 tokenID) {        tokenCounter++;        \_safeMint(\_to, tokenCounter);        \_setTokenURI(tokenCounter, \_URI);        emit Mint(tokenCounter, \_to);    }
&#x20;   function reedimBalance() public onlyOwner {        owner.transfer(address(this).balance);    }
&#x20;   function updateCostMint(uint256 tokenMintCost) public onlyOwner{        TokenMintPrice = tokenMintCost;        emit MintPriceUpdated(tokenCounter);    }

&#x20;   function contractFounds() public view onlyOwner returns(uint256) {        return address(this).balance;    }
&#x20;   function howCost() public view returns(uint256) {        return TokenMintPrice;    }
&#x20;   modifier payMintAllowed {        require(msg.value >= TokenMintPrice, 'The cost of the Mint most be pay');        \_;    }
&#x20;   modifier onlyOwner {        require(msg.sender == owner, 'Only owner can activate ');        \_;    }
&#x20;   function tokenURI(uint256 tokenId)        public        view        override(ERC721, ERC721URIStorage)        returns (string memory)    {        return super.tokenURI(tokenId);    }
&#x20;   function supportsInterface(bytes4 interfaceId)        public        view        override(ERC721, ERC721URIStorage)        returns (bool)    {        return super.supportsInterface(interfaceId);    }}

//Contract based on 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract MyNFT is ERC721URIStorage {
    uint256 private _tokenIds;
    address owner;

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can authorize users");
        _;
    }

    constructor() ERC721("MyNFT", "NFT") {
        owner = msg.sender;
    }

    function mintNFT(address recipient, string memory tokenURI)
        public
        onlyOwner
        returns (uint256)
    {
        _tokenIds = _tokenIds + 1;
        _mint(recipient, _tokenIds);
        _setTokenURI(_tokenIds, tokenURI);

        return _tokenIds;
    }
}

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract MemoryStorageNFT is ERC721, ERC721URIStorage {
    uint256 public TokenMintPrice = 0;
    address payable private owner;
    uint256 private tokenCounter = 0;
    constructor() ERC721("super Store", "P-NFT-example") {
        owner = payable(msg.sender);

    }

    event MintPriceUpdated(uint256);
    event Mint(uint256, address);

    // The following functions are overrides required by Solidity.
    function name(address _to, string memory _URI) public payable payMintAllowed returns (uint256 tokenID) {
        tokenCounter++;
        _safeMint(_to, tokenCounter);
        _setTokenURI(tokenCounter, _URI);
        emit Mint(tokenCounter, _to);
    }

    function reedimBalance() public onlyOwner {
        owner.transfer(address(this).balance);
    }

    function updateCostMint(uint256 tokenMintCost) public onlyOwner{
        TokenMintPrice = tokenMintCost;
        emit MintPriceUpdated(tokenCounter);
    }


    function contractFounds() public view onlyOwner returns(uint256) {
        return address(this).balance;
    }

    function howCost() public view returns(uint256) {
        return TokenMintPrice;
    }

    modifier payMintAllowed {
        require(msg.value >= TokenMintPrice, 'The cost of the Mint most be pay');
        _;
    }

    modifier onlyOwner {
        require(msg.sender == owner, 'Only owner can activate ');
        _;
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}
```// SPDX-License-Identifier: MIT// Compatible with OpenZeppelin Contracts ^5.0.0pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
contract MemoryStorageNFT is ERC721, ERC721URIStorage {    uint256 public TokenMintPrice = 0;    address payable private owner;    uint256 private tokenCounter = 0;    constructor() ERC721("super Store", "P-NFT-example") {        owner = payable(msg.sender);
&#x20;   }
&#x20;   event MintPriceUpdated(uint256);    event Mint(uint256, address);
&#x20;   // The following functions are overrides required by Solidity.    function name(address \_to, string memory \_URI) public payable payMintAllowed returns (uint256 tokenID) {        tokenCounter++;        \_safeMint(\_to, tokenCounter);        \_setTokenURI(tokenCounter, \_URI);        emit Mint(tokenCounter, \_to);    }
&#x20;   function reedimBalance() public onlyOwner {        owner.transfer(address(this).balance);    }
&#x20;   function updateCostMint(uint256 tokenMintCost) public onlyOwner{        TokenMintPrice = tokenMintCost;        emit MintPriceUpdated(tokenCounter);    }

&#x20;   function contractFounds() public view onlyOwner returns(uint256) {        return address(this).balance;    }
&#x20;   function howCost() public view returns(uint256) {        return TokenMintPrice;    }
&#x20;   modifier payMintAllowed {        require(msg.value >= TokenMintPrice, 'The cost of the Mint most be pay');        \_;    }
&#x20;   modifier onlyOwner {        require(msg.sender == owner, 'Only owner can activate ');        \_;    }
&#x20;   function tokenURI(uint256 tokenId)        public        view        override(ERC721, ERC721URIStorage)        returns (string memory)    {        return super.tokenURI(tokenId);    }
&#x20;   function supportsInterface(bytes4 interfaceId)        public        view        override(ERC721, ERC721URIStorage)        returns (bool)    {        return super.supportsInterface(interfaceId);    }}

Caso práctico: activos digitales

Identidad digital

¿Cómo proteger tu identidad digital con blockchain?

Caso práctico: identidad digital

Servicios financieros

¿Cómo blockchain soluciona problemas financieros?

Caso práctico: servicios financieros

Protección de activos digitales

¿Cómo proteger tus activos con blockchain?