The quickest way to start building on X Layer with Quicknode is by sending a JSON-RPC request to your endpoint. In this quickstart, you'll create an endpoint, copy its provider URL, and make your first request. Code samples are available in cURL as well as popular SDKs and programming languages.

Get Your X Layer Endpoint

1

Créez un compte Quicknode

Inscrivez-vous ici si ce n'est pas déjà fait.

2

Accédez à votre tableau de bord

Ouvrez le tableau de bord des endpoints depuis le menu latéral gauche pour gérer tous vos endpoints blockchain

3

Créez un nouvel endpoint

Click Create an Endpoint in the top-right corner, select X Layer as your blockchain, then select your preferred network

4

Copiez vos URL de fournisseur

Gardez l'URL HTTP à portée de main. Vous l'utiliserez dans vos requêtes ci-dessous.

En savoir plus sur le tableau de bord

Pour une présentation détaillée du tableau de bord Quicknode, consultez notre guide

Envoyer votre première requête

Your endpoint is ready. Now, let's make your first call to the X Layer blockchain. We'll use the eth_blockNumber méthode qui renvoie le numéro du dernier bloc. Sélectionnez votre langage ou SDK préféré et suivez les étapes ci-dessous pour envoyer votre première requête.

cURL

1

Vérifier l'installation de cURL

La plupart des systèmes basés sur *nix prennent en charge cURL nativement. Ouvrez votre terminal et vérifiez la version de cURL en exécutant la commande ci-dessous :

curl --version

2

Envoyer une requête JSON-RPC

Dans votre terminal, copiez-collez la commande cURL suivante pour récupérer le dernier numéro de bloc :

curl -X POST YOUR_QUICKNODE_ENDPOINT_URL/ \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

3

Exemple de réponse

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1234567"
}

SDK Quicknode

1

Configurer votre projet

Tout d'abord, vérifiez que Node.js est installé avec la commande node --version. S'il n'est pas installé, téléchargez-le depuis https://nodejs.org. Ensuite, créez un nouveau répertoire et initialisez un projet Node.js :

mkdir xlayer-api-quickstart
cd xlayer-api-quickstart
npm init -y

2

Installer le SDK Quicknode

Installez le package SDK Quicknode :

npm installer @quicknode/sdk

3

Créer votre fichier principal

Créez un fichier index.js pour votre code :

touch index.js

4

Ajoutez ce code à votre fichier index.js

Copiez et collez ce code dans votre fichier index.js :

const { Core } = require('@quicknode/sdk');

const main = async () => {
  const core = new Core({
    endpointUrl: 'YOUR_QUICKNODE_ENDPOINT_URL/',
  });

  const blockNumber = await core.client.request({
    method: 'eth_blockNumber',
  });

  console.log('Block number:', parseInt(blockNumber, 16));
};

main();

5

Lancez votre projet

Exécutez votre script pour afficher le numéro du dernier bloc :

node index.js

Python

1

Configurer votre projet

Créez un nouveau répertoire pour votre projet Python :

mkdir xlayer-python-quickstart
cd xlayer-python-quickstart

2

Créer et activer un environnement virtuel

Créer un environnement virtuel pour gérer les dépendances :

python3 -m venv venv
source venv/bin/activate

3

Demandes d'installation

Installez la bibliothèque « requests » pour effectuer des requêtes HTTP :

pip install requests

4

Créez un script Python (app.py)

Créez un fichier Python contenant le code suivant :

import requests
import json

# Your Quicknode endpoint URL
endpoint_url = "YOUR_QUICKNODE_ENDPOINT_URL/"

# JSON-RPC request payload
payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_blockNumber",
    "params": []
}

# Make the request
response = requests.post(endpoint_url, json=payload)
result = response.json()

print("Latest block number (hex):", result["result"])
print("Latest block number (decimal):", int(result["result"], 16))

5

Exécutez le script

Exécutez votre script Python :

python app.py

JavaScript

1

Configurer votre projet

Créez un nouveau répertoire et lancez un projet Node.js :

mkdir xlayer-js-quickstart
cd xlayer-js-quickstart
npm init -y

2

Créez un fichier JavaScript (app.js)

Créez un fichier app.js contenant le code suivant (en utilisant la fonction native `fetch` disponible dans Node.js 18 et versions ultérieures) :

const url = 'YOUR_QUICKNODE_ENDPOINT_URL/';
const options = {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_blockNumber',
    params: [],
    id: 1
  })
};

async function main() {
  try {
    const response = await fetch(url, options);
    const data = await response.json();
    console.log('Block Number (hex):', data.result);
    console.log('Block Number (decimal):', parseInt(data.result, 16));
  } catch (error) {
    console.error('Error:', error);
  }
}

main();

3

Exécutez le script

Exécutez votre script JavaScript :

node app.js

Ruby

1

Configurer votre projet

Créez un nouveau répertoire pour votre projet Ruby :

mkdir xlayer-ruby-quickstart
cd xlayer-ruby-quickstart

2

Vérifier l'installation de Ruby

Vérifiez que Ruby est bien installé sur votre système. Si ce n'est pas le cas, installez-le à partir du site https://ruby-lang.org :

ruby --version

3

Créer un script Ruby (main.rb)

Créez un fichier main.rb contenant le code suivant :

require "uri"
require "json"
require "net/http"

url = URI("YOUR_QUICKNODE_ENDPOINT_URL/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "method": "eth_blockNumber",
  "params": [],
  "id": 1,
  "jsonrpc": "2.0"
})

response = https.request(request)
result = JSON.parse(response.read_body)
hex_result = result["result"]
decimal_result = hex_result.to_i(16)
puts "Block number (hex): #{hex_result}"
puts "Block number (decimal): #{decimal_result}"

4

Exécutez le script

Exécutez votre script Ruby pour afficher le dernier numéro de bloc :

ruby main.rb

Aller

1

Configurer votre projet

Créez un nouveau répertoire pour votre projet Go :

mkdir xlayer-go-quickstart
cd xlayer-go-quickstart

2

Vérifier la configuration de Go

Vérifiez que Go est bien installé sur votre système. Si ce n'est pas le cas, installez-le à partir du site https://golang.org :

go version

3

Créer un script Go (main.go)

Créez un fichier main.go contenant le code suivant :

package main

import (
  "encoding/json"
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  "strconv"
)

type Response struct {
  Result string `json:"result"`
}

func main() {
  url := "YOUR_QUICKNODE_ENDPOINT_URL/"
  method := "POST"

  payload := strings.NewReader(`{"method":"eth_blockNumber","params":[],"id":1,"jsonrpc":"2.0"}`)

  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }

  var response Response
  err = json.Unmarshal(body, &response)
  if err != nil {
    fmt.Println("Error parsing JSON:", err)
    return
  }

  // Convert hex to decimal
  blockNumber, err := strconv.ParseInt(response.Result, 0, 64)
  if err != nil {
    fmt.Println("Error converting hex to decimal:", err)
    return
  }

  fmt.Printf("Block number (hex): %s\n", response.Result)
  fmt.Printf("Block number (decimal): %d\n", blockNumber)
}

4

Exécutez le script

Exécutez votre script Go pour afficher le numéro du dernier bloc :

lancez main.go

Ethers.js

1

Configurer votre projet

Créez un nouveau répertoire et initialisez un projet Node.js (en supposant que Node.js soit déjà installé) :

mkdir xlayer-ethers-quickstart
cd xlayer-ethers-quickstart
npm init -y
npm pkg set type=module

2

Installer ethers.js

Installez la bibliothèque ethers.js pour interagir avec Ethereum :

npm installer ethers

3

Créez votre fichier principal (index.js)

Créez un fichier index.js contenant le code suivant :

import { ethers } from "ethers";

(async () => {
  const provider = new ethers.JsonRpcProvider("YOUR_QUICKNODE_ENDPOINT_URL/");
  const blockNum = await provider.getBlockNumber();
  console.log('Current block number (decimal):', blockNum);
  console.log('Block number (hex):', '0x' + blockNum.toString(16));
})();

4

Lancez votre projet

Exécutez votre script pour afficher le numéro du dernier bloc :

node index.js

Web3.py

1

Configurer votre projet

Créez un nouveau répertoire pour votre projet web3.py :

mkdir xlayer-web3py-quickstart
cd xlayer-web3py-quickstart

2

Installez web3.py (s'il n'est pas déjà installé)

Vérifiez si web3.py est installé à l'aide de la commande `pip list | grep web3`. S'il n'apparaît pas, installez-le :

pip installer web3

3

Créez un script Python (main.py)

Créez un fichier main.py contenant le code suivant :

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("YOUR_QUICKNODE_ENDPOINT_URL/"))

try:
  latest_block_number = w3.eth.block_number
  print(f"Latest Block Number: {latest_block_number}")
  print(f"Block number (hex): {hex(latest_block_number)}")
except Exception as e:
  print(f"Error: {e}")

Eth.rb

1

Configurer votre projet

Créez un nouveau répertoire pour votre projet eth.rb :

mkdir xlayer-ethrb-quickstart
cd xlayer-ethrb-quickstart

2

Installez eth.rb (s'il n'est pas déjà installé)

Vérifiez si eth.rb est installé à l'aide de la commande `gem list eth`. S'il n'apparaît pas, installez-le :

gem installer eth

3

Créer un script Ruby (main.rb)

Créez un fichier main.rb contenant le code suivant :

require 'eth'

client = Eth::Client.create "YOUR_QUICKNODE_ENDPOINT_URL/"

begin
  block_number = client.eth_block_number
  hex_result = block_number["result"]
  decimal_result = hex_result.to_i(16)
  puts "Block number (hex): #{hex_result}"
  puts "Block number (decimal): #{decimal_result}"
rescue => e
  puts "Error: #{e.message}"
end

4

Exécutez le script

Exécutez votre script Ruby pour afficher le dernier numéro de bloc :

ruby main.rb

Ethgo

1

Configurer votre projet

Créez un nouveau répertoire pour votre projet Ethgo :

mkdir xlayer-ethgo-quickstart
cd xlayer-ethgo-quickstart

2

Initialiser le module Go et installer ethgo

Créez un fichier go.mod pour gérer les dépendances, puis installez le SDK ethgo :

go mod init xlayer-ethgo-quickstart
go get github.com/umbracle/ethgo
go mod tidy

3

Créer un script Go (main.go)

Créez un fichier main.go contenant le code suivant :

package main

import (
  "fmt"
  "log"
  "github.com/umbracle/ethgo/jsonrpc"
)

func main() {
  client, err := jsonrpc.NewClient("YOUR_QUICKNODE_ENDPOINT_URL/")
  if err != nil {
    log.Fatalf("Failed to connect to Ethereum: %v", err)
  }

  blockNumber, err := client.Eth().BlockNumber()
  if err != nil {
    log.Fatalf("Failed to get latest block number: %v", err)
  }

  fmt.Printf("Latest block number (decimal): %d\n", blockNumber)
  fmt.Printf("Latest block number (hex): 0x%x\n", blockNumber)
}

4

Exécutez le script

Exécutez votre script Go pour afficher le numéro du dernier bloc :

lancez main.go

Si vous souhaitez en savoir plus sur la création de requêtes API, consultez nos guides et nos exemples d'applications.

Présentation de l'API

Discover Supported X Layer APIs, Networks, Chain Configurations, and compatible Quicknode Products

Points d'accès du fournisseur

Learn how to set up and configure your X Layer RPC endpoints for development and production use

Sécurité des points de terminaison

Sécurisez vos points d'accès avec l'authentification par jeton, la limitation de débit, la liste blanche, le JWT et les meilleures pratiques de sécurité

Référence des erreurs

Reference document for common X Layer RPC error codes and troubleshooting tips

Modules complémentaires du Marketplace

Discover powerful add-ons and extensions to enhance your X Layer development workflow

Nous ❤️ les commentaires !

Si vous avez des commentaires ou des questions concernant cette documentation, faites-le nous savoir. Nous serions ravis de vous entendre !