Minter avec Rarible

Mintez des NFTs sur Chiliz Chain en utilisant le Rarible Multichain SDK avec l'hébergement IPFS Pinata et un contrat OpenZeppelin ERC-721 déployé, y compris la création d'ordres de vente.

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 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 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 sur Chiliz Chain. Remix IDE 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 :

Getting StartedRarible

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

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

Vous noterez que nous utilisons ethers, qui est une alternative au viem que nous avons utilisé dans d'autres sections. En effet, Rarible recommande aux développeurs d'utiliser ethers.js ou web3.js pour travailler avec les portefeuilles Web3 — et web3.js a été abandonné en mars 2025, ne laissant que ethers comme choix par défaut.

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 :

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

Voici le script complet dont vous pouvez vous inspirer :

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)))

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 :

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)))

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?