Visão geral

Estes exemplos ilustram SDK nos Quicknode suportados. Partem do princípio de que já inicializou o SDK qn do Início Rápido.

Admin API

Utilize o Admin API para analisar e gerir os recursos da conta, tais como pontos de extremidade, equipas, utilização, faturação, segurança e limites de taxa.

Node.js

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

const qn = QuicknodeSdk.fromEnv();

const endpoints = await qn.admin.getEndpoints({
  limit: 20,
  sortBy: "created_at",
  sortDirection: "desc",
});

for (const endpoint of endpoints.data) {
  console.log(endpoint.id, endpoint.name, endpoint.status);
}

Python

import asyncio
dequicknodeimport QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    pontos de extremidade = await qn.admin.get_endpoints(
        limite=20,
        ordenar_por="created_at",
        sort_direction="desc",
    )

    para endpoint em pontos finais.dados:
        imprimir(endpoint.id, endpoint.nome, endpoint.estado)

asyncio.executar(main()))

Rust

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

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

    let params = GetEndpointsRequest {
        limit: Some(20),
        sort_by: Some("created_at".to_string()),
        sort_direction: Some("desc".to_string()),
        ..Default::default()
    };
    let endpoints = qn.admin.get_endpoints(&params).await?;

    for endpoint in endpoints.data {
        println!("{} {} {}", endpoint.id, endpoint.name, endpoint.status);
    }

    Ok(())
}

Ruby

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

endpoints = qn.admin.get_endpoints(
    limit: 20,
    sort_by: "created_at",
    sort_direction: "desc",
)

endpoints["data"].each do |endpoint|
  puts "#{endpoint["id"]} #{endpoint["name"]} #{endpoint["status"]}"
end

Para conhecer toda a superfície da API, consulte Admin API .

Acesso a RPC e ferramentas

Pode utilizar o cliente RPC para enviar pedidos JSON-RPC para o endpoint «Tooling Access» da conta; qn.rpc gera e atualiza o JWT da sessão em cada chamada. Ative primeiro o acesso às ferramentas com o qn.admin métodos do plano de controlo (requer uma função de administrador). Passar rede para encaminhar uma chamada para uma rede específica.

Node.js

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

const qn = QuicknodeSdk.fromEnv();

// Enable Tooling Access once (idempotent; requires an admin role).
const status = await qn.admin.toolingAccessStatus();
if (!status.enabled) {
  await qn.admin.enableToolingAccess();
}

// params defaults to []; pass an array (positional) or object (named).
const blockNumber = await qn.rpc.call("eth_blockNumber");
const balance = await qn.rpc.call("eth_getBalance", ["0xabc...", "latest"]);
console.log(blockNumber, balance);

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

Python

import asyncio
dequicknodeimport QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    # Ativar o acesso às ferramentas uma vez (idempotente; requer uma função de administrador).
    status = await qn.admin.tooling_access_status()
    se não status.ativado:
        aguardar qn.admin.enable_tooling_access()

    número_do_bloco = await qn.rpc.chamada("eth_blockNumber")
    saldo = await qn.rpc.chamada("eth_getBalance", ["0xabc...", "mais recente"])
    imprimir(número_do_bloco, saldo)

    # Encaminhar uma chamada para uma rede específica através da sua chave multichain.
    slot = await qn.rpc.chamada("getSlot", rede="mainnet")
    imprimir(slot)

asyncio.executar(main()))

Rust

use quicknode_sdk::QuicknodeSdk;

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

    // Enable Tooling Access once (idempotent; requires an admin role).
    let status = qn.admin.tooling_access_status().await?;
    if !status.enabled {
        qn.admin.enable_tooling_access().await?;
    }

    // call(method, params, network, endpoint_url). params is Option; None defaults to [].
    let block_number = qn.rpc.call("eth_blockNumber", None, None, None).await?;
    let balance = qn
        .rpc
        .call(
            "eth_getBalance",
            Some(serde_json::json!(["0xabc...", "latest"])),
            None,
            None,
        )
        .await?;
    println!("{:?} {:?}", block_number, balance);

    Ok(())
}

Ruby

necessita de "quicknode"

qn = QuicknodeSdk::SDK.from_env

# Ativar o acesso às ferramentas uma vez (idempotente; requer uma função de administrador).
status = qn.admin.estado_de_acesso_aos_ferramentas
qn.admin.ativar_acesso_a_ferramentas a menos que status["ativado"]

número_do_bloco = qn.rpc.chamada(método: "eth_blockNumber")
saldo = qn.rpc.chamada(método: "eth_getBalance", parâmetros: ["0xabc...", "mais recente"])
imprime o número do bloco
imprime saldo

# Encaminhar uma chamada para uma rede específica através da sua chave multichain.
slot = qn.rpc.chamada(método: "getSlot", rede: "mainnet")
coloca o slot

Streams

Utilize o Streams para listar, inspecionar, criar, atualizar, pausar, ativar, eliminar e testar Streams. O exemplo abaixo lista Streams, conta Streams ativados e executa um filtro em modo de simulação sem alterar o estado da conta.

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 enabled = await qn.streams.getEnabledCount();
console.log(`Enabled Streams: ${enabled.total}`);

const filterFunction = Buffer.from(`
function main(data) {
  return data;
}
`).toString("base64");

const result = await qn.streams.testFilter({
  network: "ethereum-mainnet",
  dataset: StreamDataset.Block,
  block: "17811625",
  filterFunction,
});

console.log(result.result);

Python

import asyncio
import base64
from quicknode_sdk import QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

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

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

    filter_function = base64.b64encode(
        b"function main(data) { return data; }"
    ).decode()

    result = await qn.streams.test_filter(
        network="ethereum-mainnet",
        dataset="block",
        block="17811625",
        filter_function=filter_function,
    )

    print(result.result)

asyncio.run(main())

Rust

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

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

    let streams = qn
        .streams
        .list_streams(&ListStreamsParams {
            limit: Some(10),
            offset: Some(0),
            ..Default::default()
        })
        .await?;
    println!("Streams: {}", streams.page_info.total);

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

    let result = qn
        .streams
        .test_filter(&TestFilterParams {
            network: "ethereum-mainnet".to_string(),
            dataset: StreamDataset::Block,
            block: "17811625".to_string(),
            filter_function: Some(
                "ZnVuY3Rpb24gbWFpbihkYXRhKSB7IHJldHVybiBkYXRhOyB9".to_string(),
            ),
            filter_language: None,
            address_book_config: None,
        })
        .await?;

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

Ruby

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"]}"

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

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

result = qn.streams.test_filter(
    network: "ethereum-mainnet",
    dataset: "block",
    block: "17811625",
    filter_function: filter_function,
)

puts result["result"]

Para conhecer as opções de destino, os conjuntos de dados suportados e os detalhes dos pedidos, consulte a documentação da APIStreams .

Webhooks

Utilize o Webhooks para listar webhooks, analisar um webhook, criar um webhook a partir de um modelo, suspender ou ativar a entrega e obter as contagens de webhooks ativados. O exemplo abaixo é apenas para consulta.

Node.js

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

const qn = QuicknodeSdk.fromEnv();

const webhooks = await qn.webhooks.listWebhooks({
  limit: 10,
  offset: 0,
});

for (const webhook of webhooks.data) {
  console.log(webhook.id, webhook.name, webhook.status);
}

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

Python

import asyncio
from quicknode_sdk import QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    webhooks = await qn.webhooks.list_webhooks(limit=10, offset=0)
    for webhook in webhooks.data:
        print(webhook.id, webhook.name, webhook.status)

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

asyncio.run(main())

Rust

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

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

    let webhooks = qn
        .webhooks
        .list_webhooks(&GetWebhooksParams {
            limit: Some(10),
            offset: Some(0),
        })
        .await?;

    for webhook in webhooks.data {
        println!("{} {} {}", webhook.id, webhook.name, webhook.status);
    }

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

    Ok(())
}

Ruby

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

webhooks = qn.webhooks.list_webhooks({ limit: 10, offset: 0 })
webhooks["data"].each do |webhook|
  puts "#{webhook["id"]} #{webhook["name"]} #{webhook["status"]}"
end

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

Para obter informações sobre o comportamento dos modelos e a configuração do destino, consulte a documentação da APIWebhooks .

Armazenamento chave-valor

Utilize o cliente Key-Value Store para um estado persistente simples. Os conjuntos «sets» armazenam um valor de cadeia de caracteres por chave. As listas «lists» armazenam coleções ordenadas de cadeias de caracteres sob uma única chave.

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}`);

if (sets.data.length > 0) {
  const set = await qn.kvstore.getSet(sets.data[0].key);
  console.log(set.value);
}

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

Python

import asyncio
from quicknode_sdk import QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    sets = await qn.kvstore.get_sets(limit=10)
    print(f"Sets: {len(sets.data)}")

    if len(sets.data) > 0:
        set_value = await qn.kvstore.get_set(sets.data[0].key)
        print(set_value.value)

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

asyncio.run(main())

Rust

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

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

    let sets = qn
        .kvstore
        .get_sets(&GetSetsParams {
            limit: Some(10),
            cursor: None,
        })
        .await?;
    println!("Sets: {}", sets.data.len());

    if let Some(first_set) = sets.data.first() {
        let set = qn.kvstore.get_set(&first_set.key).await?;
        println!("{}", set.value);
    }

    let lists = qn
        .kvstore
        .get_lists(&GetListsParams {
            limit: Some(10),
            cursor: None,
        })
        .await?;
    println!("Lists: {}", lists.data.keys.len());

    Ok(())
}

Ruby

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

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

unless sets["data"].empty?
  set = qn.kvstore.get_set(key: sets["data"][0]["key"])
  puts set["value"]
end

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

Para todas as operações relacionadas com listas e conjuntos, consulte a documentação da API REST do Key-Value Store.

SQL Explorer

Utilize o cliente SQL Explorer para executar consultas SQL em dados da blockchain indexados e recuperar esquemas de tabelas.

Node.js

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

const qn = QuicknodeSdk.fromEnv();

// Run a SQL query
const result = await qn.sql.query(
  "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 schema = await qn.sql.getSchema("hyperliquid-core-mainnet");
console.log(schema);

Python

import asyncio
from quicknode_sdk import QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    # Run a SQL query
    result = await qn.sql.query(
        "SELECT action_type, user FROM hyperliquid_system_actions LIMIT 3",
        "hyperliquid-core-mainnet",
    )
    print(f"{result.rows} rows, {result.credits} credits")

    # Get the schema for a cluster
    schema = await qn.sql.get_schema("hyperliquid-core-mainnet")
    print(schema)

asyncio.run(main())

Rust

use quicknode_sdk::QuicknodeSdk;

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

    // Run a SQL query
    let result = qn
        .sql
        .query(
            "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 schema = qn.sql.get_schema("hyperliquid-core-mainnet").await?;
    println!("{:?}", schema);

    Ok(())
}

Ruby

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

# Run a SQL query
result = qn.sql.query(
    "SELECT action_type, user FROM hyperliquid_system_actions LIMIT 3",
    "hyperliquid-core-mainnet",
)
puts "#{result["rows"]} rows, #{result["credits"]} credits"

# Get the schema for a cluster
schema = qn.sql.get_schema("hyperliquid-core-mainnet")
puts schema

Para obter informações sobre a sintaxe das consultas e as tabelas disponíveis, consulte a documentação do SQL Explorer.

Exemplo de Agent

Agents combinar clientes numa única execução. Por exemplo, um agent de automatização de lançamentos agent inspecionar terminais, Streams, Webhooks, o estado do armazenamento chave-valor e consultar dados da blockchain antes de decidir que ação tomar.

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 trades = await qn.sql.query(
  "SELECT * FROM hyperliquid_trades LIMIT 5",
  "hyperliquid-core-mainnet"
);

console.log({
  endpoints: endpoints.data.length,
  streams: streams.data.length,
  webhooks: webhooks.data.length,
  sets: sets.data.length,
  trades: trades.rows,
});