Aller directement au menu principal

Vérification de Contrats

Dans un souci de transparence, il est recommandé de vérifier tous les contrats sur Core Scan. Bien qu'il existe plusieurs façons d'effectuer la vérification de contrats, nous recommandons d'utiliser l'outil de vérification officiel de Core, Core Scan, pour une fiabilité optimale. Voici un aperçu des méthodes les plus courantes pour vérifier les contrats via le web, l'API et Hardhat.

note

Assurez-vous que votre contrat intelligent suit les Solidity Support Guidelines de Core Chain. Pour ce faire, assurez-vous que le paramètre evmVersion est défini sur paris dans les paramètres du compilateur Solidity.

Vérification Web via Core Scan​

La vérification Web est la stratégie de vérification de contrat intelligent la plus utilisée. Après avoir déployé votre contrat intelligent sur Core, vous pouvez utiliser son code source pour le vérifier sur Core Scan.

  1. Accédez au site web de Core Scan.
  1. Recherchez le contrat par adresse sur Core Scan. Il suffit de coller l'adresse du contrat dans la barre de recherche du site web.
  2. Une fois le contrat localisé, sélectionnez l'onglet Contract et cliquez sur Verify and Publish.

verify-core-scan

4. Remplissez les informations de vérification requises, notamment :

  • L'adresse du contrat;
  • Le type de compilateur : pour les contrats simples, sélectionnez Single File. Pour les contrats plus complexes avec des imports externes, sélectionnez Standard Json;
  • La version du compilateur;
  • Le type de licence open-source;

verify-core-scan

5. Sur la page suivante, remplissez le code source du contrat en Solidity.

Si votre contrat a des paramètres de constructeur, il est recommandé de les ajouter dans le champ Constructor Arguments, bien que cela ne soit pas obligatoire. Ces paramètres doivent être formatés en bytes encodés en ABI. Remix et d'autres outils peuvent générer ces paramètres pour vous.

Si vous avez activé l'optimisation lors de la compilation du contrat, sélectionnez "Oui" pour le champ Optimization.

verify-contract

6. Cliquez sur Verify and Publish pour terminer le processus.

verify-contract

Votre contrat vérifié sur Core Scan devrait maintenant être publié et accessible:

verify-contract

Vérification via API​

Vous pouvez trouver un guide pour utiliser l'API de Core afin de vérifier des contrats ici. Il est important de noter que pour effectuer des appels API, vous devez vous inscrire sur Core Scan et générer une clé API.

Si vous êtes déjà familier avec l'API d'Etherscan, cela devrait être simple ! Les appels API sur Core sont 100 % compatibles avec l'API d'Etherscan. Il vous suffit de remplacer la clé API et l'URL de l'endpoint et tout devrait fonctionner normalement.

Vérification avec HardHat​

La vérification via HardHat est le moyen le plus pratique pour les développeurs de vérifier des contrats intelligents. Pour plus d'informations, vous pouvez consulter le guide officiel de vérification de Hardhat ici.

Veuillez noter qu'il est nécessaire d'ajouter les réseaux Core en tant que chaînes personnalisées dans le fichier de configuration de HardHat. Voici un exemple de configuration pour HardHat :

/**
* @type import('hardhat/config').HardhatUserConfig
*/


const { PrivateKey } = require('./secret.json');
require('@nomiclabs/hardhat-ethers');
require("@nomiclabs/hardhat-waffle");
require("@nomicfoundation/hardhat-verify");

module.exports = {
  defaultNetwork: 'testnet',

  networks: {
     hardhat: {
     },
     testnet: {
        url: 'https://rpc.test.btcs.network',
        accounts: [PrivateKey],
        chainId: 1115,
     },
     mainnet: {
       url: 'https://rpc.coredao.org',
       accounts: [PrivateKey],
       chainId: 1116,
    },
  },
  etherscan: {
   apiKey: {
     testnet: "api key",
     mainnet: "api key"
   },
   customChains: [
     {
       network: "testnet",
       chainId: 1115,
       urls: {
         apiURL: "https://api.test.btcs.network/api",
         browserURL: "https://scan.test.btcs.network/"
       }
     },
     {
       network: "mainnet",
       chainId: 1116,
       urls: {
         apiURL: "https://openapi.coredao.org/api",
         browserURL: "https://scan.coredao.org/"
       }
     }
   ]
 },
 
  solidity: {
     compilers: [
       {
          version: '0.8.9',
          settings: {
            evmVersion: 'shanghai',
             optimizer: {
                enabled: false,
                runs: 200,
             },
          },
       }
     ],
  },
  paths: {
     sources: './contracts',
     cache: './cache',
     artifacts: './artifacts',
  },
  mocha: {
     timeout: 20000,
  },
};

Vérification de Contrats​

mettez à jour le fichier foundry.toml pour spécifier la version Solidity et la version EVM pour votre projet.

[profile.default]
solidity_version = "0.8.0"  # Specify the Solidity version
evm_version = "shanghai" #Specify the EVM version as Shanghai for Core testnet2 and mainnet, use Paris for old testnet

créez un fichier .env pour stocker des informations sensibles telles que votre clé privée, votre URL RPC et vos clés API. Cela permet de sécuriser vos informations d’identification et de les référencer facilement dans votre code.

RPC_URL = " https://rpc.test2.btcs.network"
PRIVATE_KEY = "YOUR_PRIVATE_KEY"
CORESCAN_API_KEY="YOUR_API_KEY"
API_URL="https://api.test2.btcs.network/api"

Important : Ne soumettez jamais ce fichier « .env » au contrôle de version (par exemple, GitHub) pour éviter d'exposer vos informations sensibles. Si vous utilisez git, ajoutez le fichier .env à votre .gitignore.

Maintenant que vous avez créé le fichier .env ci-dessus, exécutez la commande suivante pour charger les variables d'environnement dans la session de ligne de commande en cours :

source .env

Exécutez la commande ci-dessous pour vérifier votre contrat intelligent

forge verify-contract 0xContract_Address ContractName  --verifier-url $API_URL  --api-key $CORESCAN_API_KEY --watch

Replace 0xContract_Address and ContractName with your actual contract address and the contract Name.

Foundry gérera le processus de vérification, vous pouvez utiliser Core Scan pour rechercher l'adresse du contrat afin de vérifier que le contrat a été déployé et vérifié avec succès.

Limitations Connues​

  • Actuellement, Core ne prend en charge que les versions du compilateur Solidity jusqu'à 0.8.24
  • Les bibliothèques ne sont pas prises en charge avec la vérification via l'API.
  • Si vous avez des soucis à vérifier des contrats très volumineux (1000+ lignes) en un seul fichier, il est recommandé d'utiliser le format Standard JSON pour la vérification.