Diffusion 3.0 de l'Art - Les NFT

Par -
Un artiste souhaite diffuser ses oeuvres. Il décide donc de présenter une collection, une selection d'oeuvres qui seront identifiées au sein d'un catalogue de l'exposition et proposées à un public pour l'exposition et l'acquisition. 
Il peut décider de dupliquer une ou plusieurs de ses oeuvres.  Une oeuvre numérique ou une photo peuvent facilement être dupliquées et les oeuvres en plusieurs exemplaires, si la diffusion est limitée peut faire l'oeuvre d'une numérotation. Les oeuvres seront accompagnées d'un ou plusieurs éléments qui permettront d'en établir l'authenticité, une facture de la transaction, un certificat d'authenticité par exemple. 

Le NFT contiendra alors l'identité de l'artiste, un identifiant unique, un contenu ou un lien vers un contenu.

De nombreuses plateformes en ligne permettent de créer facilement et à moindre frais des NFTs. OpenSea est l'une de ces plateformes : https://opensea.io/

Il est également possible de créer soi même son NFT, en développant un contrat intelligent compatible avec les standards et en utilisant une infrastructure privée ou publique.

Il existe en ligne de nombreuses ressources qui permettent de développer un contrat intelligent.

Le Wizard d'OpenZeppelin permet de paramétrer et générer automatiquement un contrat :

https://wizard.openzeppelin.com

Il permet de selectionner le standard à suivre

  • ERC20 : Jeton
  • ERC721 : NFTs
  • ERC115 : Collection de NFTs

Pour les NFTs les métadonnées jouent un rôle très important :

  • https://docs.ipfs.io/how-to/best-practices-for-nft-data/
  • https://docs.opensea.io/docs/metadata-standards
Le protocole IPFS permet de stocker de manière pérenne des données dans une blockchain publique.
Infura est un prestataire qui héberge ses nodes IPFS et les met à disposition de développeurs.

Stratégies de Frappe

La frappe des NFT peut suivre plusieurs stratégies. Il n'existe pas de parking pour NFTs, immédiatement après leur frappe ils doivent être transferés vers un portefeuille. 

Frappe initiale

Un artiste peut émettre en une fois plusieurs NFTs et les transferer vers son portefeuille. Charge à lui ensuite de selectionner un canal de diffusion.

Frappe à la demande

Une interface web peut être mise à disposition des clients qui leur permettra d'interagir directement avec le contrat des NFTs et d'acquérir à la demande un NFT, eventuellement contre le paiement d'une somme.

Frappe planifiée

Les NFTs peuvent également être frappées en plusieurs fois, d'une manière périodique ou evènementielle.

721 et 1155 Proposals

IERC165

interface IERC165 {
    /// @notice Query if a contract implements an interface
    /// @param interfaceID The interface identifier, as specified in ERC-165
    /// @dev Interface identification is specified in ERC-165. This function
    ///  uses less than 30,000 gas.
    /// @return `true` if the contract implements `interfaceID` and
    ///  `interfaceID` is not 0xffffffff, `false` otherwise
    function supportsInterface(bytes4 interfaceID) external view returns (bool);
}

https://docs.openzeppelin.com/contracts/3.x/api/token/erc1155

ERC-721

Le terme NFT est né d'une proposition d'implémentation Ethereum nommée "ERC-721 Non-Fungible Token Standard". Elle définit une interface pour implémenter des jetons non fongibles via un contrat intelligent sur la blockchain.

Evènements

Transfer

event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
Signale le changement de propriété d'un NFT. Il est émis quand un NFT est créé et détruit.

/// @dev This emits when ownership of any NFT changes by any mechanism. /// This event emits when NFTs are created (`from` == 0) and destroyed /// (`to` == 0). 

Exception: during contract creation, any number of NFTs /// may be created and assigned without emitting Transfer. At the time of /// any transfer, the approved address for that NFT (if any) is reset to none.

Approval

 event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);

This emits when the approved address for an NFT is changed or reaffirmed. The zero address indicates there is no approved address. /// When a Transfer event emits, this also indicates that the approved /// address for that NFT (if any) is reset to none. 

ApprovalForAll

event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

This emits when an operator is enabled or disabled for an owner. The operator can manage all NFTs of the owner. 

Fonctions

balanceOf

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

Retourne le nombre de NFT possedés par une adresse 
/// @notice Count all NFTs assigned to an owner
    /// @dev NFTs assigned to the zero address are considered invalid, and this function throws for queries about the zero address.
    /// @param _owner An address for whom to query the balance
    /// @return The number of NFTs owned by `_owner`, possibly zero

ownerOf

    /// @param _tokenId The identifier for an NFT
    /// @return The address of the owner of the NFT
function ownerOf(uint256 _tokenId) external view returns (address);

Find the owner of an NFT . NFTs assigned to zero address are considered invalid, and queries about them do throw.

safeTransferFrom

    /// @notice Transfers the ownership of an NFT from one address to another address
    /// @dev Throws unless `msg.sender` is the current owner, an authorized
    ///  operator, or the approved address for this NFT. Throws if `_from` is
    ///  not the current owner. Throws if `_to` is the zero address. Throws if
    ///  `_tokenId` is not a valid NFT. When transfer is complete, this function
    ///  checks if `_to` is a smart contract (code size > 0). If so, it calls
    ///  `onERC721Received` on `_to` and throws if the return value is not
    ///  `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
    /// @param _from The current owner of the NFT
    /// @param _to The new owner
    /// @param _tokenId The NFT to transfer
    /// @param data Additional data with no specified format, sent in call to `_to`
    function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;

safeTransferFrom

    Transfers the ownership of an NFT from one address to another address
    /// @dev This works identically to the other function with an extra data parameter,
    ///  except this function just sets data to "".
    /// @param _from The current owner of the NFT
    /// @param _to The new owner
    /// @param _tokenId The NFT to transfer
    function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;

transferFrom

    /// @param _from The current owner of the NFT
    /// @param _to The new owner
    /// @param _tokenId The NFT to transfer
    function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE     ///  TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE THEY MAY BE PERMANENTLY LOST
    /// @dev Throws unless `msg.sender` is the current owner, an authorized
    ///  operator, or the approved address for this NFT. Throws if `_from` is
    ///  not the current owner. Throws if `_to` is the zero address. Throws if
    ///  `_tokenId` is not a valid NFT.

approve

function approve(address _approved, uint256 _tokenId) external payable;
    /// @param _approved The new approved NFT controller
    /// @param _tokenId The NFT to approve

Change or reaffirm the approved address for an NFT. The zero address indicates there is no approved address.
Throws unless `msg.sender` is the current NFT owner, or an authorized operator of the current owner.

setApprovalForAll

function setApprovalForAll(address _operator, bool _approved) external;
    /// @param _operator Address to add to the set of authorized operators
    /// @param _approved True if the operator is approved, false to revoke approval

Enable or disable approval for a third party ("operator") to manage all of `msg.sender`'s assets
Emits the ApprovalForAll event. The contract MUST allow multiple operators per owner.

getApproved

function getApproved(uint256 _tokenId) external view returns (address);
    /// @param _tokenId The NFT to find the approved address for
    /// @return The approved address for this NFT, or the zero address if there is none

Get the approved address for a single NFT. Throws if `_tokenId` is not a valid NFT.

isApprovedForAll

    /// @param _owner The address that owns the NFTs
    /// @param _operator The address that acts on behalf of the owner
    /// @return True if `_operator` is an approved operator for `_owner`, false otherwise
    function isApprovedForAll(address _owner, address _operator) external view returns (bool);

Query if an address is an authorized operator for another address

}

interface ERC165 {
    /// @notice Query if a contract implements an interface
    /// @param interfaceID The interface identifier, as specified in ERC-165
    /// @dev Interface identification is specified in ERC-165. This function
    ///  uses less than 30,000 gas.
    /// @return `true` if the contract implements `interfaceID` and
    ///  `interfaceID` is not 0xffffffff, `false` otherwise
    function supportsInterface(bytes4 interfaceID) external view returns (bool);
}

The metadata extension is OPTIONAL for ERC-721 smart contracts (see “caveats”, below). This allows your smart contract to be interrogated for its name and for details about the assets which your NFTs represent.

ERC721Metadata


/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
/// @dev See https://eips.ethereum.org/EIPS/eip-721
/// Note: the ERC-165 identifier for this interface is 0x5b5e139f.
interface ERC721Metadata /* is ERC721 */ {
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external view returns (string _name);

/// @notice An abbreviated name for NFTs in this contract
function symbol() external view returns (string _symbol);

/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
/// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
/// 3986. The URI may point to a JSON file that conforms to the "ERC721
/// Metadata JSON Schema".
function tokenURI(uint256 _tokenId) external view returns (string);}




Vente

Directe, Open SEA

https://github.com/ProjectOpenSea/opensea-creatures/

Commentaires

Enregistrer un commentaire

Posts les plus consultés de ce blog

Sécurité des Applications

Par -
Introduction à la sécurité Outils pour la sécurité Les outils pour la sécurité recouvrent des notions à peu près identiques quelque soit le domaine de l'informatique que l'on considère. Les catégories développées ici sont présentes dans les trois problématiques traités dans la suite : le code, le réseau et les applications web. Les outils de contrôle d'accès et de filtrage Notions : contrôle d'accès discrétionnaire, ressources informatiques, règles d'accès, chaînage de droits, authentification forte, les trois types d'authentifications, architectures de contrôle d'accès, filtrage des flux. Le contrôle d'accès : c'est permettre à un sujet d'accéder à un système sous certaines conditions et d'effectuer un certain nombre d'opérations sur un objet défini. Ceci doit théoriquement permettre d'envisager tous les situations d'accès possibles mais la multiplication des sujets, des objets et des règles rend une vision globale difficile. Le ...
Lire la suite

Principes de la Programmation Orientée Objet

Par -
Principes Généraux : Objet et Classe Un objet est un concept de programmation qui groupe des fonctionnalités dans une entité, entité qui peut ensuite être créée à la demande. Une classe est l'implémentation d'un objet, c'est-à-dire une unité de code contenant les attributs et fonctions décrivant un objet. Encapsulation L'encapsulation consiste d'une part, à regrouper au sein d'une même entité (la classe), des propriétés et méthodes (les attributs) et d'autre part à définir la visibilité de ces attribvutes (privé, protege...) de façon à présenter une interface permettant de manipuler une classe sans en connaitre le fonctionnement interne. L’encapsulation permet de faire voir l’objet à l’extérieur comme une boîte noire ayant certaines attributs (proriétés et fonctions) et ayant un comportement spécifié. La manière dont ces propriétés ont été implémentées est alors cachée aux utilisateurs de la classe. L’implémentation peut être modifiée sans changer le comport...
Lire la suite

Principe de Responsabilité Unique

Par -
Qu'est-ce qu'une Responsabilité ? Dans le contexte du Principe de Responsabilité Unique (SRP), nous définissons une responsabilité comme "une raison de changement". Si vous pouvez penser à plus d'un motif de modification pour une classe, alors cette classe a plus d'une responsabilité. Développement du Principe de Responsabilité Unique Le Principe de Responsabilité Unique (SRP) est l'un des principes fondamentaux de la conception logicielle, souvent associé au paradigme de la programmation orientée objet. Il stipule qu'une classe ou un module ne devrait avoir qu'une seule raison de changer, ou en d'autres termes, il ne devrait être responsable que d'une seule tâche ou fonctionnalité. Clarification de la Responsabilité Le terme "responsabilité" dans le SRP fait référence aux raisons potentielles pour lesquelles une classe ou un module pourrait nécessiter une modification à l'avenir. Une classe ou un module est considéré comme re...
Lire la suite