Avalanche Francophone
  • Documentation du développeur
  • Apprendre
    • Aperçu de la plateforme
      • Staking
      • Frais de transaction
    • Les bases de la blockchain
    • FAQ
    • Forum
    • Communauté
  • Créer
  • Pour commencer: exécuter un nœud Avalanche
  • Notes de version
    • Alertes par email
    • Notes de mise à jour d'AvalancheGo
    • Notes de mise à jour d'Ortelius
  • Tutoriels
    • Plateforme
      • Créer une nouvelle blockchain
      • Créer un Réseau Local Testnet
      • Créer un sous-réseau (subnet)
      • Créer une Machine Virtuelle (VM)
      • Configurez votre Ledger Nano S avec Avalanche
      • Transférer de l'AVAX entre la X-Chain et la C-Chain
      • Transférer de l'AVAX entre la X-Chain et la P-Chain
    • Nœuds et mise en jeu
      • Ajouter un validateur
      • Maintenir un nœud Avalanche
      • Exécutez un nœud Avalanche et devenez validateur
      • Exécuter un nœud Avalanche avec Oracle VM VirtualBox
      • Exécutez un nœud Avalanche avec un Raspberry Pi 4
      • Exécutez un nœud Avalanche et faites une mise en jeu avec le portefeuille
      • Exécuter un nœud Avalanche avec OVH
      • Exécuter un nœud Avalanche avec Amazon Web Services (AWS)
      • Exécuter un nœud Avalanche avec Microsoft Azure
      • Exécuter un nœud Avalanche sous Linux à l'aide du script d'installation
      • Configuration du monitoring des nœuds
      • Mise en jeu d'AVAX, en validant ou délégant via le portefeuille Avalanche
      • Déléguer à un nœud
      • Sécurisation d'un serveur VPS
      • Mettez à niveau votre nœud AvalancheGo
    • Contrats intelligents
      • Déployer un contrat intelligent en utilisant Remix et MetaMask
      • Utilisation de Truffle avec la C-Chain d'Avalanche
    • Actifs Numériques Intelligents
      • Créer un token ERC-20
      • Créer un actif à capitalisation fixe
      • Créer un actif à capitalisation variable
      • Création d'un NFT - Partie 1
      • Créez des NFT avec le portefeuille Avalanche
      • Utilisez les Wrapped AVAX (WAVAX) sur Avalanche
  • AvalancheGo APIs
    • Émettre des appels d'API
    • Platform API (P-Chain)
    • EVM API (C-Chain)
    • AVM API (X-Chain)
    • Appels d'API obsolètes
    • API Admin
    • API Auth
    • API Health
    • API Info
    • API IPC
    • API Keystore
    • API Metrics
    • API Timestamp
  • Outils
    • AvalancheJS
      • Créer un actif sur la X-Chain
      • Management des clés sur la X-Chain
      • Envoyer un actif sur la X-Chain
      • API
    • Avash
    • Ortelius
  • Références
    • AVM Transaction Format
    • Command Line Interface
    • Coreth Atomic Transaction Format
    • Cryptographic Primitives
    • Network Protocol
    • Serialization Primitives
    • Platform Transaction Format
  • Papiers
Propulsé par GitBook
Sur cette page
  • Introduction
  • Condition
  • Transférer de l'AVAX à l'aide du portefeuille Web
  • Étape 1 - Ouvrez le portefeuille Avalanche
  • Étape 2 - Connectez-vous à votre portefeuille
  • Étape 3 - Accédez à l'onglet Cross Chain
  • Étape 4 - Entrez le montant à transférer
  • Étape 5 - Confirmer la transaction
  • Étape 6 - C'est fait!
  • Transfert de la P-Chain à la X-Chain
  • Transférer de la X-Chain à la P-Chain avec des appels API
  • Étape 1 - Exporter de l'AVAX depuis la X-Chain
  • Étape 2 - Importez AVAX dans la P-Chain
  • Transfert de la P-Chain à la X-Chain par programmation
  • Étape 1 - Exporter de l'AVAX à partir de la P-Chain
  • Étape 1 - Importer de l'AVAX vers X-Chain
  • Récapitulatif

Cet article vous a-t-il été utile ?

  1. Tutoriels
  2. Plateforme

Transférer de l'AVAX entre la X-Chain et la P-Chain

PrécédentTransférer de l'AVAX entre la X-Chain et la C-ChainSuivantNœuds et mise en jeu

Dernière mise à jour il y a 4 ans

Cet article vous a-t-il été utile ?

Introduction

Les jetons AVAX existent sur la X-Chain, où ils peuvent être échangés, sur la P-Chain, où ils peuvent être fournis comme enjeu lors de la validation du réseau primaire, et sur la C-Chain, où ils peuvent être utilisés dans des contrats intelligents, ou pour payer le gaz. Dans ce didacticiel, nous enverrons des jetons AVAX entre la X-Chain et la C-Chain.

Condition

Vous avez terminé l'exécution d'un nœud Avalanche et vous connaissez l'architecture d'Avalanche.

Pour envoyer de l'AVAX, vous devez avoir du AVAX! Vous pouvez obtenir le vrai AVAX en l'achetant sur un échange, ou vous pouvez obtenir le AVAX du tesnet depuis le Faucet testnet, qui est un moyen gratuit et facile de jouer avec Avalanche.

Transférer de l'AVAX à l'aide du portefeuille Web

Le moyen le plus simple de transférer de l'AVAX entre les chaînes est d'utiliser le portefeuille Avalanche, qui est un moyen non custodial et sécurisé d'accéder et de déplacer de l'AVAX.

Le code source du portefeuille Avalanche peut être trouvé ici.

Étape 1 - Ouvrez le portefeuille Avalanche

Sélectionnez "Acces Wallet" pour accéder à votre portefeuille. Pour connecter le portefeuille à un réseau autre que le réseau principal d'Avalanche, sélectionnez "Mainnet" et choisissez le réseau auquel vous connecter.

Étape 2 - Connectez-vous à votre portefeuille

Vous pouvez accéder à votre portefeuille en utilisant la clé privée, la phrase clé mnémonique, le fichier keystore ou Ledger Nano S. Les transferts C-Chain via Ledger ne sont pas encore pris en charge.

Après une connexion réussie, vous verrez votre solde, votre portefeuille d'actifs et diverses autres informations.

Étape 3 - Accédez à l'onglet Cross Chain

La fonctionnalité de transfert de jetons entre les chaînes se trouve sur l'onglet Cross Chain.

Étape 4 - Entrez le montant à transférer

Vous serez présenté avec un choix pour la chaîne source et la chaîne de destination. Sélectionnez respectivement X-Chain et P-Chain. Vous verrez vos soldes X et P et un champ de saisie pour saisir le montant à transférer de la chaîne source à la chaîne de destination.

Entrez le montant que vous souhaitez transférer de la X-Chain vers la P-Chain.

Étape 5 - Confirmer la transaction

Appuyez sur Confirm, puis sur Transfer pour lancer le transfert.

Étape 6 - C'est fait!

Un transfert inter-chaîne est un processus en deux étapes: d'abord une transaction pour exporter les fonds de la X-Chain, et une autre pour les importer dans la P-Chain. Le portefeuille fera les deux et montrera sa progression tout en le faisant.

En cas de blocage de la transation depuis la X-Chain vers la C-Chain utiliser la fonction "Import" dans votre portefeuille en sélectionnant la X-Chain

Transfert de la P-Chain à la X-Chain

Pour renvoyer l'AVAX à la X-Chain, vous devez effectuer le transfert dans la direction opposée.

Permutez la chaîne source et la chaîne de destination en les sélectionnant dans le menu déroulant Source et Destination. Le reste du processus est le même: entrez le montant (amount), puis appuyez sur Confirm, et ensuite sur Transfer pour lancer le transfert.

Transférer de la X-Chain à la P-Chain avec des appels API

Si vous créez une application sur le réseau Avalanche, vous souhaiterez peut-être effectuer le transfert par programme dans le cadre d'une fonctionnalité plus large. Vous pouvez le faire en appelant les API appropriées sur un nœud AvalancheGo. Le reste du didacticiel suppose que vous avez accès à un nœud AvalancheGo, aux jetons AVAX sur la X-Chain et aux informations d'identification de l'utilisateur créé et stockées dans le keystore du nœud.

Tous les exemples d'appels d'API ci-dessous supposent que le nœud s'exécute localement (c'est-à-dire écoute sur 127.0.0.1). Le nœud peut être connecté au réseau principal, à un réseau de test ou à un réseau local. Dans chaque cas, les appels et les réponses de l'API doivent être identiques, à l'exception des formats d'adresse. Le nœud n'a pas besoin d'être local; vous pouvez passer des appels vers un nœud hébergé ailleurs.

Comme vous l'avez peut-être remarqué lors du transfert d'AVAX à l'aide du portefeuille Avalanche, un transfert inter-chaîne est une opération à deux transactions:

  • Exporter de l'AVAX depuis la X-Chain

  • Importer de l'AVAX dans la P-Chain

Étape 1 - Exporter de l'AVAX depuis la X-Chain

Votre appel doit ressembler à ceci :

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.exportAVAX",
    "params" :{
        "to":"P-avax1wkmfja9ve3lt3n9ye4qp3l3gj9k2mz7ep45j7q",
        "destinationChain": "P",
        "amount": 5000000,
        "changeAddr": "X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
        "username":"myUsername",
        "password":"myPassword"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Notez que vous paierez des frais de transaction pour les opérations d'exportation et d'importation. Dans cet exemple, supposons que les frais de transaction sont de 1 000 000 nAVAX (0.001 AVAX). Ensuite, l'exportation ci-dessus consomme en fait 6 000 000 nAVAX (0.006 AVAX); 5 000 000 (0.005 AVAX) vont à la P-Chain et 1 000 000 (0.001 AVAX) sont dépensés en frais de transaction.

Assurez-vous que le montant que vous envoyez dépasse les frais de transaction. Sinon, lorsque vous importez l'AVAX sur la P-Chain, les frais de transaction seront consommés et vous vous retrouverez avec moins d'AVAX sur la P-Chain.

La réponse devrait ressembler à ceci :

{
    "jsonrpc": "2.0",
    "result": {
        "txID": "MqEaeWc4rfkw9fhRMuMTN7KUTNpFmh9Fd7KSre1ZqTsTQG73h",
        "changeAddr": "X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
    },
    "id": 1
}
curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "avm.getTxStatus",
    "params":{
        "txID":"MqEaeWc4rfkw9fhRMuMTN7KUTNpFmh9Fd7KSre1ZqTsTQG73h"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Ce qui montre que notre transaction est acceptée :

{
    "jsonrpc": "2.0",
    "result": {
        "status": "Accepted"
    },
    "id": 1
}
curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getBalance",
    "params" :{
        "address":"X-ADDRESSGOESHERE",
        "assetID":"AVAX"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Le montant déduit est le montant exporté (5 000 000 nAVAX soit 0.005 AVAX dans cet exemple) plus les frais de transaction. Si votre utilisateur contrôle plusieurs adresses X-Chain, l'AVAX peut avoir été envoyé à partir de n'importe quelle combinaison d'entre elles.

Étape 2 - Importez AVAX dans la P-Chain

Votre appel doit ressembler à ceci :

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.importAVAX",
    "params": {
        "to":"P-avax1wkmfja9ve3lt3n9ye4qp3l3gj9k2mz7ep45j7q",
        "sourceChain":"X",
        "changeAddr":"P-avax103y30cxeulkjfe3kwfnpt432ylmnxux8r73r8u",
        "username":"myUsername",
        "password":"myPassword",
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P

Cela renvoie l'ID de transaction :

{
    "jsonrpc": "2.0",
    "result": {
        "txID": "2sxo3ySETZ4xzXqAtgsUvZ5pdkqG4SML4c7Z7NoKLZcp77YNXC",
        "changeAddr":"P-avax103y30cxeulkjfe3kwfnpt432ylmnxux8r73r8u"
    },
    "id": 1
}

Nous pouvons vérifier que la transaction a été acceptée avec :

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.getTxStatus",
    "params" :{
        "txID":"2sxo3ySETZ4xzXqAtgsUvZ5pdkqG4SML4c7Z7NoKLZcp77YNXC"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Cela devrait êtreCommitted, ce qui signifie que le transfert est terminé. Nous pouvons également vérifier le solde de l'adresse avec :

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.getBalance",
    "params":{
        "address":"P-avax1wkmfja9ve3lt3n9ye4qp3l3gj9k2mz7ep45j7q"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/P

La réponse devrait ressembler à ceci :

{
    "jsonrpc": "2.0",
    "result": {
        "balance": "4000000",
        "utxoIDs": [
            {
                "txID": "2sxo3ySETZ4xzXqAtgsUvZ5pdkqG4SML4c7Z7NoKLZcp77YNXC",
                "outputIndex": 0
            }
        ]
    },
    "id": 1
}

Notez que le solde que nous voyons est le montant exporté de la X-Chain (4.000.000 nAVAX / 0.004 AVAX) moins les frais de transaction (1.000.000 nAVAX/ 0.001 AVAX dans cet exemple.) Maintenant, nous pouvons utiliser l'AVAX détenu par cette adresse P-Chain pour fournir une mise afin de valider le réseau primaire.

Transfert de la P-Chain à la X-Chain par programmation

Maintenant, déplaçons AVAX sur la P-Chain vers la X-Chain.

Comme précédemment, il s'agit également d'une opération à deux transactions:

  • Exportation depuis la P-Chain

  • Importer dans la X-Chain

Étape 1 - Exporter de l'AVAX à partir de la P-Chain

curl -X POST --data '{
    "jsonrpc": "2.0",
    "method": "platform.exportAVAX",
    "params": {
        "to":"X-avax1fjn5rffqvny7uk3tjegjs6snwjs3hhgcpcxfax",
        "amount":3000000,
        "changeAddr":"P-avax103y30cxeulkjfe3kwfnpt432ylmnxux8r73r8u",
        "username":"myUsername",
        "password":"myPassword"
    },
    "id": 1
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/P

Où to est l'adresse X-Chain à laquelle l'AVAX est envoyé.

Étape 1 - Importer de l'AVAX vers X-Chain

curl -X POST --data '{
    "jsonrpc":"2.0",
    "id"     :1,
    "method" :"avm.importAVAX",
    "params" :{
        "to":"X-avax1fjn5rffqvny7uk3tjegjs6snwjs3hhgcpcxfax",
        "sourceChain":"P",
        "changeAddr": "X-avax1turszjwn05lflpewurw96rfrd3h6x8flgs5uf8",
        "username":"myUsername",
        "password":"myPassword"
    }
}' -H 'content-type:application/json;' 127.0.0.1:9650/ext/bc/X

Comme auparavant, nous pouvons appeler avm.getBalance pour vérifier que les fonds ont été reçus. Le solde aurait dû augmenter de 3 000 000 nAVAX soit 0.003 AVAX moins les frais de transaction.

Récapitulatif

Vous pouvez maintenant permuter AVAX dans les deux sens entre la X-Chain et la P-Chain à la fois en utilisant le portefeuille Avalanche et en appelant les appels API appropriés sur un nœud Avalanche.

Vous pouvez maintenant utiliser les jetons sur la P-Chain pour ajouter un nœud en tant que validateur sur le réseau principal.

Pour envoyer l’AVAX, appelez la méthode de la X-Chain.

Où to est l'adresse d'une adresse P-Chain que vous détenez et changeAddr est l'adresse à laquelle envoyer toute modification. Vous pouvez laisser changeAddr vide; si vous le faites, la modification sera retournée à une adresse contrôlée par votre utilisateur. (Voir pour obtenir des instructions sur la création d'une nouvelle adresse P-Chain.)

Nous pouvons vérifier que cette transaction a été acceptée en appelant :

Nous pouvons également appeler pour vérifier que l'AVAX a été déduit d'une adresse détenue par notre utilisateur :

Notre transfert n’est pas encore terminé. Nous devons appeler la méthode de P-Chain pour terminer le transfert.

Pour ce faire, appelez :

Cela renvoie l'ID de transaction et nous pouvons vérifier que la transaction a été validée avec un autre appel à . Encore une fois, assurez-vous que le montant que vous envoyez dépasse les frais de transaction.

Pour terminer notre transfert de la P-Chain vers la X-Chain, appelez :

Notez que to est la même adresse spécifiée dans notre appel à .

avm.exportAVAX
avm.getTxStatus
avm.getBalance
avm.importAVAX
ici
platform.importAVAX
platform.exportAVAX
platform.getTxStatus
platform.exportAVAX