Resumen

Estos ejemplos muestran la estructura de « SDK » en los productos compatibles de Quicknode . Se da por hecho que ya has inicializado el SDK como qn del Inicio rápido.

Admin API

Utiliza el cliente de Admin API para consultar y gestionar los recursos de la cuenta, como los dispositivos, los equipos, el uso, la facturación, la seguridad y los límites de velocidad.

Node.js

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const puntos finales = await qn.admin.getEndpoints({
  límite: 20,
  sortBy: «created_at»,
  sortDirection: «desc»,
});

para (const endpoint de puntos finales.datos) {
  consola.registro(endpoint.id, endpoint.nombre, endpoint.estado);
}

Python

import asyncio
dequicknode_sdk import QuicknodeSdk

asíncrono def main():
    qn = QuicknodeSdk.from_env()

    puntos finales = await qn.admin.get_endpoints(
        límite=20,
        sort_by="created_at",
        dirección_de_ordenación="desc",
    )

    para endpoint en puntos finales.datos:
        imprimir(endpoint.id, endpoint.nombre, endpoint.estado)

asyncio.ejecutar(main()))

Óxido

use quicknode_sdk::{admin::GetEndpointsRequest, QuicknodeSdk};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    que qn = QuicknodeSdk::from_env()?;

    let parámetros = GetEndpointsRequest {
        límite: Algunos(20),
        sort_by: Algunos(«created_at».to_string()),
        sort_direction: Algunos(«desc».to_string()),
        ..Por defecto::por defecto()
    };
    sea puntos finales = qn.admin.get_endpoints(&params).await?;

    para endpoint en puntos finales.datos {
        println!("{} {} {}", endpoint.id, endpoint.name, endpoint.status);
    }

    Vale(())
}

Rubí

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

puntos finales = qn.admin.get_endpoints(
    límite: 20,
    sort_by: «created_at»,
    sort_direction: «desc»,
)

puntos finales[«datos»].cada hace |endpoint|
  pone "#{endpoint["id"]} #{endpoint["nombre"]} #{endpoint["estado"]}"
fin

Para consultar la superficie completa de la API, consulta la documentación deAdmin API .

Acceso a RPC y herramientas

Puedes utilizar el cliente RPC para enviar solicitudes JSON-RPC al servicio Tooling Access de la cuenta endpoint; qn.rpc genera y actualiza el JWT de la sesión en cada llamada. Activa primero el acceso a las herramientas con el qn.admin métodos del plano de control (requiere un rol de administrador). Aceptar red para desviar una llamada a una red concreta.

Node.js

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

// Enable Tooling Access once (idempotent; requires an admin role).
const estado = await qn.admin.toolingAccessStatus();
si (!estado.habilitado) {
  esperar qn.admin.enableToolingAccess();
}

// params defaults to []; pass an array (positional) or object (named).
const númeroDeBloque = await qn.rpc.llamada("eth_blockNumber");
const saldo = await qn.rpc.llamada("eth_getBalance", ["0xabc...", "más reciente"]);
consola.registro(númeroDeBloque, saldo);

// Route a call to a specific network by its multichain key.
const slot = await qn.rpc.llamada("getSlot", [], "solana-mainnet");
consola.registro(ranura);

Python

import asyncio
dequicknode_sdk import QuicknodeSdk

asíncrono def main():
    qn = QuicknodeSdk.from_env()

    # Habilitar el acceso a las herramientas una sola vez (idempotente; requiere un rol de administrador).
    estado = await qn.admin.estado_acceso_herramientas()
    si no estado.activado:
        esperar qn.admin.enable_tooling_access()

    número_de_bloque = await qn.rpc.llamada("eth_blockNumber")
    saldo = esperar qn.rpc.llamada("eth_getBalance", ["0xabc...", "más reciente"])
    imprimir(número_de_bloque, saldo)

    # Desviar una llamada a una red concreta mediante su clave multichain.
    ranura = await qn.rpc.llamada("getSlot", red="solana-mainnet")
    imprimir(ranura)

asyncio.ejecutar(main()))

Óxido

uso quicknode_sdk::QuicknodeSdk;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    que qn = QuicknodeSdk::from_env()?;

    // Enable Tooling Access once (idempotent; requires an admin role).
    deja que estado = qn.admin.estado_de_acceso_a_las_herramientas().await?;
    si !estado.activado {
        qn.admin.enable_tooling_access().await?;
    }

    // call(method, params, network, endpoint_url). params is Option; None defaults to [].
    sea número_de_bloque = qn.rpc.llamada("eth_blockNumber", None, None, Ninguno).await?;
    que saldo = qn
        .rpc
        .llamar(
            «eth_getBalance»,
            Algunos(serde_json::json!(["0xabc...", "latest"])),
            Ninguno,
            Ninguno,
        )
        .await?;
    println!("{:?} {:?}", block_number, balance);

    Vale(())
}

Rubí

require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

# Habilitar el acceso a las herramientas una sola vez (idempotente; requiere un rol de administrador).
estado = qn.admin.estado_acceso_herramientas
qn.admin.habilitar_acceso_a_herramientas a menos que estado[«habilitado»]

número_de_bloque = qn.rpc.llamada(método: «eth_blockNumber»)
saldo = qn.rpc.llamada(método: «eth_getBalance», parámetros: ["0xabc...", "latest"])
asigna el número de bloque
aporta equilibrio

# Desviar una llamada a una red concreta mediante su clave multichain.
ranura = qn.rpc.llamada(método: «getSlot», red: «solana-mainnet »)
asigna ranura

Streams

Utiliza el cliente « Streams » para mostrar una lista, examinar, crear, actualizar, pausar, activar, eliminar y probar Streams. El ejemplo siguiente muestra una lista de Streams, cuenta los Streams habilitados y realiza una simulación de un filtro sin modificar el estado de la cuenta.

Node.js

import { QuicknodeSdk, StreamDataset } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const streams = await qn.streams.listStreams({ limit: 10 });
console.log(`Streams: ${streams.pageInfo.total}`);

const habilitado = await qn.streams.getEnabledCount();
console.log(`Enabled Streams: ${enabled.total}`);

const funciónDeFiltro = Buffer.from(`
función main(data) {
  devolver datos;
}
`).toString("base64");

const resultado = await qn.streams.testFilter({
  red: «ethereum-mainnet »,
  conjunto de datos: StreamDataset.Bloque,
  bloque: «17811625»,
  filterFunction,
});

consola.registro(resultado.resultado);

Python

import asyncio
import base64
dequicknode_sdk import QuicknodeSdk

asíncrono def main():
    qn = QuicknodeSdk.from_env()

    streams = await qn.streams.list_streams(límite=10)
    print(f"Streams: {streams.page_info.total}")

    activado = await qn.streams.get_enabled_count()
    print(f"Enabled Streams: {enabled.total}")

    función_de_filtro = base64.b64encode(
        b"function main(data) { return data; }"
    ).decodificar()

    resultado = await qn.streams.test_filter(
        red=«ethereum-mainnet »,
        conjunto de datos=«bloque»,
        bloque=«17811625»,
        función_de_filtro=función_de_filtro,
    )

    imprimir(resultado.resultado)

asyncio.ejecutar(main()))

Óxido

use quicknode_sdk::{
    streams::{ListStreamsParams, StreamDataset, TestFilterParams},
    QuicknodeSdk,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    que qn = QuicknodeSdk::from_env()?;

    sea streams = qn
        .streams
        .list_streams(&ListStreamsParams {
            límite: Algunos(10),
            desplazamiento: Algunos(0),
            ..Por defecto::por defecto()
        })
        .await?;
    println!("Streams: {}", streams.page_info.total);

    que activado = qn.streams.get_enabled_count(None).await?;
    println!("Enabled Streams: {}", enabled.total);

    que resultado = qn
        .streams
        .test_filter(&TestFilterParams {
            red: «ethereum-mainnet ».to_string(),
            conjunto de datos: StreamDataset::Block,
            bloque: «17811625».to_string(),
            función_de_filtro: Algunas(
                "ZnVuY3Rpb24gbWFpbihkYXRhKSB7IHJldHVybiBkYXRhOyB9".to_string(),
            ),
            filter_language: Ninguno,
            configuración_de_la_agenda: Ninguno,
        })
        .await?;

    println!("{}", result.result);
    Vale(())
}

Rubí

require "base64"
require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

streams = qn.streams.list_streams({ limit: 10, offset: 0 })
puts "Streams: #{streams["pageInfo"]["total"]}"

activado = qn.streams.get_enabled_count({})
puts "Enabled Streams: #{enabled["total"]}"

filter_function = Base64.strict_encode64("function main(data) { return data; }")

resultado = qn.streams.test_filter(
    red: «ethereum-mainnet »,
    conjunto de datos: «bloque»,
    bloque: «17811625»,
    función_de_filtro: función_de_filtro,
)

muestra el resultado[«resultado»]

Para conocer las opciones de destino, los conjuntos de datos compatibles y los detalles de las solicitudes, consulta la documentación de la API REST deStreams .

Webhooks

Utiliza el cliente « Webhooks » para ver la lista de webhooks, examinar un webhook, crear un webhook a partir de una plantilla, pausar o activar el envío y consultar el número de webhooks habilitados. El ejemplo que aparece a continuación es de solo lectura.

Node.js

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const webhooks = await qn.webhooks.listWebhooks({
  límite: 10,
  desplazamiento: 0,
});

para (const webhook de webhooks.datos) {
  consola.registro(webhook.id, webhook.nombre, webhook.estado);
}

const activado = await qn.webhooks.getEnabledCount();
console.log(`Enabled webhooks: ${enabled.total}`);

Python

import asyncio
dequicknode_sdk import QuicknodeSdk

asíncrono def main():
    qn = QuicknodeSdk.from_env()

    webhooks = await qn.webhooks.list_webhooks(límite=10, desplazamiento=0)
    para webhook en webhooks.datos:
        imprimir(webhook.id, webhook.nombre, webhook.estado)

    activado = await qn.webhooks.get_enabled_count()
    print(f"Enabled webhooks: {enabled.total}")

asyncio.ejecutar(main()))

Óxido

use quicknode_sdk::{webhooks::GetWebhooksParams, QuicknodeSdk};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    que qn = QuicknodeSdk::from_env()?;

    sea webhooks = qn
        .webhooks
        .list_webhooks(&GetWebhooksParams {
            límite: Algunos(10),
            desplazamiento: Algunos(0),
        })
        .await?;

    para webhook en webhooks.datos {
        println!("{} {} {}", webhook.id, webhook.name, webhook.status);
    }

    que activado = qn.webhooks.get_enabled_count().await?;
    println!("Enabled webhooks: {}", enabled.total);

    Vale(())
}

Rubí

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

webhooks = qn.webhooks.list_webhooks({ limit: 10, offset: 0 })
webhooks[«datos»].cada hace |webhook|
  pone "#{webhook["id"]} #{webhook["nombre"]} #{webhook["estado"]}"
fin

activado = qn.webhooks.get_enabled_count
puts "Enabled webhooks: #{enabled["total"]}"

Para obtener información sobre el comportamiento de las plantillas y la configuración de los destinos, consulta la documentación de la API REST deWebhooks .

Almacén de clave-valor

Utiliza el cliente de almacén de clave-valor para un estado persistente sencillo. Los conjuntos almacenan un valor de cadena por clave. Las listas almacenan colecciones ordenadas de cadenas bajo una misma clave.

Node.js

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const sets = await qn.kvstore.getSets({ limit: 10 });
console.log(`Sets: ${sets.data.length}`);

si (conjuntos.datos.longitud > 0) {
  const set = await qn.kvstore.getSet(establece.datos[0].clave);
  consola.registro(establecer.valor);
}

const lists = await qn.kvstore.getLists({ limit: 10 });
console.log(`Lists: ${lists.data.keys.length}`);

Python

import asyncio
dequicknode_sdk import QuicknodeSdk

asíncrono def main():
    qn = QuicknodeSdk.from_env()

    conjuntos = await qn.kvstore.get_sets(límite=10)
    print(f"Sets: {len(sets.data)}")

    si len(establece.datos) > 0:
        set_value = await qn.kvstore.get_set(conjuntos.datos[0].clave)
        imprimir(set_value.valor)

    listas = await qn.kvstore.get_lists(límite=10)
    print(f"Lists: {len(lists.data.keys)}")

asyncio.ejecutar(main()))

Óxido

use quicknode_sdk::{
    kvstore::{GetListsParams, GetSetsParams},
    QuicknodeSdk,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    que qn = QuicknodeSdk::from_env()?;

    sea conjuntos = qn
        .kvstore
        .get_sets(&GetSetsParams {
            límite: Algunos(10),
            cursor: Ninguno,
        })
        .await?;
    println!("Sets: {}", sets.data.len());

    si supongamos que Algunos(primer_conjunto) = conjuntos.datos.primero() {
        sea establecer = qn.kvstore.get_set(&primer_conjunto.clave).await?;
        println!("{}", set.value);
    }

    que listas = qn
        .kvstore
        .get_lists(&GetListsParams {
            límite: Algunos(10),
            cursor: Ninguno,
        })
        .await?;
    println!("Lists: {}", lists.data.keys.len());

    Vale(())
}

Rubí

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

sets = qn.kvstore.get_sets({ limit: 10 })
puts "Sets: #{sets["data"].length}"

a menos que se establezca[«datos»].vacío?
  establecer = qn.kvstore.get_set(clave: conjuntos[«datos»][0][«clave»])
  establece el conjunto[«valor»]
fin

lists = qn.kvstore.get_lists({ limit: 10 })
puts "Lists: #{lists["data"]["keys"].length}"

Para todas las operaciones con listas y conjuntos, consulta la documentación de la API REST de Key-Value Store.

Explorador SQL

Utiliza el cliente SQL Explorer para ejecutar consultas SQL sobre datos indexados de la cadena de bloques y recuperar los esquemas de las tablas.

Node.js

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

// Run a SQL query
const resultado = await qn.sql.consulta(
  "SELECT action_type, user FROM hyperliquid_system_actions LIMIT 3",
  "hyperliquid-core-mainnet"
);
console.log(`${result.rows} rows, ${result.credits} credits`);

// Get the schema for a cluster
const esquema = await qn.sql.getSchema("hyperliquid-core-mainnet");
consola.registro(esquema);

Python

import asyncio
dequicknode_sdk import QuicknodeSdk

asíncrono def main():
    qn = QuicknodeSdk.from_env()

    # Ejecutar una consulta SQL
    resultado = await qn.sql.consulta(
        "SELECT action_type, user FROM hyperliquid_system_actions LIMIT 3",
        "hyperliquid-core-mainnet",
    )
    imprimir(f"{resultado.filas} filas, {resultado.créditos} créditos")

    # Obtener el esquema de un clúster
    esquema = await qn.sql.get_schema("hyperliquid-core-mainnet")
    imprimir(esquema)

asyncio.ejecutar(main()))

Óxido

uso quicknode_sdk::QuicknodeSdk;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    que qn = QuicknodeSdk::from_env()?;

    // Run a SQL query
    que resultado = qn
        .sql
        .consulta(
            "SELECT action_type, user FROM hyperliquid_system_actions LIMIT 3",
            "hyperliquid-core-mainnet",
        )
        .await?;
    println!("{} rows, {} credits", result.rows, result.credits);

    // Get the schema for a cluster
    let esquema = qn.sql.get_schema("hyperliquid-core-mainnet").await?;
    println!("{:?}", schema);

    Vale(())
}

Rubí

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

# Ejecutar una consulta SQL
resultado = qn.sql.consulta(
    "SELECT action_type, user FROM hyperliquid_system_actions LIMIT 3",
    "hyperliquid-core-mainnet",
)
pone "#{resultado["filas"]} filas, #{resultado["créditos"]} créditos"

# Obtener el esquema de un clúster
esquema = qn.sql.get_schema("hyperliquid-core-mainnet")
esquema «puts»

Para conocer la sintaxis de las consultas y las tablas disponibles, consulta la documentación de SQL Explorer.

Agente ejemplo de flujo de trabajo

Agentes puede combinar clientes en una sola ejecución. Por ejemplo, una herramienta de automatización de lanzamientos Agente puede inspeccionar los terminales, Streams, Webhooks, el estado del almacén de clave-valor y consultar datos de la cadena de bloques antes de decidir qué acción llevar a cabo.

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const endpoints = await qn.admin.getEndpoints({ tagLabels: ["sdk-managed"] });
const streams = await qn.streams.listStreams({ limit: 10 });
const webhooks = await qn.webhooks.listWebhooks({ limit: 10 });
const sets = await qn.kvstore.getSets({ limit: 10 });
const operaciones = await qn.sql.consulta(
  "SELECT * FROM hyperliquid_trades LIMIT 5",
  "hyperliquid-core-mainnet"
);

consola.registro({
  puntos finales: puntos finales.datos.longitud,
  streams: streams.datos.longitud,
  webhooks: webhooks.datos.longitud,
  conjuntos: conjuntos.datos.longitud,
  oficios: oficios.filas,
});