A forma mais rápida de começar a desenvolver na X Layer com o Quicknode é enviando um pedido JSON-RPC para o seu ponto de extremidade. Neste guia de início rápido, irá criar um ponto de extremidade, copiar o URL do seu fornecedor e efetuar o seu primeiro pedido. Estão disponíveis exemplos de código em cURL, bem como em SDKs e linguagens de programação populares.

Obtenha o seu ponto de extremidade X Layer

1

Criar uma conta no Quicknode

Inscreve-te aqui, se ainda não o fizeste.

2

Aceda ao seu painel de controlo

Abra o painel «Endpoints» a partir do menu da barra lateral esquerda para gerir todos os seus endpoints de blockchain

3

Criar um novo ponto de extremidade

Clique em «Criar um Endpoint» no canto superior direito, selecione «X Layer» como a sua blockchain e, em seguida, selecione a sua rede preferida

4

Copie os URLs do seu fornecedor

Tenha a URL HTTP à mão. Vai precisar dela nas solicitações que vai fazer a seguir.

Saiba mais sobre o painel de controlo

Para um guia detalhado do painel do Quicknode, consulte o nosso guia

Envie o seu primeiro pedido

O seu endpoint está pronto. Agora, vamos fazer a sua primeira chamada à blockchain X Layer. Vamos utilizar o eth_blockNumber método, que devolve o número do bloco mais recente. Selecione o seu idioma ou SDK preferido e siga os passos abaixo para enviar o seu primeiro pedido.

cURL

1

Verificar a instalação do cURL

A maioria dos sistemas baseados em *nix já inclui suporte ao cURL de fábrica. Abra o terminal e verifique a versão do cURL executando o comando abaixo:

curl --versão

2

Enviar um pedido JSON-RPC

No seu terminal, copie e cole o seguinte comando cURL para obter o número do bloco mais recente:

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

3

Exemplo de resposta

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

SDK do Quicknode

1

Configure o seu projeto

Primeiro, verifique se o Node.js está instalado com o comando `node --version`. Se não estiver instalado, descarregue-o em https://nodejs.org. Em seguida, crie um novo diretório e inicialize um projeto Node.js:

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

2

Instalar o SDK do Quicknode

Instale o pacote SDK do Quicknode:

npm instalar @quicknode/sdk

3

Crie o seu ficheiro principal

Crie um ficheiro index.js para o seu código:

touch index.js

4

Adicione este código ao seu ficheiro index.js

Copie e cole este código no seu ficheiro 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

Execute o seu projeto

Execute o seu script para ver o número do bloco mais recente:

node index.js

Python

1

Configure o seu projeto

Crie um novo diretório para o seu projeto em Python:

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

2

Criar e ativar um ambiente virtual

Criar um ambiente virtual para gerir dependências:

python3 -m venv venv
source venv/bin/activate

3

Pedidos de instalação

Instale a biblioteca `requests` para efetuar pedidos HTTP:

pip instalar requests

4

Crie um script em Python (app.py)

Crie um ficheiro Python com o seguinte código:

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

Executar o script

Execute o seu script em Python:

python app.py

JavaScript

1

Configure o seu projeto

Crie um novo diretório e inicialize um projeto Node.js:

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

2

Criar um ficheiro JavaScript (app.js)

Crie um ficheiro app.js com o seguinte código (utilizando o `fetch` nativo disponível no Node.js 18 ou superior):

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

Executar o script

Execute o seu script JavaScript:

node app.js

Ruby

1

Configure o seu projeto

Crie um novo diretório para o seu projeto Ruby:

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

2

Verificar a instalação do Ruby

Verifique se o Ruby está instalado no seu sistema. Caso contrário, instale-o a partir de https://ruby-lang.org:

ruby --versão

3

Criar um script em Ruby (main.rb)

Crie um ficheiro main.rb com o seguinte código:

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

Executar o script

Execute o seu script Ruby para ver o número do bloco mais recente:

ruby main.rb

Vai

1

Configure o seu projeto

Crie um novo diretório para o seu projeto Go:

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

2

Verificar a disposição das pedras no Go

Verifique se o Go está instalado no seu sistema. Caso contrário, instale-o a partir de https://golang.org:

go version

3

Criar um script em Go (main.go)

Crie um ficheiro main.go com o seguinte código:

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

Executar o script

Execute o seu script em Go para ver o número do bloco mais recente:

executa o ficheiro main.go

Ethers.js

1

Configure o seu projeto

Crie um novo diretório e inicialize um projeto Node.js (partindo do princípio de que o Node.js já está instalado):

mkdir xlayer-ethers-quickstart
cd xlayer-ethers-quickstart
npm init -y
npm pkg set type=módulo

2

Instalar o ethers.js

Instale a biblioteca ethers.js para interagir com a Ethereum:

npm instalar ethers

3

Crie o seu ficheiro principal (index.js)

Crie um ficheiro index.js com o seguinte código:

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

Execute o seu projeto

Execute o seu script para ver o número do bloco mais recente:

node index.js

Web3.py

1

Configure o seu projeto

Crie um novo diretório para o seu projeto web3.py:

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

2

Instale o web3.py (caso ainda não esteja instalado)

Verifique se o web3.py está instalado com o comando `pip list | grep web3`. Se não for encontrado, instale-o:

pip instalar web3

3

Crie um script em Python (main.py)

Crie um ficheiro main.py com o seguinte código:

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

Configure o seu projeto

Crie um novo diretório para o seu projeto eth.rb:

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

2

Instale o eth.rb (se ainda não estiver instalado)

Verifique se o eth.rb está instalado com o comando `gem list eth`. Se não for encontrado, instale-o:

gem instalar eth

3

Criar um script em Ruby (main.rb)

Crie um ficheiro main.rb com o seguinte código:

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

Executar o script

Execute o seu script Ruby para ver o número do bloco mais recente:

ruby main.rb

Ethgo

1

Configure o seu projeto

Crie um novo diretório para o seu projeto Ethgo:

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

2

Inicializar o módulo Go e instalar o ethgo

Inicialize um ficheiro go.mod para gerir as dependências e, em seguida, instale o SDK do ethgo:

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

3

Criar um script em Go (main.go)

Crie um ficheiro main.go com o seguinte código:

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

Executar o script

Execute o seu script em Go para ver o número do bloco mais recente:

executa o ficheiro main.go

Se quiseres continuar a aprender sobre como efetuar pedidos à API, consulta os nossos guias e aplicações de exemplo.

Visão geral da API

Descubra as APIs da camada X suportadas, as redes, as configurações de cadeia e os produtos Quicknode compatíveis

Pontos de acesso do prestador

Saiba como instalar e configurar os seus pontos finais RPC do X Layer para utilização em desenvolvimento e produção

Segurança de terminais

Proteja os seus terminais com autenticação por token, limitação de taxa, lista de permissões, JWT e as melhores práticas de segurança

Referência de erro

Documento de referência sobre os códigos de erro comuns do RPC da Camada X e dicas para a resolução de problemas

Complementos do Marketplace

Descubra complementos e extensões poderosas para otimizar o seu fluxo de trabalho de desenvolvimento no X Layer

Adoramos ❤️ os vossos comentários!

Se tiver algum comentário ou dúvida sobre esta documentação, não hesite em contactar-nos. Adoraríamos saber a sua opinião!