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.
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?
Caso práctico: activos digitales
Cadena de suministro
¿Cómo hacer cadenas de suministro más eficientes con blockchain?
Caso práctico: cadena de suministro
Ciberseguridad
Ciberseguridad y blockchain
Caso práctico: ciberseguridad
Cierre
Continúa aprendiendo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Caso práctico: activos digitales
6/11Recursos
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.
Aportes 5
Preguntas 4
Ordenar por:
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”);
RESUMEN CLASE 6:
CASO PRACTICO
ACTIVOS DIGITALES
REMIX:
MyNFT.sol
//Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
// 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;
}
}
```js
// 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);
}
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); }}
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?