
Solana Frames : créer un cNFT sur Farcaster
Quel est le sujet de cet article ?
Les réseaux sociaux décentralisés marquent une évolution majeure en donnant aux utilisateurs davantage de confidentialité et de contrôle sur leurs données en ligne. Contrairement aux plateformes de réseaux sociaux traditionnelles, les réseaux décentralisés permettent à chacun de gérer directement son graphe social et son identité numérique. Des plateformes comme Farcaster ouvrent la voie en créant des réseaux résistants à la censure qui favorisent une communication ouverte et interopérable entre différentes plateformes. L’une des innovations clés de Farcaster est l’introduction des frames, qui transforment de simples publications en applications complètes afin d’enrichir les interactions sociales en ligne.
Cet article présente Farcaster et sa récente prise en charge de Solana. Nous verrons ce qu’est Farcaster, ce que sont les frames et comment vérifier une adresse Solana. Nous suivrons ensuite un court tutoriel pour créer une frame qui génère un cNFT sur l’adresse Solana vérifiée d’un utilisateur à l’aide de l’API Helius Mint. Une expérience préalable avec TypeScript et Next.js est requise pour suivre ce tutoriel.
Qu’est-ce que Farcaster ?
Farcaster est un réseau social suffisamment décentralisé qui s’appuie sur le réseau Ethereum. Il propose une plateforme publique semblable aux réseaux sociaux populaires comme Twitter et Reddit, où les utilisateurs peuvent créer des profils, partager des publications (appelées casts) et suivre d’autres utilisateurs. Farcaster se distingue par l’importance qu’il accorde à la propriété et à la portabilité pour les utilisateurs : ceux-ci possèdent leurs comptes et leurs relations avec les autres. Ils peuvent passer d’une application à une autre tout en conservant leur identité numérique et leur graphe social.
Que sont les frames ?
Les frames permettent aux développeurs de transformer n’importe quel cast en application interactive. En étendant le standard OpenGraph, elles transforment les intégrations statiques en expériences dynamiques et interactives. Les utilisateurs peuvent ainsi créer des fonctionnalités comme des sondages, des flux en direct ou des galeries interactives dans n’importe quel client Farcaster, y compris Warpcaster. Une frame est essentiellement un ensemble de balises <meta> renvoyées avec le <head> d’une page HTML. Les applications Farcaster affichent la page sous forme de frame si elle contient toutes les propriétés requises. La spécification des frames décrit ces propriétés. Par exemple, une frame initiale doit :
- Renvoyer une frame valide dans la section HTML
<head> - Renvoyer un
<body>HTML valide si l’utilisateur ouvre la frame dans un navigateur - Ne pas inclure de contenu dynamique dans la frame initiale, car les clients Farcaster la mettent en cache
- Ne pas inclure de balise
fc:frame:state
Vérifier une adresse Solana sur Farcaster
Farcaster a récemment ajouté la prise en charge des adresses Solana. Les développeurs peuvent donc créer des frames qui interagissent avec le portefeuille Solana d’un utilisateur. Moins de 24 heures après le lancement de cette prise en charge, plus de 9 328 FID Farcaster uniques avaient vérifié une adresse Solana.
Les utilisateurs peuvent vérifier leur adresse Solana en procédant comme suit :
- Accédez aux Paramètres
- Cliquez sur Adresses vérifiées, puis sur le bouton « Vérifier une adresse »
- Connectez votre portefeuille Solana et signez un message pour prouver que vous en êtes propriétaire
Notez que le seul portefeuille actuellement pris en charge est Phantom.
Tutoriel : créer une frame qui génère un cNFT
Dans cet article, nous allons créer une frame qui permet aux utilisateurs disposant d’une adresse Solana vérifiée de générer un NFT compressé (cNFT). Nous initialiserons le projet avec frames.js, un modèle Next.js permettant de créer et de déboguer des frames. Nous utiliserons OnchainKit de Coinbase, et plus précisément Frame Kit, pour récupérer les informations d’un utilisateur Farcaster lorsqu’il interagit avec la frame. Nous transmettrons ensuite ces données à l’API Helius Mint pour générer le cNFT suivant dans le portefeuille Solana de l’utilisateur :
Configurer notre frame
Créer une frame avec frame.js est aussi simple que de cloner le modèle de démarrage. Exécutez simplement la commande suivante, en remplaçant <name> par le nom du nouveau dossier dans lequel vous souhaitez cloner le modèle :
npx degit github:framesjs/frames.js/examples/framesjs-starter#main <name>J’ai choisi de nommer mon répertoire helius-frame. J’ai donc remplacé <name> par <helius-frame>. Accédez ensuite au nouveau répertoire (par exemple, cd helius-frame) et installez les dépendances requises avec la commande yarn install. Une fois le téléchargement terminé, exécutez yarn dev pour lancer le serveur de développement. Ouvrez http://localhost:3000 dans votre navigateur pour afficher ce qui suit :
En cliquant sur le lien hypertexte Debug, nous accédons à http://localhost:3000/debug :
C’est pratique, car nous pouvons tester notre frame localement sans la déployer. Nous pouvons par exemple nous connecter pour tester les boutons, usurper l’identité d’autres utilisateurs et simuler l’état du hub. Warpcaster propose également un excellent outil de validation, Frame Validator. Pour la suite, nous utiliserons Frame Validator pour nos tests, simplement par préférence personnelle.
Exécutez ensuite yarn install pour installer les dépendances nécessaires du modèle. Exécutez également yarn install @coinbase/onchainkit pour installer OnchainKit.
Nous allons réorganiser les dossiers du projet comme suit :
- Supprimez le dossier examples. Les exemples donnent de précieuses indications sur la création de frames, mais ils ne sont pas nécessaires pour notre objectif. Supprimer ce dossier allège le projet. Je vous recommande toutefois vivement de les consulter pour découvrir d’autres méthodes de création de frames courantes
- Créez un dossier api dans le répertoire app. Cette étape respecte les conventions Next.js relatives aux routes API en établissant une distinction claire entre le frontend et le backend de notre application. Déplacez ensuite le dossier frames, avec son contenu — route.ts — dans le nouveau dossier api.
- Créez un dossier utils dans le répertoire app. Dans ce nouveau dossier, créez un fichier mint.ts : nous y placerons la logique de génération du cNFT
Nous pouvons enfin commencer à créer notre frame !
Modifier notre frame
layout.tsx
Commençons par le fichier layout.tsx. Supprimez tout son contenu et remplacez-le par le code suivant :
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
{children}
);
}Le composant RootLayout adopte une approche minimaliste pour envelopper l’ensemble de l’application dans une structure de mise en page cohérente. Il est flexible et conçu pour être réutilisable. En partant de cette mise en page minimaliste, les développeurs peuvent utiliser ce fichier comme modèle pour créer et personnaliser leurs propres frames selon leurs besoins.
Notez qu’en modifiant le fichier layout.tsx, vous rencontrerez des problèmes avec l’utilisation locale du débogueur. Il n’est pas obligatoire de modifier layout.tsx. Nous le faisons toutefois afin d’introduire les métadonnées de l’application dans page.tsx. Pour contourner ce problème, vous pourriez ajouter les métadonnées dans ce fichier.
page.tsx
Supprimez le contenu de page.tsx et remplacez-le par ce qui suit :
import type { Metadata } from "next";
import { getFrameMetadata } from "@coinbase/onchainkit";
const baseURL = "https://helius-frame.vercel.app/";
const frameMetadata = getFrameMetadata({
image: {
src: `${baseURL}/default.jpg`,
aspectRatio: "1:1",
},
buttons: [
{
label: "Click to mint a cNFT on Solana!",
action: "post",
},
],
postUrl: `${baseURL}api/frames`,
});
export const metadata: Metadata = {
title: "Mint a cNFT on Solana",
description: "Mint a cNFT to your verified Solana address using the Helius Mint API",
openGraph: {
title: "Mint a cNFT on Solana",
description: "Mint a cNFT to your verified Solana address using the Helius Mint API",
images: ["https://helius-frame.vercel.app/default.jpg"],
},
other: {
...frameMetadata,
},
};
export default function Page() {
return (
Mint a cNFT on Farcaster using the Helius Mint API
Built by 0xIchigo
GitHub Repo
);
}Le code ci-dessus configure notre frame initiale, qui sera accessible à une URL sur un serveur web. Dans mon cas, la frame initiale est hébergée sur Vercel à l’adresse https://helius-frame.vercel.app/. Nous verrons plus loin dans ce tutoriel comment effectuer un déploiement avec Vercel.
Nous importons d’abord le type Metadata depuis Next.js afin de typer l’export metadata dans ce fichier. Nous importons également getFrameMetadata depuis @coinbase/onchainkit. Nous définissons ensuite l’URL de base de l’application afin d’éviter de répéter le code.
Nous appelons ensuite getFrameMetadata pour configurer les métadonnées de notre frame initiale. Ces métadonnées comprennent :
- Une image (c’est-à-dire src) qui sert d’élément visuel à la frame, avec un format d’image de 1:1
- Un bouton intitulé « Cliquez pour générer un cNFT sur Solana ! » qui, lorsqu’il est activé, déclenche une requête POST vers le
postUrlspécifié (c’est-à-dire${baseURL}api/frames). Cette action lance le processus de génération
Nous exportons ensuite un objet metadata qui comprend le titre et la description de la page, les métadonnées OpenGraph (c’est-à-dire openGraph) et le frameMetadata défini précédemment, décomposé dans la propriété other.
Enfin, page définit et exporte le composant de page par défaut. Nous renvoyons un élément h1 simple qui invite à générer un cNFT. Farcaster nous impose en effet de renvoyer du HTML : l’interaction principale est gérée par les frames plutôt que par un accès direct au site lui-même. Toutefois, si un utilisateur ouvre le site, celui-ci doit tout de même afficher quelque chose.
mint.ts
Collez le code suivant dans mint.ts :
const url = `Get a URL at dev.helius.xyz`;
export const mintCompressedNFT = async (address: string) => {
const response = await fetch(url, {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
jsonrpc: "2.0",
id: "frames-sol-mint",
method: "mintCompressedNft",
params: {
name: "Solana Soldier",
symbol: "HELIUS",
owner: address,
description: "A decentralized warrior backed by Solana's most loved RPC Nodes, APIs, Webhooks, and Developer Tooling",
attributes: [
{
trait_type: "RPCs",
value: "Fast",
},
{
trait_type: "Company",
value: "Helius"
},
],
imageUrl: "https://shdw-drive.genesysgo.net/HmvVwYAy7cxWECLbu2cjWBSHysVoriTqgdugyePVg3rY/cnftmint.jpg",
externalUrl: "https://www.helius.dev/",
sellerFeeBasisPoints: 6900,
},
}),
});
const data = await response.json();
console.log(`data: ${JSON.stringify(data, null, 2)}`);
if (!response.ok) {
throw new Error(`The response was not okay - ${response.status}`);
}
if (!data.result || !data.result.assetId) {
throw new Error(`The response did not include the expected data.result.assetId field`);
}
return data.result;
};La fonction utilitaire mintCompressedNFT est essentielle à notre application, car elle génère un cNFT prédéfini à une adresse donnée. Nous utilisons l’API Helius Mint pour créer une fonction asynchrone, simple et réutilisable qui encapsule le processus de génération du cNFT. Nous devons envoyer une requête à notre URL RPC générale Helius, définie par url. Si vous n’en avez pas encore, accédez à votre tableau de bord Helius pour générer gratuitement une URL RPC à utiliser pour url.
Notez que mon dépôt utilise mon URL SecureRPC. Veillez à ne pas divulguer votre clé API et envisagez d’utiliser un proxy. Vous trouverez une description complète du schéma de la requête ici.
Notez également que j’ai déjà chargé l’image du cNFT sur ShdwDrive, car au moment de la rédaction, Farcaster ne prenait pas encore entièrement en charge les transactions. L’API Helius Mint se charge d’envoyer les métadonnées hors chaîne vers Arweave dès lors qu’un signataire est fourni.
La fonction inclut également une gestion robuste des erreurs afin d’intercepter et de signaler tout problème survenant pendant le processus de génération. Elle consigne aussi les données de la réponse à des fins de débogage.
route.ts
Dans api/frames/route.ts, collez le code suivant :
import { NextRequest, NextResponse} from "next/server";
import { getFrameMessage, getFrameHtmlResponse } from "@coinbase/onchainkit/frame";
import { mintCompressedNFT } from "../../utils/mint";
const baseURL = "https://helius-frame.vercel.app/";
export async function POST(req: NextRequest): Promise {
const body = await req.json();
// Validate the frame message and extract the user ID
const { isValid, message } = await getFrameMessage(body, {
neynarApiKey: "NEYNAR_ONCHAIN_KIT",
});
console.log(JSON.stringify(message, null, 2));
// Make sure they're following us before they can mint the cNFT
if (isValid && !message.following) {
return new NextResponse(getFrameHtmlResponse({
image: {
src: `${baseURL}/error.jpg`,
aspectRatio: "1:1",
},
buttons: [
{
label: "You need to be following to mint! Click to retry",
action: "post",
},
],
postUrl: `${baseURL}api/frames`,
}));
// Make sure they have a verified Solana address
} else if (isValid && message.interactor.verified_addresses.sol_addresses) {
const solanaAddresses = message.interactor.verified_addresses.sol_addresses;
console.log(`SOLANA ADDRESSES: ${solanaAddresses}`);
if (solanaAddresses.length !== 0) {
try {
console.log(`MINTING to ${solanaAddresses[0]}`);
// We take the first address address, in case there's more than one
const mintResult = await mintCompressedNFT(solanaAddresses[0]!);
return new NextResponse(getFrameHtmlResponse({
image: {
src: `${baseURL}/success.jpg`,
aspectRatio: "1:1",
},
buttons: [
{
label: "Success! View your cNFT on XRAY",
action: "link",
target: `https://xray.helius.xyz/token/${mintResult.assetId}?network=mainnet`
},
],
}));
} catch (e: any) {
console.log(`Minting failed: ${e}`);
return new NextResponse(getFrameHtmlResponse({
image: {
src: `${baseURL}/error.jpg`,
aspectRatio: "1:1",
},
buttons: [
{
label: "Minting failed. Click to retry",
action: "post",
},
],
postUrl: `${baseURL}api/frames`,
}));
}
} else {
console.log(`No Solana address found`);
return new NextResponse(getFrameHtmlResponse({
image: {
src: `${baseURL}/error.jpg`,
aspectRatio: "1:1",
},
buttons: [
{
label: "No Solana address found. Click to retry",
action: "post",
},
],
postUrl: `${baseURL}api/frames`
}));
}
} else {
return new NextResponse(getFrameHtmlResponse({
image: {
src: `${baseURL}/error.jpg`,
aspectRatio: "1:1",
},
buttons: [
{
label: "Invalid frame message. Click to retry",
action: "post",
},
],
postUrl: `${baseURL}api/frames`,
}));
}
}Ce fichier est une route API Next.js qui traite toutes les requêtes POST destinées à notre frame. Il commence par importer NextRequest et NextResponse depuis next/server afin de traiter les requêtes entrantes et d’envoyer les réponses. Nous importons également getFrameMessage et getFrameHtmlResponse depuis @coinbase/onchainkit/frame pour valider les messages des frames et générer des réponses HTML aux interactions avec celles-ci. Enfin, nous importons notre fonction utilitaire mintCompressedNFT.
baseURL est défini afin de réduire les répétitions de code. Il sert à construire les chemins des ressources et des endpoints API.
Le fichier exporte la fonction POST, qui analyse le corps de la requête entrante afin d’en extraire le message de la frame. Nous utilisons getFrameMessage pour vérifier la validité de l’interaction entrante avec la frame et de la charge utile du message. Pour cela, nous lui transmettons le corps de la requête au format JSON et la clé API Neynar par défaut (c’est-à-dire « NEYNAR_ONCHAIN_KIT »). Neynar est une plateforme destinée aux développeurs qui vise à simplifier le développement sur Farcaster. getFrameMessage renvoie une Promise qui se résout en FrameValidationResponse. Sa définition est la suivante :
export type FrameValidationResponse =
| { isValid: true; message: FrameValidationData }
| { isValid: false; message: undefined };Ainsi, si l’interaction avec la frame est valide, la fonction renvoie le message de type FrameValidationData. Sa définition est la suivante :
export interface FrameValidationData {
button: number; // Number of the button clicked
following: boolean; // Indicates if the viewer clicking the frame follows the cast author
input: string; // Text input from the viewer typing in the frame
interactor: {
fid: number; // Viewer Farcaster ID
custody_address: string; // Viewer custody address
verified_accounts: string[]; // Viewer account addresses
verified_addresses: {
eth_addresses: string[] | null;
sol_addresses: string[] | null;
};
};
liked: boolean; // Indicates if the viewer clicking the frame liked the cast
raw: NeynarFrameValidationInternalModel;
recasted: boolean; // Indicates if the viewer clicking the frame recasted the cast
valid: boolean; // Indicates if the frame is valid
}Ces informations sont précieuses, car elles comprennent des données pertinentes comme l’identifiant Farcaster de l’utilisateur, l’existence éventuelle d’adresses Ethereum ou Solana vérifiées et le fait qu’il ait ou non aimé le cast. Dans ce tutoriel, nous voulons vérifier si l’utilisateur qui tente de générer le cNFT suit mon profil. Si c’est le cas, nous l’autoriserons à le générer. Nous voulons également nous assurer qu’il dispose d’une adresse Solana vérifiée sur laquelle nous pouvons générer le cNFT.
Nous vérifions d’abord que l’interaction est valide et que l’utilisateur suit mon compte. Dans le cas contraire, un message d’erreur et un bouton l’invitant à réessayer s’affichent. Nous vérifions ensuite si l’utilisateur dispose d’une adresse Solana vérifiée. Si une ou plusieurs adresses sont présentes, nous lançons le processus de génération. Nous prenons la première adresse Solana vérifiée et la transmettons à mintCompressedNFT. En cas de réussite, nous renvoyons une image de confirmation et un lien permettant d’afficher le cNFT sur Orb. En cas d’échec, nous consignons l’erreur et répondons par un message invitant l’utilisateur à réessayer. Si aucune adresse Solana vérifiée n’est trouvée, nous répondons par un message d’erreur signalant l’absence d’adresse Solana vérifiée et invitons l’utilisateur à réessayer. Enfin, si le message de la frame n’est pas valide, nous répondons par un message signalant cette erreur et invitons l’utilisateur à réessayer.
Le code utilise getFrameHtmlResponse pour générer des réponses HTML adaptées aux différents résultats du processus de génération ou des contrôles de validation. Cela comprend la définition des images, des formats d’image et des boutons des réponses pour des interactions utilisateur spécifiques.
Passer en production
Une fois le code terminé, créez un nouveau dépôt GitHub et envoyez-y le code. Exécutez les commandes suivantes dans votre ligne de commande pour envoyer le code vers GitHub :
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/<username>/<new repo name>.git
git branch -M main
git push -u origin mainAprès avoir envoyé le code vers GitHub, l’étape suivante consiste à déployer l’application. Vercel propose une intégration fluide avec GitHub qui simplifie tout le processus de déploiement. Nous allons donc l’utiliser. Pour continuer :
- Connectez-vous à votre compte sur le site web de Vercel. Si vous n’en avez pas, vous devrez en créer un. Vercel propose une offre Hobby généreuse, c’est-à-dire gratuite, qui suffira à nos besoins
- Une fois connecté, accédez au tableau de bord et cliquez sur le bouton Nouveau projet. Vercel vous invitera à importer un projet depuis votre compte GitHub. Sélectionnez le dépôt que vous venez de créer à l’étape précédente
- Vercel détectera automatiquement le framework utilisé et proposera des paramètres de build. Vercel a été créé par les créateurs de Next.js et offre une prise en charge de premier ordre. Vous n’avez donc pas à vous soucier d’une configuration laborieuse
- Après avoir configuré les paramètres du projet, cliquez sur le bouton Déployer. Vercel lancera automatiquement le processus, puis construira et déploiera le projet vers une URL Vercel unique.
- Une fois le déploiement terminé, Vercel vous fournira cette URL unique pour accéder à l’application en ligne. Mon projet a été déployé sur https://helius-frame.vercel.app/ : le nom du dépôt GitHub suivi de .vercel.app. Vercel permet également de configurer des domaines personnalisés dans les paramètres du projet
Et voilà ! En suivant ces étapes, nous avons envoyé notre frame Farcaster vers GitHub et l’avons hébergée sur Vercel. Vous pouvez tester son fonctionnement à l’aide des outils mentionnés précédemment, comme le validateur de frames. Il ne reste plus qu’à publier un cast avec l’URL de la frame !
Conclusion
La convergence de la blockchain et des réseaux sociaux représente une avancée majeure dans notre manière de concevoir les espaces numériques et d’y interagir. La popularité de Farcaster et des frames transforme les publications autrefois statiques des plateformes de réseaux sociaux traditionnelles en expériences interactives. Cet article présente Farcaster et les frames. Le tutoriel proposé constitue une introduction à l’utilisation de la récente prise en charge de Solana par Farcaster pour permettre aux utilisateurs de générer des cNFT en un seul clic. Que vous soyez un développeur souhaitant créer une application sur Farcaster ou que vous cherchiez une nouvelle façon stimulante de parcourir votre fil d’actualité, les possibilités sont infinies.
Si vous avez lu jusqu’ici, merci, anon ! Si vous souhaitez rejoindre Farcaster, utilisez le lien d’invitation suivant !
N’oubliez pas de saisir votre adresse e-mail ci-dessous pour ne manquer aucune nouveauté sur Solana. Vous souhaitez aller plus loin ? Découvrez les derniers articles du blog Helius et poursuivez dès aujourd’hui votre parcours avec Solana.
Ressources supplémentaires
Articles associés
Abonnez-vous à Helius
Suivez les dernières actualités du développement sur Solana et recevez une notification à chaque publication


