# Minting avec Rarible

Rarible est un protocole et une place de marché NFT multichaîne qui fournit des SDK et des API pour créer des applications NFT sur plusieurs réseaux EVM.

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

Comme le SDK Rarible ne gère pas les téléversements IPFS, nos exemples ici utilisent [Pinata](https://pinata.cloud/) comme hôte IPFS. Vous aurez besoin d’un compte Pinata afin d’obtenir une clé JWT.

Ils nécessiteront également que vous ayez :

* 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 permet de le faire dans le navigateur. N’oubliez pas de vérifier le contrat à l’aide d’un explorateur de blocs !
* Une clé API Rarible. Consultez leur guide de démarrage 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 remarquerez que nous utilisons `ethers`, qui est une alternative à `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 de facto.
{% endhint %}

## Minter une collection de NFT

Commencez par créer votre fichier .env :

```
# RPC Chiliz
RPC_URL=https://spicy-rpc.chiliz.com       # ou un RPC mainnet
PRIVATE_KEY=0xabc...                       # clé du minter (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

# Entrées média / métadonnées
IMAGE_PATH=./art/image.png
NAME=My Chiliz NFT
DESCRIPTION=Minté on-chain via le SDK Rarible

```

Notre flux de travail de choix est :

1. Téléverser les médias vers IPFS via Pinata
2. Créer et téléverser le fichier de métadonnées
3. SDK Rarible + mint on-chain

Voici le script d’exemple 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 les médias vers 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}`
  // console.log('imageUri:', imageUri)

  // Créer 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}`
  // console.log('metadataUri:', metadataUri)

  // Mint on-chain via 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 ID Union utilisent "<BLOCKCHAIN>:<address>" — 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('Élément minté :', itemId, 'tx :', hash)
}

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

```

{% endcode %}

## Lazy-minter une collection NFT

Le lazy minting est une option pour ceux qui ne veulent pas supporter le coût initial de mint d’un NFT avant de le mettre en vente. Ils peuvent mettre leur NFT en vente, puis ne le minter qu’au moment où il est acheté ou transféré. Les frais de gas font donc partie du processus de mint et sont payés par l’acheteur.

En bref, le lazy minting consiste à mettre le NFT sur la blockchain uniquement lorsque quelqu’un l’achète, et non avant.

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

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

# 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  # facultatif (pour les aperçus)

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

```

Et maintenant, le code d’exemple 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 les médias vers 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 (élément hors chaîne ; l’acheteur minte 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, rendez-le lazy s’il vous plaît
    creators: [{ account: creator, value: 10000 }], // 100 % vont à votre portefeuille
    royalties: [],                               // par ex. [{ account: creator, value: 500 }] pour 5 %
  })

  // console.log('ID de l’élément lazy :', result.itemId)
}

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

```

{% endcode %}


---

# Agent Instructions: 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:

```
GET https://docs.chiliz.com/fr-ai/develop/advanced/work-with-nfts/minting-with-rarible.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.