La forma más rápida de empezar a desarrollar en Fantom con Quicknode es enviando una solicitud JSON-RPC a tu punto de conexión. En esta guía de inicio rápido, crearás un punto de conexión, copiarás la URL de su proveedor y realizarás tu primera solicitud. Hay ejemplos de código disponibles en cURL, así como en los SDK y lenguajes de programación más habituales.

Consigue tu punto final de Fantom

1

Crear una cuenta en Quicknode

Regístrate aquí si aún no lo has hecho.

2

Ve a tu panel de control

Abre el panel de control de Endpoints desde el menú de la barra lateral izquierda para gestionar todos tus puntos de conexión de la cadena de bloques

3

Crear un nuevo punto final

Haz clic en «Crear un punto final» en la esquina superior derecha, selecciona «fantom» como cadena de bloques y, a continuación, selecciona la red que prefieras.

4

Copia las URL de tus proveedores

Ten a mano la URL HTTP. La vas a utilizar en las solicitudes que vas a realizar a continuación.

Más información sobre el panel de control

Si quieres ver una explicación detallada del panel de control de Quicknode, echa un vistazo a nuestra guía

Envía tu primera solicitud

Tu punto final ya está listo. Ahora, vamos a realizar tu primera llamada a la cadena de bloques Fantom. Utilizaremos el eth_blockNumber método, que devuelve el número de bloque más reciente. Selecciona tu idioma o SDK preferido y sigue los pasos que se indican a continuación para enviar tu primera solicitud.

cURL

1

Comprobar la instalación de cURL

La mayoría de los sistemas basados en *nix son compatibles con cURL de serie. Abre el terminal y comprueba la versión de cURL ejecutando el siguiente comando:

curl --versión

2

Enviar una solicitud JSON-RPC

En tu terminal, copia y pega el siguiente comando de cURL para obtener el último número de bloque:

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

3

Ejemplo de respuesta

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

SDK de Quicknode

1

Configura tu proyecto

En primer lugar, comprueba que Node.js esté instalado ejecutando el comando `node --version`. Si no está instalado, descárgalo desde https://nodejs.org. A continuación, crea un nuevo directorio e inicializa un proyecto de Node.js:

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

2

Instala el SDK de Quicknode

Instala el paquete SDK de Quicknode:

npm instalar @quicknode/sdk

3

Crea tu archivo principal

Crea un archivo «index.js» para tu código:

touch index.js

4

Añade este código a tu archivo index.js

Copia y pega este código en tu archivo 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

Ejecuta tu proyecto

Ejecuta tu script para ver el último número de bloque:

nodo index.js

Python

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto de Python:

mkdir fantom-python-quickstart
cd fantom-python-quickstart

2

Crear y activar un entorno virtual

Crear un entorno virtual para gestionar las dependencias:

python3 -m venv venv
source venv/bin/activate

3

Solicitudes de instalación

Instala la biblioteca «requests» para realizar solicitudes HTTP:

pip instalar requests

4

Crea un script en Python (app.py)

Crea un archivo de Python con el siguiente 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

Ejecuta el script

Ejecuta tu script de Python:

python app.py

JavaScript

1

Configura tu proyecto

Crea un nuevo directorio e inicializa un proyecto de Node.js:

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

2

Crea un archivo JavaScript (app.js)

Crea un archivo «app.js» con el siguiente código (utilizando la función «fetch» nativa disponible en Node.js 18 y versiones posteriores):

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

Ejecuta el script

Ejecuta tu script de JavaScript:

nodo app.js

Rubí

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto de Ruby:

mkdir fantom-ruby-quickstart
cd fantom-ruby-quickstart

2

Comprobar la instalación de Ruby

Comprueba que Ruby esté instalado en tu sistema. Si no es así, instálalo desde https://ruby-lang.org:

ruby --versión

3

Crea un script en Ruby (main.rb)

Crea un archivo «main.rb» con el siguiente 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

Ejecuta el script

Ejecuta tu script de Ruby para ver el último número de bloque:

ruby main.rb

Ir

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto de Go:

mkdir fantom-go-quickstart
cd fantom-go-quickstart

2

Comprobar la instalación de Go

Comprueba que Go esté instalado en tu sistema. Si no es así, instálalo desde https://golang.org:

go versión

3

Crea un script en Go (main.go)

Crea un archivo «main.go» con el siguiente 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

Ejecuta el script

Ejecuta tu script de Go para ver el último número de bloque:

ejecuta main.go

Ethers.js

1

Configura tu proyecto

Crea un nuevo directorio e inicializa un proyecto de Node.js (se da por hecho que Node.js ya está instalado):

mkdir fantom-ethers-quickstart
cd fantom-ethers-quickstart
npm init -y
npm pkg set tipo=módulo

2

Instala ethers.js

Instala la biblioteca ethers.js para interactuar con Ethereum:

npm instalar ethers

3

Crea tu archivo principal (index.js)

Crea un archivo index.js con el siguiente 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

Ejecuta tu proyecto

Ejecuta tu script para ver el último número de bloque:

nodo index.js

Web3.py

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto web3.py:

mkdir fantom-web3py-quickstart
cd fantom-web3py-quickstart

2

Instala web3.py (si aún no lo tienes instalado)

Comprueba si web3.py está instalado con `pip list | grep web3`. Si no lo encuentras, instálalo:

pip instalar web3

3

Crea un script en Python (main.py)

Crea un archivo «main.py» con el siguiente 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

Configura tu proyecto

Crea un nuevo directorio para tu proyecto eth.rb:

mkdir fantom-ethrb-quickstart
cd fantom-ethrb-quickstart

2

Instala eth.rb (si aún no está instalado)

Comprueba si eth.rb está instalado con el comando `gem list eth`. Si no lo encuentras, instálalo:

gem instalar eth

3

Crea un script en Ruby (main.rb)

Crea un archivo «main.rb» con el siguiente 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

Ejecuta el script

Ejecuta tu script de Ruby para ver el último número de bloque:

ruby main.rb

Ethgo

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto Ethgo:

mkdir fantom-ethgo-quickstart
cd fantom-ethgo-quickstart

2

Inicializar el módulo de Go e instalar ethgo

Inicializa un archivo «go.mod» para gestionar las dependencias y, a continuación, instala el SDK de ethgo:

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

3

Crea un script en Go (main.go)

Crea un archivo «main.go» con el siguiente 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

Ejecuta el script

Ejecuta tu script de Go para ver el último número de bloque:

ejecuta main.go

Si quieres seguir aprendiendo a realizar solicitudes a la API, echa un vistazo a nuestras guías y aplicaciones de ejemplo.

Descripción general de la API

Descubre las API de Fantom compatibles, las redes, las configuraciones de cadena y los productos Quicknode compatibles

Puntos de conexión de los proveedores

Descubre cómo instalar y configurar tus puntos de conexión RPC de Fantom para su uso en entornos de desarrollo y producción

Seguridad de los dispositivos finales

Protege tus dispositivos finales mediante la autenticación por token, la limitación de velocidad, las listas blancas, JWT y las mejores prácticas de seguridad

Referencia de error

Documento de referencia sobre los códigos de error habituales de Fantom RPC y consejos para la resolución de problemas

Complementos de Marketplace

Descubre potentes complementos y extensiones para mejorar tu flujo de trabajo de desarrollo con Fantom

¡Nos encanta recibir comentarios!

Si tienes algún comentario o pregunta sobre esta documentación, háznoslo saber. ¡Nos encantaría saber tu opinión!