17 minutos de lectura
Resumen
La arquitectura dual de Hyperliquid combina un motor de negociación de alto rendimiento (HyperCore) con compatibilidad con EVM (HyperEVM), lo que genera oportunidades únicas para los desarrolladores de DeFi. Aunque las posibilidades son infinitas, una de las aplicaciones más interesantes es la capacidad de acceder a los datos de precios en tiempo real de HyperCore directamente desde tus dApps de HyperEVM, sin necesidad de un oráculo de precios independiente.
Esta arquitectura única permite acceder a datos de precios en tiempo real —como los precios de los futuros perpetuos— directamente desde tus contratos inteligentes, sin necesidad de recurrir a oráculos externos. Se trata de un avance revolucionario para los desarrolladores de DeFi que desean tener acceso nativo a las primitivas financieras de HyperCore desde un entorno EVM.
En esta guía, crearás un contrato inteligente de HyperEVM que lee los precios en tiempo real de HyperCore. A lo largo del proceso, descubrirás cómo utilizar la interfaz L1Read.sol de Hyperliquid y los contratos precompilados para obtener y convertir los precios del oráculo, sentando así las bases para dApps más avanzadas, como bots de trading, protocolos de préstamos y análisis en cadena.
Lo que aprenderás
- Cómo configurar un proyecto de Foundry para HyperEVM
- Cómo implementar un contrato inteligente en HyperEVM para obtener los precios del oráculo HyperCore aprovechando los precompilados de HyperEVM
- Cómo consultar los datos de precios de HyperCore mediante scripts directos y contratos inteligentes
Lo que necesitarás
- Foundry instalado en tu ordenador
- Conocimientos básicos de Solidity
- Tokens HYPE para pagar el gas (procedentes del grifo de la red de pruebas o de una compra en la red principal)
- Un monedero para el despliegue de contratos (por ejemplo, MetaMask, Rabby o un monedero nuevo creado en Foundry)
- Una cuenta gratuita de Quicknode (opcional, pero recomendada) para acceder al punto final RPC dedicado de Hyperliquid (para la red principal)
La arquitectura de Hyperliquid: HyperCore e HyperEVM
Hyperliquid es una cadena de bloques de capa 1 optimizada para casos de uso de DeFi de alto rendimiento. Su motor central, HyperCore, gestiona un libro de órdenes totalmente en cadena con finalidad en menos de un segundo. Este rendimiento es posible gracias a HyperBFT, el mecanismo de consenso de Hyperliquid, que garantiza la finalidad en un solo bloque y admite hasta 200 000 órdenes por segundo. Por otro lado, HyperEVM integra contratos inteligentes compatibles con Ethereum en este ecosistema, lo que permite a los desarrolladores crear aplicaciones basadas en los datos del libro de órdenes de HyperCore.
HyperCore pone a disposición su funcionalidad a través de «precompiles»: contratos especiales ubicados en direcciones predefinidas que permiten a los contratos de HyperEVM consultar datos como precios de oráculo, metadatos de activos y posiciones de los usuarios. Se puede acceder a ellos directamente en Solidity mediante llamadas estáticas, gracias a la L1Read.sol contrato proporcionado por Hyperliquid. Para asegurarte de que estás utilizando las direcciones de precompilación correctas, consulta siempre la lista más reciente en la página de Hyperliquid documentación oficial para desarrolladores.
En esta guía, utilizaremos las siguientes funciones disponibles en el L1Read.sol contrato:
oraclePx(uint32 índice): Devuelve el precio de Oracle de un contrato de futuros perpetuos sobre un índice determinado. Utiliza elORACLE_PX_PRECOMPILE_ADDRESSprecompilar.perpAssetInfo(uint32 índice): Devuelve los metadatos de un contrato de futuros perpetuos sobre un índice determinado. Utiliza elPERP_ASSET_INFO_PRECOMPILE_ADDRESSprecompilar.
La arquitectura de Hyperliquid permite tanto leer como escribir en el HyperCore dentro de HyperEVM. Sin embargo, sus contratos del sistema de escritura aún no están disponibles en la red principal de HyperEVM. Por lo tanto, en esta guía nos centraremos en la lectura del HyperCore.
Requisitos previos
Antes de empezar, asegúrate de hacer lo siguiente:
Instalar Foundry
Para empezar, asegúrate de tener instalado en tu ordenador Foundry, un conjunto de herramientas para el desarrollo de contratos inteligentes EVM. Si no es así, instálalo ejecutando el siguiente comando en tu terminal:
curl -L https://foundry.paradigm.xyz | bash
foundryup
Si eres nuevo en Foundry, echa un vistazo a nuestro tutorial de Foundry para empezar.
Consigue tu punto de conexión de Quicknode
Para interactuar con HyperEVM, debes conectarte a la cadena de bloques de Hyperliquid mediante un punto final RPC. Aunque puedes utilizar puntos finales RPC públicos, te recomendamos que utilices un punto final dedicado para entornos de producción. Para obtener tu punto final, regístrate para obtener una cuenta gratuita en Quicknode y crea un punto final para Hyperliquid (Mainnet).
Configura tu monedero
Puedes crear un monedero nuevo o utilizar uno ya existente para implementar tu contrato inteligente a través de Foundry.
Al importar tu monedero, te recomendamos que, por motivos de seguridad, cifres tu clave privada en lugar de utilizarla directamente. Para saber más sobre por qué es importante, consulta la guía «Cómo proteger tus claves privadas » de Hardhat y Foundry.
Ejecuta el siguiente comando en tu terminal e introduce la clave privada de tu monedero y una contraseña para cifrarla:
monedero de fundición importar nombre-de-tu-monedero --interactivo
Sustituir nombre-de-tu-monedero con el nombre de tu monedero. Se te pedirá que introduzcas tu clave privada y que establezcas una contraseña para el cifrado. El --interactivo Esta opción garantiza que la clave privada no se guarde en el historial de tu shell, por motivos de seguridad.
Para crear una nueva cartera, puedes utilizar el siguiente comando:
monedero de fundición nuevo
Consigue tokens HYPE
HYPE es el token nativo de Hyperliquid, y necesitarás algunos tokens HYPE para pagar las comisiones de gas del despliegue de nuestro contrato inteligente.
Para la red de pruebas, puedes obtener USDC de prueba a través del «Testnet Faucet» de Hyperliquid y utilizarlo para comprar HYPE. Si quieres utilizar la red principal, puedes adquirir tokens HYPE en la red principal de Hyperliquid. Tanto si utilizas la red de pruebas como la red principal, debes transferir HYPE desde los contratos perpetuos de HyperCore a la cuenta al contado de HyperCore y, a continuación, a HyperEVM, todo ello a través de su interfaz de usuario, tal y como se muestra a continuación:
Mira este vídeo para saber cómo conseguir tokens HYPE en HyperEVM:
En este vídeo, descubrirás todo lo que hay que saber sobre Hyperliquid HyperEVM y cómo dar tus primeros pasos con HyperEVM. Explicamos las diferencias entre HyperCore y HyperEVM, y cómo obtener y transferir tokens HYPE a la cartera de HyperEVM.
Cómo interactuar con HyperCore de HyperEVM
En esta sección, te mostraremos cómo interactuar con los precios de Oracle de HyperCore en tu dApp de HyperEVM utilizando las precompilaciones de HyperEVM. Trataremos los siguientes métodos:
- Uso de consultas directas con Foundry's
Reparto - Creación de un contrato sencillo en Solidity para obtener los precios de HyperCore Oracle
En primer lugar, vamos a crear un proyecto de Foundry con el que trabajar.
Configurar un proyecto de Foundry
Paso 1: Crear un proyecto de Foundry
forge init hyperevm-oracle-prices
cd hyperevm-oracle-prices
Este comando creará un nuevo directorio llamado hyperevm-oracle-precios e inicializar un proyecto de Foundry en su interior, con algunos archivos iniciales (es decir, src/Counter.sol) y configuraciones (es decir, foundry.toml).
├── README.md
├── foundry.toml // Configuración de Foundry archivo
├── lib
├── script
│ └── Counter.s.sol // Script de implementación de Foundry
├── src
│ └── Counter.sol // Contrato principal archivo
└── test
└── Counter.t.sol // Contrato de prueba archivo
Paso 2: Actualizar la estructura de archivos
Cambia el nombre del script de implementación y de los archivos principales del contrato para que coincidan con el nombre del proyecto, y elimina el archivo de prueba, ya que no lo vamos a utilizar en esta guía.
mv script/Counter.s.sol script/DeployPriceOracleReader.s.sol
mv src/Counter.sol src/PriceOracleReader.sol
rm test/Counter.t.sol
Paso 3: Configurar las variables de entorno
Crear un .env archivo en el directorio raíz para almacenar las URL de los puntos de conexión. Puedes utilizar el punto de conexión RPC de Quicknode Hyperliquid en la red principal (Mainnet) o utilizar puntos de conexión públicos.
TESTNET_RPC_URL=https://rpc.hyperliquid-testnet.xyz/evm
MAINNET_RPC_URL=https://rpc.hyperliquid.xyz/evm # o tu propio punto final RPC de Quicknode Hyperliquid
A continuación, carga las variables en tu entorno de terminal:
fuente .env
Paso 4: Actualizar el archivo de configuración de Foundry
Actualizar el foundry.toml archivo para incluir las URL RPC de Hyperliquid:
[perfil.predeterminado]
src = "src"
out = "out"
libs = ["lib"]
[puntos de conexión RPC]
hyperliquid_testnet = "${TESTNET_RPC_URL}"
hyperliquid_mainnet = "${MAINNET_RPC_URL}"
Obtener los metadatos del token
Para obtener los metadatos de un token, realizaremos una llamada a la API del punto final de Hyperliquid. El punto final devuelve el nombre del token, el número de decimales (szDecimals) y otros metadatos, junto con el índice del token.
curl --location 'https://api.hyperliquid.xyz/info' \
--header 'Content-Type: application/json' \
--data '{"type": "meta"}'
Los índices de tokens son diferentes en la red principal y en la red de pruebas. Por lo tanto, debes actualizar el punto final de la API a
https://api.hyperliquid-testnet.xyz/infosi estás utilizando la red de pruebas.
Una vez que hayas obtenido el índice del token (por ejemplo, 5), tendrás que darle el formato adecuado para las llamadas al contrato inteligente. Para ello, debes:
- Conversión del índice a hexadecimal
- Añadiéndole como prefijo
0x - Rellenarlo hasta 32 bytes (64 caracteres hexadecimales) con ceros a la izquierda
Por ejemplo, si el índice del token es 5, la conversión quedaría así:
Decimal: 5
Hexadecimal: 0x0000000000000000000000000000000000000000000000000000000000000005
szDecimalses el número de dígitos significativos del precio. Por ejemplo, en el caso del BTC, elszDecimalses 5.
¡Ya estás listo para empezar! Veamos cómo interactuar con HyperCore de HyperEVM consultando directamente las precompilaciones de HyperCore o creando un contrato sencillo en Solidity para obtener los precios de HyperCore Oracle.
Método 1: Consultas directas con Foundry's Reparto
Este método te permite interactuar rápidamente con las precompilaciones de HyperCore sin necesidad de un contrato desplegado. Puedes utilizar el reparto comando para realizar estas consultas directamente desde tu terminal.
Paso 1: Identificar la dirección de precompilación
Tal y como se explica en el La arquitectura de Hyperliquid En esta sección, hay diferentes tipos de precompilaciones disponibles para interactuar con HyperCore. En este ejemplo, nos centraremos en la ORACLE_PX_PRECOMPILE_ADDRESS, que es la dirección de la precompilación «HyperCore Oracle Prices» y admite un parámetro: el índice del token.
Consulta siempre la documentación oficial para desarrolladores de Hyperliquid para asegurarte de que estás utilizando las direcciones de precompilación correctas.
ORACLE_PX_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000807
Paso 2: Consultar el precio con «Cast»
Se puede utilizar la siguiente plantilla de comando para consultar el precio de cualquier token:
cast call <precompile_address> <input_parameter_token_index> --rpc-url <rpc_url>
Por ejemplo, para consultar el precio del BTC (token con índice 3 en la red de pruebas):
llamada de tipo 0x0000000000000000000000000000000000000807 0x0000000000000000000000000000000000000000000000000000000000000003 --rpc-url $TESTNET_RPC_URL
Las consultas directas utilizan entradas sin procesar de 32 bytes.
El resultado será el precio del BTC en dólares estadounidenses, con un máximo de 5 cifras significativas y 6 - szDecimals decimales, donde szDecimals varía en función del token.
El valor debería aparecer en formato hexadecimal, por ejemplo:
0x00000000000000000000000000000000000000000000000000000000000ea768
Convierte el resultado en un número decimal:
cast --to-dec 0x00000000000000000000000000000000000000000000000000000000000ea768
Por ejemplo, el resultado de este comando es 960360, que representa el precio del BTC en dólares estadounidenses (96036,0) en el momento de redactar esta guía.
Aunque las consultas directas son útiles para realizar pruebas rápidas, un contrato inteligente ofrece una solución en cadena para las dApps. Vamos a crear nuestro PriceOracleReader contrato.
Método 2: Consultar el precio mediante un contrato inteligente
En esta sección, crearemos un contrato inteligente que consulte los precios del oráculo de HyperCore y devuelva el precio de cualquier token.
Paso 1: Importar el contrato L1Read
En primer lugar, tenemos que añadir el L1Read.sol contrato facilitado por Hiperlíquido a nuestro proyecto.
Nota: El
L1Read.solEl contrato no forma parte del paquete oficial de Foundry, por lo que tenemos que añadirlo manualmente.
Nota 2: Hemos modificado el
L1Read.solDefinir todas las funciones externas del contrato como «public», para que podamos llamarlas desde nuestro contrato inteligente.
Crea un nuevo archivo llamado L1Read.sol bajo el src directorio y pega el siguiente código:
Haz clic para ampliar
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract L1Read {
struct Position {
int64 szi;
uint64 entryNtl;
int64 isolatedRawUsd;
uint32 leverage;
bool isIsolated;
}
struct SpotBalance {
uint64 total;
uint64 hold;
uint64 entryNtl;
}
struct UserVaultEquity {
uint64 equity;
uint64 lockedUntilTimestamp;
}
struct Withdrawable {
uint64 withdrawable;
}
struct Delegation {
address validator;
uint64 amount;
uint64 lockedUntilTimestamp;
}
struct DelegatorSummary {
uint64 delegated;
uint64 undelegated;
uint64 totalPendingWithdrawal;
uint64 nPendingWithdrawals;
}
struct PerpAssetInfo {
string coin;
uint32 marginTableId;
uint8 szDecimals;
uint8 maxLeverage;
bool onlyIsolated;
}
struct SpotInfo {
string name;
uint64[2] tokens;
}
struct TokenInfo {
string name;
uint64[] spots;
uint64 deployerTradingFeeShare;
address deployer;
address evmContract;
uint8 szDecimals;
uint8 weiDecimals;
int8 evmExtraWeiDecimals;
}
address constant POSITION_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000800;
address constant SPOT_BALANCE_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000801;
address constant VAULT_EQUITY_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000802;
address constant WITHDRAWABLE_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000803;
address constant DELEGATIONS_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000804;
address constant DELEGATOR_SUMMARY_PRECOMPILE_ADDRESS =
0x0000000000000000000000000000000000000805;
address constant MARK_PX_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000806;
address constant ORACLE_PX_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000807;
address constant SPOT_PX_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000808;
address constant L1_BLOCK_NUMBER_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000000809;
address constant PERP_ASSET_INFO_PRECOMPILE_ADDRESS = 0x000000000000000000000000000000000000080a;
address constant SPOT_INFO_PRECOMPILE_ADDRESS = 0x000000000000000000000000000000000000080b;
address constant TOKEN_INFO_PRECOMPILE_ADDRESS = 0x000000000000000000000000000000000000080C;
function position(address user, uint16 perp) public view returns (Position memory) {
bool success;
bytes memory result;
(success, result) = POSITION_PRECOMPILE_ADDRESS.staticcall(abi.encode(user, perp));
require(success, "Position precompile call failed");
return abi.decode(result, (Position));
}
function spotBalance(address user, uint64 token) public view returns (SpotBalance memory) {
bool success;
bytes memory result;
(success, result) = SPOT_BALANCE_PRECOMPILE_ADDRESS.staticcall(abi.encode(user, token));
require(success, "SpotBalance precompile call failed");
return abi.decode(result, (SpotBalance));
}
function userVaultEquity(
address user,
address vault
) public view returns (UserVaultEquity memory) {
bool success;
bytes memory result;
(success, result) = VAULT_EQUITY_PRECOMPILE_ADDRESS.staticcall(abi.encode(user, vault));
require(success, "VaultEquity precompile call failed");
return abi.decode(result, (UserVaultEquity));
}
function withdrawable(address user) public view returns (Withdrawable memory) {
bool success;
bytes memory result;
(success, result) = WITHDRAWABLE_PRECOMPILE_ADDRESS.staticcall(abi.encode(user));
require(success, "Withdrawable precompile call failed");
return abi.decode(result, (Withdrawable));
}
function delegations(address user) public view returns (Delegation[] memory) {
bool success;
bytes memory result;
(success, result) = DELEGATIONS_PRECOMPILE_ADDRESS.staticcall(abi.encode(user));
require(success, "Delegations precompile call failed");
return abi.decode(result, (Delegation[]));
}
function delegatorSummary(address user) public view returns (DelegatorSummary memory) {
bool success;
bytes memory result;
(success, result) = DELEGATOR_SUMMARY_PRECOMPILE_ADDRESS.staticcall(abi.encode(user));
require(success, "DelegatorySummary precompile call failed");
return abi.decode(result, (DelegatorSummary));
}
function markPx(uint32 index) public view returns (uint64) {
bool success;
bytes memory result;
(success, result) = MARK_PX_PRECOMPILE_ADDRESS.staticcall(abi.encode(index));
require(success, "MarkPx precompile call failed");
return abi.decode(result, (uint64));
}
function oraclePx(uint32 index) public view returns (uint64) {
bool success;
bytes memory result;
(success, result) = ORACLE_PX_PRECOMPILE_ADDRESS.staticcall(abi.encode(index));
require(success, "OraclePx precompile call failed");
return abi.decode(result, (uint64));
}
function spotPx(uint32 index) public view returns (uint64) {
bool success;
bytes memory result;
(success, result) = SPOT_PX_PRECOMPILE_ADDRESS.staticcall(abi.encode(index));
require(success, "SpotPx precompile call failed");
return abi.decode(result, (uint64));
}
function l1BlockNumber() public view returns (uint64) {
bool success;
bytes memory result;
(success, result) = L1_BLOCK_NUMBER_PRECOMPILE_ADDRESS.staticcall(abi.encode());
require(success, "L1BlockNumber precompile call failed");
return abi.decode(result, (uint64));
}
function perpAssetInfo(uint32 perp) public view returns (PerpAssetInfo memory) {
bool success;
bytes memory result;
(success, result) = PERP_ASSET_INFO_PRECOMPILE_ADDRESS.staticcall(abi.encode(perp));
require(success, "PerpAssetInfo precompile call failed");
return abi.decode(result, (PerpAssetInfo));
}
function spotInfo(uint32 spot) public view returns (SpotInfo memory) {
bool success;
bytes memory result;
(success, result) = SPOT_INFO_PRECOMPILE_ADDRESS.staticcall(abi.encode(spot));
require(success, "SpotInfo precompile call failed");
return abi.decode(result, (SpotInfo));
}
function tokenInfo(uint32 token) public view returns (TokenInfo memory) {
bool success;
bytes memory result;
(success, result) = TOKEN_INFO_PRECOMPILE_ADDRESS.staticcall(abi.encode(token));
require(success, "TokenInfo precompile call failed");
return abi.decode(result, (TokenInfo));
}
}
Este archivo incluye funciones que utilizan Solidity's staticcall para interactuar con los precompilados en sus direcciones predefinidas.
Paso 2: Crear un contrato «PriceOracleReader»
Abre el PriceOracleReader.sol Abre el archivo y pega el siguiente código:
Haz clic para ampliar
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
// Import the L1Read contract
import "./L1Read.sol";
contract PriceOracleReader is L1Read {
// Mapping to store the latest price for each perp asset index
mapping(uint32 => uint256) public latestPrices;
// Mapping to store asset names
mapping(uint32 => string) public assetNames;
// Event for price updates
event PriceUpdated(uint32 indexed perpIndex, uint256 price);
/**
* @dev Update the price for a perp asset
* @param perpIndex The index of the perp asset
* @return The converted price with 18 decimals
*/
function updatePrice(uint32 perpIndex) public returns (uint256) {
// Get the raw oracle price using the inherited function
uint64 rawPrice = oraclePx(perpIndex);
// Get the asset info using the inherited function
PerpAssetInfo memory assetInfo = perpAssetInfo(perpIndex);
uint8 szDecimals = assetInfo.szDecimals;
// Store the asset name
assetNames[perpIndex] = assetInfo.coin;
// Convert the price: price / 10^(6 - szDecimals) * 10^18
// This converts from raw price to human-readable price with 18 decimals
uint256 divisor = 10 ** (6 - szDecimals);
uint256 convertedPrice = (uint256(rawPrice) * 1e18) / divisor;
// Store the converted price
latestPrices[perpIndex] = convertedPrice;
// Emit event
emit PriceUpdated(perpIndex, convertedPrice);
return convertedPrice;
}
/**
* @dev Get the latest price for a perp asset
* @param perpIndex The index of the perp asset
* @return The latest converted price with 18 decimals
*/
function getLatestPrice(uint32 perpIndex) public view returns (uint256) {
return latestPrices[perpIndex];
}
}
El presente contrato;
- hereda de la variable local
L1Leercontrato que acabamos de añadir - incluye un
actualizarPreciofunción que recupera el precio más reciente y lo convierte a 18 decimales utilizando la función heredadaoraclePxyperpAssetInfofunciones - incluye un
obtenerPrecioActualfunción que devuelve el último precio de un índice de activos perpetuos determinado - incluye un
Precio actualizadoevento que avisa cuando se actualiza el precio.
El actualizarPrecio La función convierte el precio en bruto en un precio legible para el usuario con 18 decimales. La fórmula de conversión es:
uint256 precioConvertido = (uint256(precio sin convertir) * 1e18) / divisor;
donde precio sin procesar es el precio bruto devuelto por el oraclePx función en formato hexadecimal, divisor se calcula de la siguiente manera: 10 ** (6 - szDecimals), y szDecimals es el número de dígitos significativos del precio.
Paso 3: Implementar el contrato PriceOracleReader
Ahora que tenemos el PriceOracleReader contrato, podemos implementarlo en la red de pruebas o en la red principal.
Paso 4: Crear un script de implementación
Abre el script/DeployPriceOracleReader.s.sol Abre el archivo y pega el siguiente código:
Haz clic para ampliar
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "forge-std/Script.sol";
import "../src/PriceOracleReader.sol";
contract DeployPriceOracleReader is Script {
function run() external {
// Start broadcast to record and send transactions
vm.startBroadcast();
// Deploy the PriceOracleReader contract
PriceOracleReader reader = new PriceOracleReader();
console.log("PriceOracleReader deployed at:", address(reader));
// End broadcast
vm.stopBroadcast();
}
}
Este script implementa el PriceOracleReader contrato y registra la dirección.
Paso 5: Ejecutar el script de implementación
Ejecuta el siguiente comando para compilar e implementar el contrato:
Compilación en Forge
script de Forge script/DeployPriceOracleReader.s.sol:DeployPriceOracleReader --rpc-url $TESTNET_RPC_URL --account nombre-de-tu-monedero --broadcast
Nota: El
--cuentaEl parámetro «flag» especifica el monedero que se utilizará para desplegar el contrato. Puedes utilizar el mismo monedero que importaste anteriormente. Utilizalista de carteras de Castpara ver la lista de tus carteras si no estás seguro de cuál utilizar.
El script de implementación iniciará el proceso de difusión e implementará el contrato. Una vez confirmada la transacción, se implementará el contrato y se registrará la dirección.
Paso 6: Interactúa con tu contrato en HyperEVM
Ahora que el contrato está implementado, podemos llamar a la actualizarPrecio Función para obtener el precio más reciente de un activo perp con un índice determinado. Se puede utilizar el siguiente comando para consultar el precio del activo perp con el índice 3 en la red de pruebas:
cast call <your_contract_address> "updatePrice(uint32)(uint256)" 3 --rpc-url $TESTNET_RPC_URL
Nota: El
actualizarPrecioLa función toma unuint32parámetro, que es el índice del activo perp. Dado que el índice está codificado dentro deloraclePxla propia función, no es necesario pasarla como datos codificados.
Este comando devolverá el último precio del activo perp con índice 3 en wei (18 decimales), por ejemplo: 96036000000000000000000 para representar $96036.
Conclusión
¡Enhorabuena! Ya has aprendido a acceder a los precios de Oracle en tiempo real desde HyperCore utilizando tanto scripts como contratos inteligentes de Solidity a través de HyperEVM. Esta integración abre nuevas posibilidades en el ámbito de las finanzas descentralizadas (DeFi), como plataformas de préstamos, activos sintéticos o bots de arbitraje, todo ello dentro del ecosistema de alto rendimiento y compatible con EVM de Hyperliquid.
Puedes interactuar con tu contrato inteligente HyperEVM utilizando bibliotecas de Ethereum como ethers.js o Viem. Echa un vistazo a nuestras guías de ethers.js y Viem para obtener más información sobre estas bibliotecas.
Próximos pasos
- Explora otras precompilaciones de lectura: HyperCore ofrece una amplia gama de precompilaciones que pueden utilizarse para consultar datos del libro de órdenes de HyperCore. Explora las precompilaciones y sus capacidades para ver cómo pueden utilizarse en tus dApps de HyperEVM.
- Descubre las precompilaciones de escritura de Hyperliquid: las precompilaciones de escritura de Hyperliquid te permiten realizar operaciones en la cadena de bloques, lo que facilita la aplicación de estrategias de negociación avanzadas y una gestión avanzada de las órdenes.
- Amplía tu dApp de HyperEVM: al combinar HyperCore con HyperEVM, puedes crear una dApp que aproveche los datos del libro de órdenes en cadena de HyperCore para ofrecer una experiencia de usuario fluida, como bots de trading, plataformas de préstamos o activos sintéticos.
Recursos adicionales
- Documentación de Hyperliquid
- Guías de Quicknode Hyperliquid
- Documentación de Quicknode Hyperliquid
- Libro de la fundición
- Vídeo: ¿Qué es HyperLiquid HyperEVM y cómo empezar a utilizarlo?
Si te quedas atascado o tienes alguna duda, cuéntanoslo en nuestro Discord. Mantente al día de las últimas novedades siguiéndonos en Twitter (@Quicknode) o en nuestro canal de anuncios de Telegram.
¡Nos encanta recibir comentarios!
Si tienes algún comentario o sugerencia sobre nuevos temas, no dudes en hacérnoslo saber. Nos encantaría saber tu opinión.