Los programas on-chain no pueden acceder directamente a datos off-chain. Dependen de los oráculos para introducir información como precios de activos, resultados de eventos o respuestas de API. Sin estos oráculos, los programas están limitados al estado que ya está almacenado on-chain.

Switchboard es una red de oráculos descentralizada multicadena, construida originalmente en Solana para proporcionar a los smart contracts datos off-chain confiables, como precios, clima y datos de eventos. En este tutorial, construiremos un programa de Solana que lee el precio actual de SOL/USD desde Switchboard.

Haremos tres cosas en este tutorial:

1. Construir y desplegar un programa de Solana que lea datos de Switchboard.
2. Inicializar y configurar un nuevo feed de precios de Switchboard para nuestro programa.
3. Escribir un script de cliente que interactúe con nuestro programa en Devnet para mostrar el precio.

Antes de construir el programa de Solana, primero entendamos cómo funciona Switchboard.

Cómo funciona Switchboard

Switchboard utiliza los siguientes 4 componentes clave para permitir que los programas de Solana lean datos off-chain:

1. Jobs: Un job en Switchboard es una colección de tareas secuenciales. Cada tarea realiza una operación específica. Por ejemplo, una tarea puede obtener datos de un endpoint de API externo mientras que otra tarea analiza la respuesta.
2. Data Sources: De aquí provienen los datos off-chain, como Binance, Coinbase y Pyth. Los jobs de Switchboard obtienen datos de estas fuentes.
3. Oracles: Son los nodos de la red de Switchboard que ejecutan tus jobs. Cada oráculo obtiene datos de todos los data sources configurados, los agrega y envía un único valor i128 al feed on-chain.
4. Feed: El feed es la cuenta on-chain que almacena los envíos de los oráculos. Cuando tu programa lee el feed, recibe el valor agregado producido a partir de los resultados individuales de los oráculos, que el SDK de Switchboard convierte a un tipo Decimal para la aritmética decimal.

En resumen, así es como los componentes anteriores funcionan juntos:

• Defines los jobs que especifican de dónde obtener los datos (data sources)
• Los nodos de los oráculos ejecutan estos jobs y envían sus resultados a la cuenta del feed on-chain
• El feed agrega los envíos de los oráculos en un único valor i128
• Tu programa lee desde el feed

Aprenderemos cómo funcionan estos procesos en el transcurso de este tutorial. Comencemos con la implementación de nuestros feeds de precios.

Requisitos previos

Para seguir el tutorial, necesitarás un entorno de desarrollo de Solana funcional con las siguientes herramientas instaladas:

• Solana CLI y Anchor: necesarios para escribir, construir y desplegar programas de Solana. Si aún no los tienes configurados, lee el primer artículo de esta serie.
• Bun: como gestor de paquetes para ejecutar el script del cliente. Ejecuta este comando en tu Terminal curl -fsSL https://bun.sh/install | bash para instalar Bun.

Interactuaremos con nuestro programa desplegado utilizando scripts independientes en lugar de pruebas unitarias. Esto se debe a que los feeds de precios se actualizan en Devnet, y queremos demostrar cómo los datos de los oráculos en tiempo real fluyen hacia la lógica on-chain.

Configura tu clúster de Solana en Devnet ejecutando el siguiente comando en tu terminal:

Copy
solana config set --url [https://api.devnet.solana.com](https://api.devnet.solana.com/)

También necesitarás algo de SOL en Devnet para pagar las transacciones. Puedes solicitar SOL de prueba del faucet utilizando solana airdrop:

Copy
solana airdrop 2 # for 2 devnet SOL.

Solo puedes solicitar 2 SOL en el faucet de Devnet a la vez. Puedes solicitar 2, esperar un momento y solicitar otro más tarde, ya que tiene un límite de uso.

Solana slots

En Solana, el tiempo se mide en slots, que son intervalos secuenciales de tiempo de red durante los cuales la cadena avanza; el número de un slot aumenta a medida que la red progresa y se utiliza como un reloj simple para ordenar eventos on-chain. Esto es similar al número de bloque de Ethereum (block.number) solo porque ambos representan la progresión del tiempo y el ordenamiento de los eventos.

Quédate con esta idea de los slots; Switchboard los utiliza para medir la antigüedad de los datos, veremos cómo se usa más adelante en este artículo.

Configuración del programa

Comenzaremos creando un proyecto de Anchor que define el programa de Solana, el cual extraerá los datos de precio desde Switchboard.

Copy
anchor init switchboard-demo
cd switchboard-demo

Actualiza el campo cluster en tu proveedor de Anchor.toml para usar Devnet, ya que trabajaremos en Devnet:

Copy
[provider]
cluster = "Devnet"
wallet = "~/.config/solana/id.json"

A continuación, agregaremos el crate switchboard-on-demand a la sección de dependencias de nuestro archivo programs/switchboard-demon/src/Cargo.toml. Es el crate de Switchboard con el que trabajaremos.

Copy
[dependencies]
anchor-lang = "0.31.1"
switchboard-on-demand = "0.5.3"

Dentro de programs/switchboard-demo/src/lib.rs, escribimos un programa que:

1. Lee los datos de la cuenta del feed on-demand de Switchboard como bytes sin procesar.
2. Analiza los bytes sin procesar del feed en un struct PullFeedAccountData del crate switchboard-on-demand.
3. Llama al método get_value en el feed analizado con los siguientes parámetros para validar y extraer el último precio:
   • max_stale_slots: establece el número máximo de slots de Solana desde la última actualización de la cuenta del feed. Si el feed es más antiguo que esto, feed.get_value falla.
   • min_samples: establece el número mínimo de envíos de oráculos requeridos para un precio válido.
   • only_positive: cuando es verdadero, rechaza valores no positivos (≤ 0). Útil para precios o cantidades que siempre deben ser positivas.
4. Registra el precio de SOL/USD usando msg!.

Copy
use anchor_lang::prelude::*;
use switchboard_on_demand::{
    on_demand::accounts::pull_feed::PullFeedAccountData,
    prelude::rust_decimal,
};
use rust_decimal::Decimal;

declare_id!("iSYBH57FJPsqKnVxz8pyqPvCLEBH63y95Vgk346utR2");

#[program]
pub mod switch_on_demand_price_feed {
    use super::*;

    pub fn read_price(ctx: Context<ReadPrice>) -> Result<()> {
        // Step 1: READS THE FEED ACCOUNT's RAW BINARY (bytes)
        let data_slice = ctx.accounts.feed.data.borrow();

        // Step 2: PARSE FEED ACCOUNT DATA
        let feed = PullFeedAccountData::parse(data_slice).unwrap();

        // Step 3: RETRIEVE FEED VALUE WITH SLOT, SAMPLING CONSTRAIN, 
        //         AND THE PARAMETER THAT DETERMINES WHETHER THE RECEIVED VALUE 
        //         IS POSITIVE OR NEGATIVE
        let price: Decimal = feed.get_value(
            &Clock::get()?,
            /*max_stale_slots=*/ 100,
            /*min_samples=*/ 3,
            /*only_positive=*/ true,
        ).unwrap();
        
        // Step 4: LOGS THE SOL/USD PRICE WITH `msg!`.
        msg!("SOL/USD price: {}", price);
        Ok(())
    }
}

#[derive(Accounts)]
pub struct ReadPrice<'info> {
    /// CHECK: This is a Switchboard on-chain feed (PullFeedAccount)
    pub feed: AccountInfo<'info>,
}

Nota el comentario sobre la antigüedad del slot y las restricciones de muestreo en el paso 3. Cada vez que Switchboard escribe un nuevo valor on-chain, registra el número de slot. Cuando llamas a feed.get_value(&Clock::get()?, max_stale_slots, ...), Switchboard compara el slot actual con el slot de la última actualización del feed.

Si la diferencia supera max_stale_slots (100 en nuestro código), get_value devuelve un error. La instrucción falla y la transacción es rechazada.

Además, el parámetro min_samples asegura que agreguemos respuestas de suficientes oráculos para aumentar la precisión. En nuestro ejemplo, lo hemos establecido en 3, lo que significa que el resultado debe incluir datos de al menos 3 respuestas de oráculos. Veremos cómo configurar estos oráculos más adelante en este artículo cuando discutamos la inicialización off-chain.

A continuación, construye y despliega el programa ejecutando el siguiente comando:

Copy
anchor build && anchor deploy

Un despliegue exitoso devolverá el Id del programa y la firma como se muestra a continuación:

Nuestro programa on-chain ahora está desplegado y puede registrar el precio de SOL/USD, pero aún no podemos usarlo porque, aunque el programa está listo para leer un precio desde la cuenta del feed, todavía no tiene un feed específico desde el cual leer. Abordaremos esto a continuación configurando el feed off-chain.

Configuración del feed off-chain

Recuerda que el feed es la cuenta on-chain que almacena los envíos de los oráculos.

Configurar un feed implica dos pasos, que cubriremos a continuación:

1. Configuración e inicialización del feed
2. Actualizaciones del feed

1/2 Configuración e inicialización del feed

La configuración del feed define los data sources y las reglas de agregación para tu oráculo (como las on-chain, p. ej. max_stale_slots). Especificas qué APIs externas u oráculos on-chain consultar, cuántas respuestas necesitas y la varianza aceptable entre las fuentes. Esta configuración existe como un objeto de JavaScript antes de que algo vaya on-chain.

La inicialización del feed toma la configuración y crea la cuenta real on-chain. La transacción de inicialización almacena los metadatos de tu feed, lo vincula a un grupo de nodos de oráculos (denominado “oracle queue” en Switchboard), y genera la public key a la que tu programa debe hacer referencia al solicitar datos de precios.

A diferencia de los oráculos de Chainlink, los feeds de Switchboard no se actualizan automáticamente. Utilizan un modelo pull. Tu programa debe desencadenar un job a través de un script off-chain para obtener nuevos datos y actualizar el feed on-chain.

Cada job consiste en:

1. Array de tareas: Una lista de tareas que contiene operaciones para ejecutar secuencialmente.
2. Tipos de tareas: Diferentes tareas en el Array de tareas, tales como:
   • httpTask: que obtiene los datos del feed desde una URL.
   • jsonParseTask: Extrae valores específicos de la respuesta JSON retornada desde httpTask usando una consulta de ruta.

El siguiente ejemplo muestra un job con dos tareas: una que obtiene datos de la tasa de cambio desde la API de Coinbase y otra que analiza la respuesta.

Típicamente, implementarías estos jobs tú mismo, usando una función por job. Sin embargo, no implementaremos manualmente la lógica de obtención en este ejemplo por simplicidad.

El equipo de Switchboard ya ha proporcionado un archivo público utils.ts que contiene implementaciones comunes de obtención de jobs. En su lugar, utilizaremos esas. Abre el archivo utils en GitHub, copia el contenido y pégalo en /scripts/utils.ts.

Configuración de múltiples data sources

El diagrama anterior muestra una tarea con un solo origen. En un programa real, necesitarás múltiples fuentes, lo que significa que tendrás múltiples jobs. Las fuentes múltiples previenen puntos únicos de falla y permiten que el feed filtre valores atípicos a través de comprobaciones de varianza.

Creación del script de inicialización

Crea un archivo initializeFeeds.ts en la carpeta /scripts y ejecuta el siguiente comando para instalar las dependencias que necesitaremos para interactuar con la red de Switchboard. También usaremos @solana/web3.js, incluido con nuestra instalación de Anchor.

Copy
yarn add @switchboard-xyz/on-demand @switchboard-xyz/common

Nuestro script ejecuta 5 pasos:

1. Define cuatro jobs para leer el precio de SOL/USD: uno lee del oráculo on-chain de Pyth, tres leen de APIs REST.
2. Configura el feed con las reglas de agregación (maxStaleness, minimumSamples, etc).
3. Genera un nuevo keypair de cuenta del feed para crear una dirección única on-chain que almacene los datos de precio del feed.
4. Utiliza Crossbar, el servicio de Switchboard para subir a IPFS, para almacenar las definiciones de los jobs off-chain. Esto evita costos de almacenamiento on-chain. Crossbar devuelve el hash de contenido de IPFS que usarán los oráculos para obtener las definiciones almacenadas de los jobs. Veremos cómo los oráculos usan este hash en la sección de actualizaciones del feed.
5. Construye y envía la transacción de inicialización del feed para crear el feed on-chain.

Copy
import { PublicKey } from "@solana/web3.js";
import * as sb from "@switchboard-xyz/on-demand";
import { AnchorUtils, PullFeed } from "@switchboard-xyz/on-demand";
import { CrossbarClient, decodeString } from "@switchboard-xyz/common";
import {
  buildCoinbaseJob,
  buildBinanceJob,
  buildPythJob,
  buildBybitJob,
  TX_CONFIG,
} from "./utils";

const crossbarClient = new CrossbarClient(
  "https://crossbar.switchboard.xyz",
  /* verbose= */ true
);

// 1. DEFINE FOUR FEED JOBs to READ SOL/USD PRICE
const FEED_JOBS = [
  // Pyth oracle passing the SOL/USD price feed public key
  buildPythJob("H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG"),
  
  // Web API Endpoints
  buildCoinbaseJob("SOL-USD"),
  buildBinanceJob("SOLUSDT"),
  buildBybitJob("SOLUSDT"),
];

(async function main() {
   // Load wallet and RPC connection from Solana CLI config (~/.config/solana/id.json)
   // Then fetch the network's default oracle queue
  const { keypair, connection, program } = await AnchorUtils.loadEnv();
  const queueAccount = await sb.getDefaultQueue(connection.rpcEndpoint);
  const queue = queueAccount.pubkey;

  // 2. FEED CONFIGURATION
  const conf: any = {
    name: "SOL-USD Price Feed", // the feed name (max 32 bytes)
    queue: new PublicKey(queue), // the queue of oracles to bind to
    maxVariance: 1.0, // allow 1% variance between submissions and jobs
    minResponses: 3, // minimum number of responses of jobs to allow
    numSignatures: 3, // number of signatures to fetch per update
    minSampleSize: 3, // minimum number of responses to sample for a result
    maxStaleness: 100, // maximum stale slots of responses to sample
  };

  // 3. GENERATE FEED KEYPAIR
  console.log("Initializing new data feed");
  const [pullFeed, feedKp] = PullFeed.generate(program!);
  
  // 4. STORE JOB DEFINITIONS ON IPFS
  conf.feedHash = decodeString(
    (await crossbarClient.store(queue.toString(), FEED_JOBS)).feedHash
  );
  
   // 5. BUILD AND SEND THE INITIALIZATION TRANSACTION 
   //    WITH THE FEED CONFIGURATION
  const initTx = await sb.asV0Tx({
    connection,
    ixs: [await pullFeed.initIx(conf)],
    payer: keypair.publicKey,
    signers: [keypair, feedKp],
    computeUnitPrice: 75_000,
    computeUnitLimitMultiple: 1.3,
  });
  
  console.log("Sending initialize transaction");
  const sig = await connection.sendTransaction(initTx, TX_CONFIG);
  await connection.confirmTransaction(sig, "confirmed");
  console.log(`Feed ${feedKp.publicKey} initialized: ${sig}`);
  
})();

Expliquemos las partes clave específicas de Switchboard del código anterior:

Oracle queues

El script recupera la oracle queue por defecto para tu red usando sb.getDefaultQueue(). La queue es el mecanismo de coordinación de Switchboard para los nodos de los oráculos. Cuando vinculas un feed a una queue, le estás indicando a la red de Switchboard qué grupo de oráculos puede cumplir con las solicitudes de actualización para tu feed. Cada queue tiene su propio conjunto de oráculos registrados, parámetros de recompensa y reglas operativas. En Devnet, esto devuelve la queue pública de prueba que todos los desarrolladores comparten.

La configuración del feed

En el código anterior, la configuración del feed es el conjunto de reglas que agrega los resultados de nuestros jobs en un único valor de confianza. Esta confianza proviene de múltiples capas de validación de nuestra configuración:

• minResponses: Requerimos al menos 3 respuestas exitosas por actualización, y muestreamos al menos 3 envíos al calcular el resultado. Esto se alinea con min_samples = 3 en nuestra llamada on-chain a get_value.
• maxVariance: Establecemos esto en 1.0, lo que significa que si una fuente informa un precio que difiere en más de un 1% de los demás, puede ser descartada por inconsistente.
• maxStaleness: Esto asegura que los datos sean recientes, correspondiendo al valor max_stale_slots en nuestro programa on-chain.

Ejecuta el script usando bun, el entorno de ejecución de JavaScript que instalamos antes:

Copy
bun run scripts/initializeFeeds.ts

El resultado contendrá la public key del feed obtenida de la cuenta del feed en el programa, como se muestra a continuación:

Este feed ahora está activo en Devnet, pero aún está vacío. En la siguiente sección, comenzaremos a llenarlo con datos utilizando esta public key.

2/2 Actualización del feed

Ahora que nuestra cuenta del feed está inicializada, necesitamos un proceso para poblarla continuamente con datos frescos. La actualización del feed es la parte del proceso que asegura que la cuenta del feed siempre contenga datos actualizados.

Crearemos un script, runfeeds.ts, que ejecuta un bucle infinito. En cada iteración, solicita los últimos precios para nuestros jobs a la red de Switchboard utilizando la public key del feed. Los datos de todos los oráculos se agregan, y el script luego envía una transacción para almacenar el resultado validado en nuestra cuenta del feed on-chain.

Copy
import * as sb from "@switchboard-xyz/on-demand";
import { CrossbarClient } from "@switchboard-xyz/common";
import yargs from "yargs";
import { TX_CONFIG, sleep } from "./utils";
import { PublicKey } from "@solana/web3.js";

/// Parse command-line arguments - requires the feed account public key '--feed'
const argv = yargs(process.argv).options({ feed: { required: true } })
  .argv as any;

  console.log(`Using feed: ${argv.feed}`);

// The main function is wrapped in an immediately-invoked async function expression (IIFE).
(async function main() {
  // Load wallet keypair, RPC connection, and program
  const { keypair, connection, program } = await sb.AnchorUtils.loadEnv();
  
  // Load the default Switchboard queue account for the specified network (devnet or mainnet).
  const queue = await sb.Queue.loadDefault(program!);
  
  // Initialize a 'PullFeed' object to interact with the 
  // on-chain data feed public key specified in the terminal.
  const feedAccount = new sb.PullFeed(program!, argv.feed!);
  
  // Connect to Switchboard's off-chain infrastructure
  const crossbar = new CrossbarClient("https://crossbar.switchboard.xyz");
  const gateway = await queue.fetchGatewayFromCrossbar(crossbar as any);
  
  // Cache address lookup tables to reduce transaction size
  await feedAccount.preHeatLuts();
  let runCount = 0;

  console.log("Starting feed updater.");

  // Start an infinite loop to continuously update the data feed.
  while (true) {
    try {
      console.log(`\n--- Update #${++runCount} ---`);
      
      // Request fresh oracle data. The gateway reads the feedHash from the feed account,
      // retrieves job definitions from IPFS, distributes them to oracles, and returns
      // their aggregated responses
      const [pullIx, responses, _ok, luts] = await feedAccount.fetchUpdateIx({
        gateway: gateway.gatewayUrl,
        crossbarClient: crossbar as any,
      });

      // Check for oracle errors
      let hasError = false;
      for (const response of responses) {
        const shortErr = response.shortError();
        if (shortErr) {
          console.log(`Oracle response error: ${shortErr}`);
          hasError = true;
        }
      }

      // Skip update if errors occurred or no instructions returned
      if (hasError || !pullIx || pullIx.length === 0) {
        console.log("Skipping update due to oracle errors or no instructions generated.");
        await sleep(5000); // Wait longer before retrying if there are errors.
        continue;
      }

      // Assemble the update instructions into a versioned transaction (v0).
      const tx = await sb.asV0Tx({
        connection,
        ixs: [...pullIx!],
        signers: [keypair], // The payer's keypair must sign the transaction.
        computeUnitPrice: 200_000, // Set a priority fee to get the transaction processed faster.
        computeUnitLimitMultiple: 1.3, // Add a buffer to the compute unit limit to prevent failure.
        lookupTables: luts, // Include the pre-heated LUTs.
      });

      // Send transaction to update the feed on-chain
      const sig = await connection.sendTransaction(tx, TX_CONFIG);
      console.log(`✅ Transaction sent: https://explorer.solana.com/tx/${sig}?cluster=devnet`);
      
      console.log("Waiting for confirmation...");
      await connection.confirmTransaction(sig, "confirmed");
      console.log("✅ Transaction confirmed!");

    } catch (e) {
        console.error("❌ An error occurred in the main loop:", e);
    } finally {
        // Pause execution for a few seconds before starting the next update cycle.
        await sleep(5000);
    }
  }
})();

Cómo se utiliza el hash de contenido de IPFS

Cuando se llama a feedAccount.fetchUpdateIx():

1. Lee los datos de la cuenta del feed de Solana, que contienen el feedHash (el hash de contenido de IPFS almacenado durante la inicialización).
2. Envía una solicitud al gateway con este feedHash.
3. El gateway (y los oráculos) usan el feedHash para recuperar las definiciones de los jobs desde IPFS.
4. Los oráculos ejecutan esos jobs (obtienen datos de Pyth, Coinbase, Binance, Bybit).
5. Los oráculos devuelven sus resultados al gateway de Switchboard, el cual los agrega.
6. fetchUpdateIx() devuelve instrucciones (pullIx) que escriben los datos agregados de los oráculos en la cuenta del feed si la transacción es exitosa.

Ejecutaremos el script con la public key del feed como un argumento de línea de comandos, como se muestra a continuación:

Copy
bun scripts/runfeeds.ts --feed GgGVgSLWAyL9Xf4fGaAQQCkmWetBjX7PCNz8kTK97DKB

Y el resultado se verá así:

Mantendremos este script ejecutándose continuamente para asegurar que siempre recibamos datos frescos.

Leyendo el precio de SOL/USD

Ahora que tenemos el programa desplegado y el feed actualizándose continuamente, escribamos un script para leer el precio de SOL/USD.

Esto es lo que hace el siguiente script:

1. Definir la cuenta del feed: Proporcionas la public key de la cuenta del feed creada anteriormente a través de nuestro script de inicialización de feed (GgGVgSLWAyL9Xf4fGaAQQCkmWetBjX7PCNz8kTK97DKB).
2. Construir la instrucción: El método ****.readPrice() de Switchboard hace referencia al método read_price on-chain. El paso .accounts({ feed }) vincula la cuenta del feed a la instrucción.
3. Construir la transacción: Envuelve la instrucción en una transacción versionada con firmas y límites de cómputo.
4. Simular la transacción: Primero simula la transacción para previsualizar los logs y detectar errores antes de gastar comisiones de transacción. La salida de msg! de tu programa on-chain aparece aquí, la cual el script captura y muestra.
5. Enviar la transacción a la red de Solana: Finalmente, el script envía la transacción on-chain e imprime un enlace para verla en Solana Explorer.

Copy
import { PublicKey } from "@solana/web3.js";
import * as sb from "@switchboard-xyz/on-demand";
import * as anchor from "@coral-xyz/anchor";
import { TX_CONFIG } from "./utils";

(async function main() {
  try {
    console.log("Getting SOL/USD price from Switchboard...");
    
    // Load keypair and connection from local environment
    const { keypair, connection } = await sb.AnchorUtils.loadEnv();
    
    // Create Anchor provider and attach it
    const provider = new anchor.AnchorProvider(
      connection,
      new anchor.Wallet(keypair),
      { commitment: "confirmed" }
    );
    anchor.setProvider(provider);
    
    // Load the deployed program using Anchor's workspace
    const program = anchor.workspace.switchOnDemandPriceFeed;
    
    // ====== 1. DEFINE FEED ACCOUNT ======
    // Replace with YOUR feed account address from initializeFeeds.ts output
    const feedAccount = new PublicKey("GgGVgSLWAyL9Xf4fGaAQQCkmWetBjX7PCNz8kTK97DKB");
    
    // 2. **BUILD THE INSTRUCTION**
    // Build the instruction to call the 'read_price' method on-chain
    const ix = await program.methods
      .readPrice()
      .accounts({
        feed: feedAccount,
      })
      .instruction();
      
    // ====== 3. BUILDING THE TRANSACTION ======
    // Wrap in a versioned transaction, with the payer signing
    const tx = await sb.asV0Tx({
      connection,
      ixs: [ix],
      payer: keypair.publicKey,
      signers: [keypair],
      computeUnitPrice: 200_000,
      computeUnitLimitMultiple: 1.3,
    });
    
    // ====== 4. TRANSACTION SIMULATION ======
    // Simulate the transaction to capture logs (including our price output)
    const sim = await connection.simulateTransaction(tx, TX_CONFIG);
    
    if (sim.value.logs) {
      const priceLog = sim.value.logs.find(log => 
        log.includes("SOL/USD price:"));
      
      if (priceLog) {
        console.log(`✅ ${priceLog}`);
      } else {
        console.log("All logs:", sim.value.logs);
      }
    }
    
    // ====== 5. SENDING THE TRANSACTION TO THE SOLANA NETWORK ======
    // Send the actual transaction and log its signature link
    const sig = await connection.sendTransaction(tx, TX_CONFIG);
    console.log(`📝 Transaction: https://explorer.solana.com/tx/${sig}?cluster=devnet`);
    
  } catch (error) {
    console.error("❌ Error getting price:", error);
  }
})();

Ahora, con runfeeds.ts activo en una terminal, abre una segunda terminal y ejecuta el script de lectura:

Copy
bun run scripts/showPrice.ts

Deberías ver el precio de SOL/USD registrado directamente desde tu programa on-chain, lo que confirma que toda la tubería de datos está funcionando.

En nuestro ejemplo, simplemente estamos obteniendo el precio y mostrándolo. Podrías construir cualquier cosa que utilice los datos de Switchboard on-chain.

Conclusión

Hemos aprendido a interactuar con el flujo de trabajo del oráculo de Switchboard para obtener datos confiables de múltiples fuentes y utilizarlos on-chain. Los pasos involucrados en este proceso son:

• escribir tu programa on-chain, el cual debe interactuar con los datos de la cuenta del feed de Switchboard.
• inicializar y configurar los feeds de Switchboard off-chain, lo que genera una public key de la cuenta del feed on-chain que el ejecutador de feeds de tu aplicación puede utilizar para actualizar los datos continuamente.
• ejecutar scripts de cliente para leer desde el feed utilizando la public key.

Ejercicio de seguimiento

Crea un programa que calcule el impacto del precio, evaluando cómo el deslizamiento afectaría a las operaciones de trading. La función debe utilizar los datos del feed de precios de Switchboard.

• Recuperar el precio actual de SOL/USD desde Switchboard.
• Implementar un modelo de deslizamiento por niveles basado en el tamaño de la operación.
• Calcular el precio de ejecución real después del deslizamiento.
• Reportar el tamaño de la operación original, el precio de mercado actual, el impacto del precio calculado y el precio de ejecución efectivo después del deslizamiento.