# Bridge de Chiliz Chain vers Solana

Pour relier un jeton existant de Chiliz Chain à Solana, vous devez écrire et déployer deux contrats intelligents distincts : un OFT Adapter sur la chaîne où le jeton existe déjà (Chiliz Chain), et un Native OFT sur la chaîne de destination (Solana).

*Notez que LayerZero propose son propre QuickStart pour les contrats OFT :*

{% embed url="<https://docs.layerzero.network/v2/developers/evm/oft/quickstart>" %}

## Prérequis

{% hint style="info" %}
Le pont entre Chiliz Chain (EVM) et Solana (Non-EVM) nécessite un développement sur double pile.\
Vous devrez mettre en place des environnements et des portefeuilles pour les deux écosystèmes.

Vous aurez donc besoin des environnements suivants :

* Pour les interactions avec Chiliz Chain : Node/npx et Hardhat.
* Pour les interactions avec Solana : [Rustup](https://rustup.rs/) (les contrats intelligents Solana utilisent le langage de programmation Rust), [Solana CLI et le framework Anchor](https://solana.com/docs/intro/installation) , et [le SDK Solana de LayerZero](https://docs.layerzero.network/v2/tools/sdks/solana-sdk).
  {% endhint %}

Ce guide nécessite ce qui suit :

* Une adresse de contrat de jeton sur Chiliz Chain. Vous n’avez pas besoin d’en être propriétaire.
* Un portefeuille Web3 pour chaque chaîne (MetaMask ne prend pas en charge les chaînes non EVM) :
  * Pour Chiliz Chain : portefeuille MetaMask avec [la configuration RPC de Chiliz Chain](/fr-ai/develop/basics/connect-to-chiliz-chain/connect-using-rpc.md).
  * Pour Solana : [Solflare](https://www.solflare.com/) portefeuille avec [configuration de Solana Mainnet](https://solana.com/docs/references/clusters). Voici [leur guide de configuration](https://www.solflare.com/guides/how-to-set-up-your-first-crypto-wallet-with-solflare-step-by-step/).
* Assez de jetons de gaz sur chaque chaîne pour payer les déploiements des contrats ainsi que les frais de gaz pour l’envoi des messages.
  * Sur Chiliz Chain : des jetons CHZ.
  * Sur Solana : des jetons SOL.

## Étape 1 : développement du contrat

{% hint style="info" %}
**Le défi des « Shared Decimals »**

Parce que Solana gère les mathématiques des jetons différemment de la Machine Virtuelle Ethereum (EVM), nous devons gérer correctement les décimales :

* Chiliz Chain (EVM) : les jetons ERC-20 standard ont généralement 18 décimales de précision.
* Solana : les jetons SPL natifs ont généralement 9 décimales de précision.

Si vous envoyez $$ $1 \times 10^{18}$ $$ unités de Chiliz vers Solana, le contrat Solana interpréterait mal le montant, ce qui entraînerait une inflation massive du jeton sur la chaîne de destination.

Pour normaliser les calculs, LayerZero utilise une configuration `sharedDecimals` . Par défaut, le standard OFT LayerZero V2 définit `sharedDecimals` à 6.

* Lorsqu’un utilisateur transfère 1,00 jeton de Chiliz, l’Adapter supprime les 12 décimales les plus basses (en les traitant comme de la « poussière ») pour réduire le nombre à 6 décimales.
* Le message est envoyé à travers le pont.
* Le programme Solana reçoit le nombre à 6 décimales et le met à l’échelle *vers le haut* jusqu’à ses 9 décimales locales avant de frapper les jetons.

[En savoir plus ici](https://docs.layerzero.network/v2/faq#what-is-shareddecimals-can-i-override-default-shareddecimals-in-an-oft-contract).
{% endhint %}

### Préparation de l’ `OFTAdapter` sur Chiliz Chain

{% hint style="warning" %}
Il s’agit d’une étape préparatoire, ne le déployez pas tout de suite !\
Vous le déploierez à l’étape 3.
{% endhint %}

Le `OFTAdapter` le contrat agit comme un coffre-fort pour votre jeton existant. Lorsque des utilisateurs transfèrent leurs jetons hors de Chiliz Chain, ce contrat verrouille les jetons ERC20 d’origine.

{% hint style="info" %}
Parce que les `OFTAdapter` définit `sharedDecimals` de LayerZero est à 6 par défaut, vous pouvez utiliser l’implémentation standard. Si vous devez un jour modifier cela (par exemple, à 8), vous remplaceriez la `sharedDecimals()` fonction.
{% endhint %}

Créez un nouveau fichier nommé `ChilizTokenAdapter.sol` dans votre dossier contracts :

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import { OFTAdapter } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oft/OFTAdapter.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

contract ChilizSolanaAdapter is OFTAdapter {
    constructor(
        address _token,      // L’adresse de votre jeton EXISTANT sur Chiliz Chain (18 décimales)
        address _lzEndpoint, // L’adresse du endpoint LayerZero V2 sur Chiliz
        address _delegate    // L’adresse capable d’effectuer des changements de configuration (généralement votre portefeuille)
    ) OFTAdapter(_token, _lzEndpoint, _delegate) Ownable(_delegate) {}
}
```

{% hint style="info" %}
Comme vous pouvez le voir, ce contrat étend le [contrat LayerZero OFT Adapter](https://github.com/LayerZero-Labs/LayerZero-v2/blob/main/packages/layerzero-v2/evm/oapp/contracts/oft/OFTAdapter.sol), ainsi qu’un contrat standard `Ownable.sol` pour attribuer les clés d’administration. Vous avez besoin des deux afin que vous seul puissiez relier les chaînes en toute sécurité.
{% endhint %}

### Préparation et déploiement du `OFT` sur Solana

Contrairement à Chiliz Chain, Solana n’utilise pas la Machine Virtuelle Ethereum (EVM) ni le langage Solidity. Les contrats intelligents Solana (appelés « Programs ») sont écrits en [Rust](https://rust-lang.org/).

Pour relier votre jeton, vous devez déployer un programme OFT sur Solana. Lorsque ce programme reçoit un message vérifié de votre OFTAdapter déployé sur Chiliz, il frappera le jeton SPL correspondant dans le portefeuille Solana de l’utilisateur.

{% embed url="<https://docs.layerzero.network/v2/developers/solana/oft/overview>" %}

LayerZero fournit un [exemple Anchor prêt à l’emploi](https://github.com/LayerZero-Labs/devtools/tree/main/examples/oft-solana) afin que vous n’ayez pas à écrire la logique de pont en Rust à partir de zéro.

#### 1. Clonez l’exemple LayerZero OFT Solana :

```bash
git clone https://github.com/LayerZero-Labs/devtools.git
cd devtools/examples/oft-solana
npm install
```

#### 2. Compilez le programme Rust

Cela générera également votre identifiant unique de programme Solana (équivalent à une adresse de contrat dans l’EVM) :

```bash
anchor build
```

Une fois la compilation terminée, Anchor générera une nouvelle paire de clés dans `target/deploy/oft_solana-keypair.json`.\
Vous pouvez récupérer votre nouvel identifiant de programme en exécutant :

```bash
anchor keys list
```

#### 3. Déployez sur Solana Mainnet

Assurez-vous que votre CLI Solana est configurée pour Mainnet et que votre portefeuille local dispose de suffisamment de $SOL pour le déploiement et le loyer de stockage.\
N’oubliez pas de mettre à jour la `Anchor.toml` et la macro `lib.rs` macro declare\_id! avec ce nouvel identifiant de programme avant de déployer.

```bash
solana config set --url mainnet-beta
anchor deploy
```

#### 4. Initialisez l’OFT et le Mint SPL

Sur Solana, la logique d’un jeton et son registre sont séparés. Vous devez initialiser un nouveau compte Mint (le jeton SPL) et attribuer votre programme OFT nouvellement déployé comme autorité de Mint. Cela garantit que seul le pont LayerZero peut frapper de nouveaux jetons sur Solana.

Le SDK LayerZero fournit des tâches Hardhat/TypeScript pour gérer cette initialisation directement depuis la ligne de commande. Dans votre `oft-solana` projet, configurez votre Endpoint LayerZero pour Solana (`30168`) et exécutez le script d’initialisation :

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

```bash
npx hardhat lz:oft-solana:init --program-id <YOUR_NEW_PROGRAM_ID> --mint-decimals 9 --shared-decimals 6
```

{% endcode %}

{% hint style="info" %}
Paramètres cruciaux :

* `--mint-decimals 9`: Définit la précision standard du jeton SPL sur Solana.
* `--shared-decimals 6`: Doit correspondre aux décimales partagées que vous avez configurées (ou à la valeur par défaut) sur votre Chiliz Chain `OFTAdapter`. C’est ce qui garantit que 1 jeton Chiliz = 1 jeton Solana.
  {% endhint %}

Une fois que cette transaction d’initialisation est confirmée sur la blockchain Solana, votre programme OFT natif est entièrement configuré et prêt à être relié à l’OFTAdapter Chiliz !

## Étape 2 : configuration LayerZero

Avec votre Adapter Chiliz déployé et votre programme OFT Solana initialisé, vous devez maintenant configurer leur connexion. C’est là que la différence entre les réseaux EVM et non EVM devient très visible.

{% hint style="info" %}
Format des adresses :

* Chiliz Chain (EVM) : utilise des adresses hexadécimales standard de 20 octets (par exemple, `0x123...`).
* Solana : utilise des adresses encodées en Base58 (par exemple, `YourProgramId111111111111111111111111111111`).
  {% endhint %}

La messagerie inter-chaînes de LayerZero exige que toutes les [adresses de pairs](https://docs.layerzero.network/v2/concepts/glossary#peer) soient formatées en `bytes32`. Heureusement, l’outillage Hardhat LayerZero V2 gère automatiquement la conversion de Base58 vers Bytes32 pour vous, tant que vous définissez correctement les endpoints dans votre configuration.

Le [Générateur de configuration simple](https://docs.layerzero.network/v2/tools/simple-config) est la méthode recommandée pour générer la configuration de câblage, car il automatise le câblage bidirectionnel et applique en coulisses les configurations de sécurité recommandées.

Créez ou mettez à jour votre fichier `layerzero.config.ts` à la racine de votre projet Hardhat :

{% code lineNumbers="true" %}

```typescript
import { ExecutorOptionType } from '@layerzerolabs/lz-v2-utilities';
import { OAppEnforcedOption, OmniPointHardhat } from '@layerzerolabs/toolbox-hardhat';
import { EndpointId } from '@layerzerolabs/lz-definitions';
import { generateConnectionsConfig } from '@layerzerolabs/metadata-tools';

// Définir les contrats
const chilizContract: OmniPointHardhat = {
    eid: EndpointId.CHILIZ_V2_MAINNET,
    contractName: 'ChilizSolanaAdapter', // Nom de votre déploiement Hardhat sur EVM
};

const solanaContract: OmniPointHardhat = {
    eid: EndpointId.SOLANA_V2_MAINNET,
    address: 'YourSolanaProgramIdHereInBase58', // Format d’adresse Base58 pour Solana
};

// Définir les options d’exécution pour Solana (Compute Units et Lamports)
const SOLANA_ENFORCED_OPTIONS: OAppEnforcedOption[] = [
    {
        msgType: 1,
        optionType: ExecutorOptionType.LZ_RECEIVE,
        gas: 200000,    // Compute Units Solana nécessaires pour l’exécution sur la destination
        value: 2500000, // Lamports pour couvrir les frais potentiels de loyer de création ATA
    },
];

// Définir les options d’exécution pour le retour vers Chiliz (gas EVM)
const EVM_ENFORCED_OPTIONS: OAppEnforcedOption[] = [
    {
        msgType: 1, 
        optionType: ExecutorOptionType.LZ_RECEIVE,
        gas: 200000, // Unités de gas EVM standard pour débloquer des jetons sur Chiliz
        value: 0,
    },
];

// Exporter la configuration générée
export default async function () {
    return {
        contracts: [
            { contract: chilizContract },
            { contract: solanaContract },
        ],
        connections: await generateConnectionsConfig([
            [
                chilizContract, 
                solanaContract,
                [['LayerZero Labs'], []], 
                [1, 1], 
                [SOLANA_ENFORCED_OPTIONS, EVM_ENFORCED_OPTIONS], // Options [Vers Solana SVM, Vers Chiliz EVM]
            ],
        ]),
    };
}
```

{% endcode %}

La tâche d’assemblage LayerZero lira cela, décodera la chaîne Base58, la complétera à 32 octets et la transmettra en toute sécurité à l’ `setPeer` fonction.

## Étape 3 : flux de déploiement

Avec vos contrats écrits et votre `layerzero.config.ts` préparé, il est temps de déployer l’OFTAdapter Chiliz. Comme vous avez déjà construit et déployé le programme OFT natif Solana à l’aide d’Anchor à l’étape 1, cette étape se concentre sur le déploiement de la partie EVM du pont à l’aide de Hardhat.

### **Déploiement du contrat Chiliz OFTAdapter**

Dans votre projet Hardhat, créez un script de déploiement dans votre répertoire `deploy/` nommé `01_deploy_chiliz_solana_adapter.ts`. Ce script transmet l’adresse de votre jeton existant et l’adresse Chiliz Endpoint V2 (EID) au constructeur.

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

```typescript
import { DeployFunction } from 'hardhat-deploy/types';

const deployAdapter: DeployFunction = async ({ getNamedAccounts, deployments }) => {
    const { deploy } = deployments;
    const { deployer } = await getNamedAccounts();

    // L’adresse de votre jeton ERC-20 existant sur Chiliz (18 décimales)
    const TOKEN_ADDRESS = "0xYourTokenAddressHere"; 
    
    // L’adresse de l’endpoint Mainnet V2 Chiliz
    const CHILIZ_ENDPOINT_V2 = "0x6F475642a6e85809B1c36Fa62763669b1b48DD5B";

    console.log("Déploiement de l’OFTAdapter sur Chiliz Mainnet...");

    await deploy('ChilizSolanaAdapter', {
        from: deployer,
        args: [
            TOKEN_ADDRESS,       // _token
            CHILIZ_ENDPOINT_V2,  // _lzEndpoint
            deployer             // _delegate (propriétaire)
        ],
        log: true,
        waitConfirmations: 2,
    });
};

export default deployAdapter;
deployAdapter.tags = ['ChilizSolanaAdapter'];
```

{% endcode %}

### **Déploiement de l’OFTAdapter Chiliz**

{% hint style="info" %}
Avant de continuer, assurez-vous que :

* vous avez copié l’identifiant de programme Base58 obtenu dans votre `layerzero.config.ts` .
* votre `hardhat.config.ts` a l’URL RPC et la clé privée correctement configurées pour le réseau principal Chiliz Chain.
  {% endhint %}

Exécutez la commande suivante dans votre terminal pour déployer l’Adapter EVM :

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

```bash
npx hardhat deploy --network chiliz --tags ChilizSolanaAdapter
```

{% endcode %}

Une fois le déploiement terminé, Hardhat enregistrera l’adresse du contrat Chiliz dans le `deployments/` dossier.

À ce stade, vous avez des contrats actifs à la fois sur Chiliz Chain (EVM) et Solana (SVM), mais ils ne se font pas encore confiance. Il est temps de les faire se rencontrer !

## Étape 4 : câblage et pairage

Pour permettre à votre contrat OFTAdapter et à votre programme OFT de communiquer, vous devez les « câbler » ensemble en tant que pairs de confiance.

Parce que nous faisons le pont entre deux Machines Virtuelles totalement différentes (EVM et SVM), la configuration exige une attention particulière.

{% hint style="info" %}
**gas EVM vs Compute Units Solana**

Lorsqu’un utilisateur transfère un jeton de Chiliz Chain vers une autre chaîne EVM (comme Base), l’Executor LayerZero a besoin de gas EVM pour appeler `lzReceive`.

Cependant, lors d’un transfert de Chiliz Chain vers Solana, la chaîne de destination n’utilise pas de gas EVM. [Elle utilise des Compute Units et des Lamports (fractions de $SOL)](https://solana.com/docs/core/fees).\
De plus, si un utilisateur transfère des jetons vers un portefeuille Solana qui ne détient pas encore votre jeton, l’Executor doit payer les frais de « rent exemption » de Solana pour créer un Compte de Jeton Associé (ATA) pour lui. Cela nécessite de dépenser de la valeur réelle en $SOL sur la destination.
{% endhint %}

Pour garantir que l’Executor dispose de suffisamment de Compute Units et de Lamports pour frapper des jetons et créer des ATA sur Solana, vous devez définir ces limites dans votre `layerzero.config.ts` fichier *avant* câblage.

Exécutez la commande de câblage automatisée dans votre terminal :

{% code lineNumbers="true" %}

```bash
npx hardhat lz:oapp:wire --oapp-config layerzero.config.ts
```

{% endcode %}

Cela préparera les 6 transactions de configuration requises :

1. `setSendLibrary`: Assigne le MessageLib pour les paquets sortants.
2. `setReceiveLibrary`: Assigne le MessageLib pour les paquets entrants.
3. `setConfig`: Configure les DVN et l’Executor.
4. `setConfig` : Configure les DVN pour la vérification entrante.
5. `setEnforcedOptions`: Garantit des paramètres d’exécution cohérents (crucial pour s’assurer que l’utilisateur paie suffisamment à l’avance pour couvrir les Compute Units Solana et le loyer des Lamports).
6. `setPeer`: Lie l’EID Solana à votre identifiant de programme Base58 de destination.

La boîte à outils LayerZero V2 automatise le gros du travail : elle décodera l’adresse Solana Base58, la complétera au `bytes32` format EVM, et soumettra les `setPeer` et le `setEnforcedOptions` transactions aux deux chaînes.

Une fois les transactions de câblage confirmées, votre pont EVM-vers-Solana est opérationnel et sécurisé par des permissions.

Votre jeton est officiellement prêt à franchir la frontière EVM/SVM !

## Étape 5 : fonctionnement et tests

Avec votre Adapter Chiliz déployé, votre OFT natif Solana initialisé, et les deux correctement reliés ensemble, votre jeton est officiellement prêt à franchir la frontière EVM/SVM. La dernière étape consiste à exécuter et suivre un transfert de test de Chiliz Chain vers Solana.

### 1) Envoi du message inter-chaînes vers Solana

La boîte à outils LayerZero V2 inclut une tâche Hardhat pour envoyer des transferts OFT directement depuis la ligne de commande.

Contrairement aux transferts EVM-vers-EVM où votre destination est une chaîne hexadécimale standard, votre destination ici est une adresse de portefeuille Solana Base58. La CLI LayerZero gère automatiquement la conversion de Base58 vers Bytes32 pour la charge utile du message.

Exécutez la commande suivante dans votre terminal :

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

```bash
npx hardhat lz:oft:send --oapp-config layerzero.config.ts --from-eid 30409 --to-eid 30168 --to <YOUR_SOLANA_WALLET_ADDRESS_BASE58> --amount 10
```

{% endcode %}

{% hint style="info" %}
Que se passe-t-il ici ?

1. Le script indique les frais inter-chaînes en $CHZ (qui couvrent le gas EVM, les frais du réseau de vérification et les frais de destination Solana).
2. Il appelle le `send()` fonction sur votre Chiliz Adapter.
3. L’Adapter verrouille 10 jetons (18 décimales). Il supprime les 12 décimales les plus basses comme de la « poussière » (les laissant dans votre portefeuille Chiliz) pour réduire la charge utile à 6 `sharedDecimals`.
4. L’Endpoint LayerZero émet le paquet vers Solana Mainnet.
   {% endhint %}

### 2) Suivi du paquet sur LayerZero Scan

Comme le pont vers Solana implique une traduction entre deux mécanismes de consensus totalement différents et l’attente de la finalité SVM, un délai asynchrone est normal.

Pour suivre ce parcours en temps réel, cliquez sur le lien LayerZero Scan qui apparaît dans la sortie du CLI.

En savoir plus sur cet outil ici :

{% embed url="<https://docs.layerzero.network/v2/developers/evm/tooling/layerzeroscan>" %}

{% hint style="info" %}

#### Traduction des décimales

L’OFT natif Solana aura automatiquement mis à l’échelle la charge utile à 6 décimales provenant du pont vers les 9 décimales SPL standard, de sorte que votre portefeuille Solana reçoit exactement 10 jetons complets.
{% endhint %}

**4) Résolution des messages bloqués**

Si votre transaction est marquée comme confirmée sur Chiliz mais échoue à s’exécuter sur Solana, la cause la plus courante est une erreur de Lamports insuffisants ou de Compute Units.

* Si le portefeuille Solana de destination ne disposait pas déjà d’un Compte de Jeton Associé (ATA) pour votre jeton spécifique, l’Executor LayerZero a dû payer les frais de « rent exemption » Solana pour le créer.
* Si le `value` parameter (Lamports) dans votre `enforcedOptions` était trop faible pour couvrir ce loyer, ou si le `gas` (Compute Units) était insuffisant, l’Executor refusera de payer de sa poche, et le message restera bloqué.
* Correctif : vous ne perdez pas vos jetons. Vous pouvez pousser manuellement un message bloqué via l’interface utilisateur LayerZero Scan. Connectez votre portefeuille Solana, cliquez sur le bouton « Force Resume » ou « Execute » sur l’explorateur de blocs, et payez vous-même les frais de destination locaux (Compute Units + loyer ATA en $SOL) pour finaliser la frappe.


---

# 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/use-omnichain-tokens/bridging-from-chiliz-chain-to-solana.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.