> For the complete documentation index, see [llms.txt](https://docs.chiliz.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.chiliz.com/fr/developper/notions-avancees/travailler-avec-les-nfts/minter-avec-rarible.md).

# Minter avec Rarible

Rarible est un protocole et marketplace NFT multi-chaînes qui fournit des SDKs et des APIs pour créer des applications NFT sur plusieurs réseaux EVM.

Pour le minting de NFTs, le [Rarible Multichain SDK](https://docs.rarible.org/reference/getting-started) vous permet de minter dans vos propres collections ou des collections partagées et de créer immédiatement des ordres de vente.

Étant donné que le SDK Rarible ne gère pas le téléversement IPFS, nos exemples ici utilisent [Pinata](https://pinata.cloud/) comme hébergeur IPFS. Vous aurez besoin d'un compte Pinata pour obtenir une clé JWT.

Ils nécessiteront également que vous disposiez de :

* Un contrat ERC-721 déjà déployé sur Chiliz Chain. Vous devez déployer vous-même un [contrat OpenZeppelin ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol) sur Chiliz Chain. [Remix IDE](https://remix.ethereum.org/) vous offre un IDE dans le navigateur pour le faire. N'oubliez pas de vérifier le contrat en utilisant un explorateur de blocs !
* Une clé API Rarible. Consultez leur Getting Started pour savoir comment en obtenir une :

{% embed url="<https://docs.rarible.org/docs/rarible-protocol>" %}

Pour utiliser le SDK Rarible, nous avons besoin de quelques installations :

```bash
npm i @rarible/sdk @rarible/types ethers dotenv pinata
```

{% hint style="warning" %}
Vous noterez que nous utilisons `ethers`, qui est une alternative au `viem` que nous avons utilisé dans d'autres sections.\
En effet, [Rarible recommande](https://docs.rarible.org/reference/getting-started#interacting-with-evm-wallets) aux développeurs d'utiliser ethers.js ou web3.js pour travailler avec les portefeuilles Web3 — et [web3.js](https://web3js.org/#/) [a été abandonné en mars 2025](https://blog.chainsafe.io/web3-js-sunset/), ne laissant que `ethers` comme choix par défaut.
{% endhint %}

## Minter une collection de NFTs

Commencez par construire votre fichier .env :

```
# Chiliz RPC
RPC_URL=https://spicy-rpc.chiliz.com       # ou un RPC Mainnet
PRIVATE_KEY=0xabc...                       # clé du minteur (côté SERVEUR UNIQUEMENT)

# Rarible
RARIBLE_API_KEY=your_rarible_api_key
COLLECTION_ADDRESS=0xYourCollectionOnChiliz
SUPPLY=1                                   # 1 = ERC-721, >1 = ERC-1155

# Pinata
PINATA_JWT=eyJhbGciOi...                   # JWT Pinata depuis le tableau de bord
PINATA_GATEWAY=your-subdomain.mypinata.cloud

# Médias / métadonnées
IMAGE_PATH=./art/image.png
NAME=My Chiliz NFT
DESCRIPTION=Minted on-chain via Rarible SDK

```

Notre flux de travail préféré est :

1. Téléverser le média sur IPFS via Pinata
2. Construire et téléverser le fichier de métadonnées
3. SDK Rarible + mint on-chain

Voici le script complet dont vous pouvez vous inspirer :

{% code overflow="wrap" lineNumbers="true" fullWidth="true" %}

```bash
import 'dotenv/config'
import fs from 'fs'
import path from 'path'
import { Wallet, JsonRpcProvider } from 'ethers'
import { createRaribleSdk } from '@rarible/sdk'
import { toCollectionId, toUnionAddress } from '@rarible/types'
import { PinataSDK } from 'pinata'

function guessMime(p: string) {
  const ext = path.extname(p).toLowerCase()
  if (ext === '.png') return 'image/png'
  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg'
  if (ext === '.webp') return 'image/webp'
  if (ext === '.gif') return 'image/gif'
  if (ext === '.mp4') return 'video/mp4'
  if (ext === '.webm') return 'video/webm'
  return 'application/octet-stream'
}

async function main() {
  // Téléverser le média sur IPFS
  const pinata = new PinataSDK({
    pinataJwt: process.env.PINATA_JWT!,
  })

  const mediaPath = process.env.IMAGE_PATH!
  const mediaBlob = new Blob([fs.readFileSync(mediaPath)], { type: guessMime(mediaPath) })
  const mediaFile = new File([mediaBlob], path.basename(mediaPath), { type: guessMime(mediaPath) })

  const mediaUpload = await pinata.upload.public.file(mediaFile)
  const imageUri = `ipfs://${mediaUpload.cid}`

  // Construire et téléverser le fichier de métadonnées
  const metadata = {
    name: process.env.NAME!,
    description: process.env.DESCRIPTION!,
    image: imageUri,
    // animation_url: "ipfs://<cid>/video.mp4",
    // attributes: [{ trait_type: "Tier", value: "Gold" }],
  }
  const metaUpload = await pinata.upload.public.json(metadata)
  const metadataUri = `ipfs://${metaUpload.cid}`

  // Mint on-chain Rarible
  const provider = new JsonRpcProvider(process.env.RPC_URL!)
  const wallet = new Wallet(process.env.PRIVATE_KEY!, provider)
  const sdk = createRaribleSdk(wallet, 'prod', { apiKey: process.env.RARIBLE_API_KEY! })

  // Les IDs Union utilisent "<BLOCKCHAIN>:<adresse>" — ici BLOCKCHAIN est "CHILIZ"
  const collectionId = toCollectionId(`CHILIZ:${process.env.COLLECTION_ADDRESS}`)
  const creator = toUnionAddress(`CHILIZ:${wallet.address}`)

  const { transaction, itemId } = await sdk.nft.mint({
    collectionId,
    uri: metadataUri,
    supply: Number(process.env.SUPPLY || 1), // 1 pour 721, >1 pour 1155
  })

  const { hash } = await transaction.wait()
  console.log('Minted item:', itemId, 'tx:', hash)
}

main().catch((e) => (console.error(e), process.exit(1)))

```

{% endcode %}

## Lazy-minter une collection de NFTs

Le Lazy Minting est une option pour ceux qui ne souhaitent pas payer le coût initial du minting d'un NFT avant de le mettre en vente. Ils peuvent lister leur NFT pour achat, puis le minter uniquement lorsqu'il est acheté ou transféré. Les frais de gas font donc partie du processus de minting, et sont payés par l'acheteur.

En bref, le lazy-minting signifie mettre le NFT sur la blockchain uniquement lorsque quelqu'un achète le NFT, pas avant.

Vous aurez besoin d'un fichier .env correctement défini :

```
# Chiliz RPC / portefeuille
RPC_URL=https://spicy-rpc.chiliz.com
PRIVATE_KEY=0xabc...                         # clé du créateur (garder secret)

# Rarible
RARIBLE_API_KEY=your_rarible_api_key
COLLECTION_ADDRESS=0xYourCollectionOnChiliz   # ERC-721 ou ERC-1155

# Pinata
PINATA_JWT=eyJhbGciOi...                      # JWT Pinata depuis le tableau de bord
PINATA_GATEWAY=your-subdomain.mypinata.cloud  # optionnel (pour les aperçus)

# Médias / métadonnées
IMAGE_PATH=./art/image.png
NAME=My Chiliz NFT
DESCRIPTION=Lazy-minted on Rarible (Chiliz)
SUPPLY=1                                      # 1 pour 721; >1 pour des éditions 1155

```

Et maintenant l'exemple de code pour lazy-minter votre projet :

{% code overflow="wrap" lineNumbers="true" fullWidth="true" %}

```typescript
import 'dotenv/config'
import fs from 'fs'
import path from 'path'
import { Wallet, JsonRpcProvider } from 'ethers'
import { createRaribleSdk } from '@rarible/sdk'
import { toCollectionId, toUnionAddress } from '@rarible/types'
import { PinataSDK } from 'pinata'

function guessMime(p: string) {
  const ext = path.extname(p).toLowerCase()
  if (ext === '.png') return 'image/png'
  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg'
  if (ext === '.webp') return 'image/webp'
  if (ext === '.gif') return 'image/gif'
  if (ext === '.mp4') return 'video/mp4'
  if (ext === '.webm') return 'video/webm'
  return 'application/octet-stream'
}

async function main() {
  // Téléverser le média sur IPFS
  const pinata = new PinataSDK({
    pinataJwt: process.env.PINATA_JWT!,
  })

  const mediaPath = process.env.IMAGE_PATH!
  const mediaBlob = new Blob([fs.readFileSync(mediaPath)], { type: guessMime(mediaPath) })
  const mediaFile = new File([mediaBlob], path.basename(mediaPath), { type: guessMime(mediaPath) })
  const mediaUp = await pinata.upload.public.file(mediaFile)
  const imageUri = `ipfs://${mediaUp.cid}`

  const metadata = {
    name: process.env.NAME!,
    description: process.env.DESCRIPTION!,
    image: imageUri,
    // animation_url: "ipfs://<cid>/video.mp4",
    // attributes: [{ trait_type: "Tier", value: "Gold" }],
  }
  const metaUp = await pinata.upload.public.json(metadata)
  const metadataUri = `ipfs://${metaUp.cid}`

  // Lazy mint Rarible
  const provider = new JsonRpcProvider(process.env.RPC_URL!)
  const wallet = new Wallet(process.env.PRIVATE_KEY!, provider)
  const sdk = createRaribleSdk(wallet, 'prod', { apiKey: process.env.RARIBLE_API_KEY! })
  const collectionId = toCollectionId(`CHILIZ:${process.env.COLLECTION_ADDRESS}`)
  const creator = toUnionAddress(`CHILIZ:${wallet.address}`)

  // Préparer et soumettre le lazy mint (objet off-chain ; l'acheteur mint lors de l'achat)
  const prepared = await sdk.nft.mint.prepare({ collectionId })
  const result = await prepared.submit({
    uri: metadataUri,
    supply: Number(process.env.SUPPLY || 1),     // 1 pour 721; >1 pour 1155
    lazyMint: true,                              // Oui, le rendre lazy s'il vous plaît
    creators: [{ account: creator, value: 10000 }], // 100% vont à votre portefeuille
    royalties: [],                               // ex. [{ account: creator, value: 500 }] pour 5%
  })
}

main().catch((e) => (console.error(e), process.exit(1)))

```

{% endcode %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.chiliz.com/fr/developper/notions-avancees/travailler-avec-les-nfts/minter-avec-rarible.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.