Cómo lanzar un token en Elysium y hacer trading con él en Hyperliquid
Escrito por Uttam Singh
Elysium es la Layer 2 de Kinetiq para Hyperliquid, y su mainnet se lanzó el 9 de noviembre. Es una cadena EVM con bloques de 100 ms que usa HYPE para el gas y liquida en HyperEVM. Un token de Elysium puede negociarse en los propios libros de órdenes de Hyperliquid. Esta guía recorre el camino completo. Despliegas un ERC-20 en Elysium con Foundry y nuestro RPC de Elysium, creas su espejo en HyperEVM y luego ejecutas el listado en HyperCore que lo coloca en un libro de órdenes spot contra USDC.
Desplegar y crear el espejo es barato y no requiere permisos, aunque el primer mint del espejo debe esperar un período de impugnación de unos 5.5 días. El listado en HyperCore es una ceremonia única del emisor en Hyperliquid, y empieza con una subasta del ticker cuyo precio nunca baja de 500 HYPE. Todo lo que viene después de esa ceremonia está abierto a cualquier holder, que puede mover el token entre Elysium, HyperEVM y HyperCore a través de los bridges.
¿Qué debes saber sobre Elysium antes del lanzamiento?
Elysium es una cadena de Arbitrum Orbit construida por Kinetiq que liquida en HyperEVM y se ejecuta coubicada con HyperCore. HyperCore es la capa de exchange de Hyperliquid, donde viven sus libros de órdenes de spot y de perpetuos. HyperEVM es el entorno EVM que se ejecuta junto a HyperCore en la misma L1 de Hyperliquid. Nuestro post sobre apostar todo por Hyperliquid explica cómo encajan ambas partes, y nuestra guía de trading en Elysium cubre la cadena en sí con más profundidad, desde por qué Hyperliquid necesita una L2 hasta las apps que se lanzan en ella.
HyperEVM limita su capacidad a propósito. Sus bloques pequeños admiten 3M de gas cada segundo, y solo los bloques grandes, que se producen una vez por minuto, admiten 30M de gas. Kinetiq construyó Elysium para cargas de trabajo que necesitan más, como los market makers que refrescan sus cotizaciones varias veces por segundo. La cadena apunta a 300 Mgas/s (millones de gas por segundo) de ejecución, aproximadamente dos órdenes de magnitud más que HyperEVM, y mantiene HYPE como el único token que necesitas para hacer transacciones.
Los bloques de Elysium son bloques canónicos reales, así que latest y los recibos de transacción tienen su significado habitual, sin una capa de preconfirmación encima. Solidity, Foundry, Hardhat y viem funcionan sin cambios. Kinetiq también se comprometió a destinar el 25% de las comisiones del sequencer a los builders cuyas apps generan actividad en la cadena.
Somos el principal proveedor de RPC de Elysium, y la documentación de Kinetiq nos incluye como el proveedor de infraestructura recomendado para Elysium. Nuestra página de RPC de Elysium y nuestro quickstart de la API de Elysium tienen los endpoints de mainnet. Dos detalles de nuestro FAQ de la API de Elysium ahorran tiempo de depuración:
- El export
elysiumTestnetdeviem/chainses otra cadena. Pertenece a un proyecto no relacionado, así que define tú mismo el Elysium de Kinetiq condefineChain. - Una transferencia simple de HYPE cuesta un poco más de 21,000 de gas. Las cadenas de Arbitrum agregan una pequeña cantidad por los datos de la cadena padre, así que un límite de gas de
21000fijado en el código falla conintrinsic gas too low.
¿Cómo llega un token de Elysium a un libro de órdenes de HyperCore?
Un token hace dos saltos de bridge, y cada salto tiene su propia configuración:
Elysium your ERC-20
| mirror bridge: lock on Elysium, mint a 1:1 mirror on HyperEVM
v
HyperEVM the mirror, a plain ERC-20
| deposit wallet: escrow on HyperEVM that HyperCore credits and debits
v
HyperCore a spot token with an order book against USDCEl bridge espejo no necesita código en tu token. Bloquea el original en Elysium en una wallet de escrow y mintea un espejo 1:1 en HyperEVM, así que el suministro del espejo siempre es igual a lo que está bloqueado.
HyperCore vincula cada token spot con un solo contrato EVM, y el desplegador tiene que demostrar que controla ese contrato. Un contrato desplegado directamente desde una wallet lo demuestra con su nonce de despliegue. Tu espejo lo despliega la factory del bridge, así que esa verificación no le sirve. Una wallet de depósito resuelve esto siguiendo el patrón que usa Circle para vincular USDC. Mantiene el espejo en escrow, guarda tu dirección de firma en el slot de almacenamiento que HyperCore lee para los contratos desplegados por una factory, y se convierte en el contrato al que HyperCore se vincula.
Tres decisiones de este camino no se pueden deshacer, así que defínelas antes de gastar nada. Son los decimales del token en HyperCore (fijados cuando ganas el ticker), su suministro de génesis y el vínculo entre el token de HyperCore y la wallet de depósito.
¿Cómo despliegas el token en Elysium?
Necesitas tres cosas antes de que algo toque la cadena:
- Un endpoint de Elysium. Crea una app en el dashboard de Alchemy y selecciona Elysium.
- HYPE en Elysium. HYPE pasa por bridge 1:1 desde HyperEVM a través del bridge de Kinetiq y llega como gas nativo, sin un token wrapped intermedio.
- Foundry. Todos los comandos de abajo usan
forgeycast, y la misma clave del desplegador firma en Elysium, HyperEVM y HyperCore.
El bridge espejo acepta cualquier ERC-20 estándar que cumpla tres propiedades. Debe exponer name(), symbol() y decimals(), porque con esos metadatos el bridge empareja el token con su espejo. Los metadatos nunca deben cambiar. Además, las transferencias deben mover exactamente la cantidad solicitada, lo que descarta los tokens con comisión por transferencia y los tokens de rebase. Un ERC-20 simple de OpenZeppelin cumple las tres. Nuestra guía de tokens ERC-20 en Solidity cubre qué hace cada función.
Planifica desde ahora el suministro según los límites de HyperCore. HyperCore guarda los saldos como enteros de 64 bits y permite como máximo 8 decimales de wei, lo que limita un token con 8 decimales a unos 184 mil millones de unidades enteras. Un suministro fijo de mil millones cabe con holgura:
// SPDX-License-Identifier: MIT
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract ExampleToken is ERC20 {
constructor() ERC20("Example Token", "EXMPL") {
_mint(msg.sender, 1_000_000_000 * 10 ** decimals());
}
}El ERC-20 de OpenZeppelin define el nombre y el símbolo una sola vez en el constructor, y sin función de mint el suministro queda fijo en el despliegue. Guarda el contrato como src/ExampleToken.sol y despliégalo:
forge init example-token && cd example-token
forge install OpenZeppelin/openzeppelin-contracts
# Save the contract above as src/ExampleToken.sol, then import your deployer key once.
cast wallet import deployer --interactive
export ELYSIUM_RPC="https://elysium-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY"
forge create src/ExampleToken.sol:ExampleToken \
--rpc-url "$ELYSIUM_RPC" \
--account deployer \
--broadcastcast wallet import guarda la clave en un keystore cifrado, y --account la desbloquea al momento de firmar, así que la clave sin procesar nunca aparece en el historial de tu shell. Nuestra guía de tokens en Robinhood Chain usa el mismo flujo en otra cadena de Arbitrum Orbit.
Para ver la frecuencia de bloques por ti mismo, suscríbete a los bloques nuevos a través del endpoint WebSocket. A este ritmo, el polling por HTTP se salta bloques entre consultas, así que usa aquí la URL de WebSocket:
import { createPublicClient, defineChain, webSocket } from "viem";
const wssUrl = process.env.ELYSIUM_WSS;
if (!wssUrl) throw new Error("Set ELYSIUM_WSS to your Alchemy Elysium WebSocket URL");
// viem/chains exports an unrelated chain called elysiumTestnet, so define Elysium yourself.
const elysium = defineChain({
id: 99901, // Elysium mainnet
name: "Elysium",
nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 },
rpcUrls: { default: { http: [], webSocket: [wssUrl] } },
});
const client = createPublicClient({ chain: elysium, transport: webSocket(wssUrl) });
let previous;
client.watchBlocks({
onBlock: (block) => {
const now = Date.now();
if (previous) console.log(`block ${block.number} arrived ${now - previous} ms after the last one`);
previous = now;
},
onError: (error) => console.error(error.message),
});Define ELYSIUM_WSS con la URL wss://elysium-mainnet.g.alchemy.com/v2/ y tu key. Puedes consultar tu token y sus transacciones en el explorador de Elysium.
¿Cómo creas el espejo del token en HyperEVM?
El bridge espejo tiene dos partes. Una wallet de escrow en Elysium guarda los tokens bloqueados, y en HyperEVM hay un ERC-20 espejo que solo el bridge puede mintear y quemar. La configuración no requiere permisos y toma una transacción en cada cadena, en cualquier orden. Las direcciones de abajo son las de la mainnet de Elysium, tomadas de la página de direcciones de contratos de Kinetiq. Verifícalas ahí antes de enviar fondos:
export HYPEREVM_RPC="https://hyperliquid-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY"
export TOKEN=<your token's address on Elysium>
export BRIDGE_FACTORY=0x209B0476ec33841c661f41C0C260A3b8aF94164A # ElysiumBridgeFactory, on Elysium
export MIRROR_FACTORY=0x473D61817Da6ce1a97aDC010FF1e96048504643B # ElysiumMirrorFactory, on HyperEVM
export ELYSIUM_ROUTER=0x61EbbC3A29f1970aF2Ce862bA9c5364832E14d17 # gateway router, on Elysium
export DEPLOYER=$(cast wallet address --account deployer)
# Elysium: deploy the escrow wallet that will hold locked tokens.
cast send "$BRIDGE_FACTORY" "createL2Wallet(address)" "$TOKEN" \
--rpc-url "$ELYSIUM_RPC" --account deployer
# The one mirror address the factory derived from your token's name, symbol, and decimals.
export MIRROR=$(cast call "$BRIDGE_FACTORY" "expectedL1Mirror(address)(address)" "$TOKEN" --rpc-url "$ELYSIUM_RPC")La transacción en HyperEVM despliega el espejo en esa dirección y registra el par con el bridge en ambas cadenas. Paga en HYPE dos mensajes de entrega a Elysium, y el valor que envías debe ser exactamente igual a la suma de los presupuestos de ambos mensajes. Kinetiq recomienda ofertar el doble del precio de gas actual de Elysium, con un mínimo de 0.5 gwei, para que ambos mensajes se ejecuten al llegar. Lo que aprovisiones de más se reembolsa a tu dirección en Elysium:
GAS_PRICE_BID=$(( $(cast gas-price --rpc-url "$ELYSIUM_RPC") * 2 )) # 2x the current Elysium gas price
(( GAS_PRICE_BID < 500000000 )) && GAS_PRICE_BID=500000000 # at least 0.5 gwei
MAX_GAS=300000
MAX_SUBMISSION=400000000000000 # 0.0004 HYPE per message
VALUE_EACH=$(( MAX_SUBMISSION + MAX_GAS * GAS_PRICE_BID ))
cast send "$MIRROR_FACTORY" \
"createAndRegisterL1Mirror(address,string,string,uint8,(uint256,uint256,uint256,uint256,uint256,uint256,uint256,address))" \
"$TOKEN" "Example Token" "EXMPL" 18 \
"($MAX_SUBMISSION,$MAX_SUBMISSION,$MAX_GAS,$MAX_GAS,$GAS_PRICE_BID,$VALUE_EACH,$VALUE_EACH,$DEPLOYER)" \
--value $(( 2 * VALUE_EACH )) \
--rpc-url "$HYPEREVM_RPC" --account deployerPasa el nombre, el símbolo y los decimales exactos que tiene el token en vivo. La factory acepta cualquier metadato, pero solo el espejo que coincide con tu token puede recibir suministro, y uno que no coincide queda vacío para siempre. Los dos mensajes normalmente llegan a Elysium en menos de un minuto. Si uno no se ejecuta, vuelve a ejecutar el mismo registro con los mismos argumentos para reenviar ambos.
Ahora el bridge está abierto para cualquier holder. Para mover tokens, aprueba la wallet de escrow en Elysium y envíalos a través del router. El router recibe la dirección del espejo como argumento del token en ambas direcciones:
export WALLET=$(cast call "$BRIDGE_FACTORY" "l2WalletFor(address)(address)" "$TOKEN" --rpc-url "$ELYSIUM_RPC")
AMOUNT=$(cast to-wei 1000000) # 1,000,000 tokens, converted to 18-decimal base units
cast send "$TOKEN" "approve(address,uint256)" "$WALLET" "$AMOUNT" \
--rpc-url "$ELYSIUM_RPC" --account deployer
cast send "$ELYSIUM_ROUTER" "outboundTransfer(address,address,uint256,uint256,uint256,bytes)" \
"$MIRROR" "$DEPLOYER" "$AMOUNT" 0 0 0x \
--rpc-url "$ELYSIUM_RPC" --account deployerEl bloqueo ocurre de inmediato. El espejo se puede reclamar en HyperEVM una vez que pasa el período de impugnación de Elysium, que es la ventana de espera de los mensajes que salen de un optimistic rollup y dura unos 5.5 días en mainnet. Cualquiera puede reclamarlo, y el bridge de Kinetiq muestra la transferencia como reclamable cuando está lista. Planifica el primer mint del espejo en torno a esa espera. Cuando se confirme el reclamo, lee el suministro del espejo con el Alchemy CLI:
alchemy evm contract read "$MIRROR" "totalSupply()(uint256)" -n hyperliquid-mainnetEl viaje de vuelta es más rápido. Quemar el espejo en HyperEVM libera el original en Elysium, normalmente en menos de un minuto.
Los integradores que listen el espejo deberían verificarlo a través de la factory en lugar de confiar solo en la dirección. La verificación de Kinetiq combina dos lecturas. elysiumTokenOf(mirror) en la factory de espejos debe devolver el token original, y el suministro del espejo debe ser mayor que cero, algo que un espejo que no coincide nunca puede alcanzar.
¿Cómo listas el token en un libro de órdenes spot de HyperCore?
El listado es una ceremonia del emisor en HyperCore con cinco partes. Compras un ticker, creas la wallet de depósito, ejecutas la génesis, vinculas el token a la wallet y registras el par spot. La guía de despliegue spot de Kinetiq documenta la ceremonia completa. Solo la dirección que gana el ticker puede firmar las acciones de HyperCore, y no hay allowlist ni revisión entre comprar el ticker y tener un libro de órdenes activo. En la práctica, la ceremonia abarca varios días, porque la subasta sigue su propio calendario.
¿Cuánto cuesta la subasta del ticker?
Los tickers se venden en una subasta holandesa de 31 horas. El precio baja de forma lineal hacia un precio mínimo de 500 HYPE, y cada nueva subasta abre al doble del precio de la venta anterior, o en el precio mínimo si la última subasta no se vendió. La documentación de Hyperliquid pide a los desplegadores ensayar primero el despliegue exacto en testnet, porque el pago de la subasta no se puede reembolsar si un despliegue se queda atascado.
Las acciones de HyperCore de abajo usan el SDK de Python de Hyperliquid y firman con el mismo keystore de Foundry que las transacciones EVM:
import getpass
import json
import pathlib
import eth_account
from hyperliquid.exchange import Exchange
from hyperliquid.info import Info
from hyperliquid.utils import constants
from hyperliquid.utils.signing import get_timestamp_ms, sign_l1_action
keystore = json.loads(pathlib.Path("~/.foundry/keystores/deployer").expanduser().read_text())
deployer = eth_account.Account.from_key(
eth_account.Account.decrypt(keystore, getpass.getpass("Keystore password: "))
)
exchange = Exchange(deployer, base_url=constants.MAINNET_API_URL)
info = Info(constants.MAINNET_API_URL, skip_ws=True)
def ok(response):
if response.get("status") != "ok":
raise RuntimeError(response)
return response
auction = info.post("/info", {"type": "spotDeployState", "user": deployer.address})["gasAuction"]
print("Current ticker price in HYPE:", auction["currentGas"])Nuestra HyperCore Data API, ahora en acceso anticipado, sirve el mismo estado de la subasta.
Cuando el precio sea aceptable, compra el ticker. Esta llamada fija para siempre la especificación de decimales en HyperCore. El ejemplo usa 8 decimales de wei y 2 decimales de tamaño, lo que cumple la regla de HyperCore de que los decimales de wei sean al menos los decimales de tamaño más 5. El tope de la oferta está en unidades de HyperCore, donde HYPE tiene 8 decimales:
MAX_GAS = 600 * 10**8 # refuse to pay more than 600 HYPE
result = ok(exchange.spot_deploy_register_token("EXMPL", 2, 8, MAX_GAS, "Example Token"))
TOKEN_INDEX = result["response"]["data"]
print("Ticker index:", TOKEN_INDEX)¿Cómo encajan la wallet de depósito, la génesis y el vínculo?
Crea la wallet de depósito en HyperEVM mientras el ticker todavía no está vinculado. El último argumento es la dirección que firmará el vínculo, que la wallet escribe en el slot de almacenamiento que HyperCore verifica:
export DEPOSIT_WALLET_FACTORY=0x9aD2639eB48FD7dd0f6F310F04aF5A9f7937cf6c # HyperCoreDepositFactory, on HyperEVM
export TOKEN_INDEX=<ticker index from the purchase>
cast send "$DEPOSIT_WALLET_FACTORY" "createWallet(address,uint64,address)" "$MIRROR" "$TOKEN_INDEX" "$DEPLOYER" \
--rpc-url "$HYPEREVM_RPC" --account deployer
cast call "$DEPOSIT_WALLET_FACTORY" "walletFor(address,uint64,address)(address)" "$MIRROR" "$TOKEN_INDEX" "$DEPLOYER" \
--rpc-url "$HYPEREVM_RPC"La génesis crea todo el suministro del token en HyperCore. En un token que llega por bridge, todo va a la dirección del sistema del token, una dirección reservada de HyperCore formada por 0x20 seguido del índice del ticker. El suministro sale de la dirección del sistema solo cuando alguien deposita tokens espejo en escrow, así que el suministro circulante en HyperCore siempre coincide con lo que tiene la wallet de depósito. La génesis se ejecuta una sola vez. Un token que llega por bridge también desactiva Hyperliquidity, la estrategia de HIP-2 que siembra un libro nuevo con órdenes operadas por el protocolo:
MAX_SUPPLY_WEI = str(1_000_000_000 * 10**8) # one billion tokens at 8 HyperCore decimals
SYSTEM_ADDRESS = "0x20" + format(TOKEN_INDEX, "038x") # 0x20, then the index in the remaining 19 bytes
ok(exchange.spot_deploy_user_genesis(TOKEN_INDEX, [(SYSTEM_ADDRESS, MAX_SUPPLY_WEI)], []))
ok(exchange.spot_deploy_genesis(TOKEN_INDEX, MAX_SUPPLY_WEI, True)) # True = no HyperliquidityEl vínculo consta de dos acciones de HyperCore, una solicitud que nombra la wallet de depósito y una finalización firmada por la dirección guardada en ella. El desfase de decimales es la diferencia entre los 18 decimales del ERC-20 y los 8 del token de HyperCore. El SDK no tiene un helper para estas acciones, así que fírmalas y envíalas directamente. El vínculo es permanente:
DEPOSIT_WALLET = "<deposit wallet address from walletFor>"
def submit(action):
nonce = get_timestamp_ms()
signature = sign_l1_action(deployer, action, None, nonce, None, True) # True = mainnet
return ok(exchange.post("/exchange", {
"action": action, "nonce": nonce, "signature": signature, "vaultAddress": None,
}))
submit({"type": "spotDeploy", "requestEvmContract": {
"token": TOKEN_INDEX, "address": DEPOSIT_WALLET.lower(), "evmExtraWeiDecimals": 10,
}})
submit({"type": "finalizeEvmContract", "token": TOKEN_INDEX, "input": "customStorageSlot"})Los depósitos funcionan desde este punto, incluso antes de que el token tenga un libro de órdenes.
¿Cómo abres el libro de órdenes?
Registrar el par spot contra USDC (índice de token 0) y luego registrar Hyperliquidity crea el mercado. La segunda llamada es obligatoria incluso con Hyperliquidity desactivada, en cuyo caso coloca cero órdenes y solo fija el precio de apertura:
pair = ok(exchange.spot_deploy_register_spot(TOKEN_INDEX, 0)) # 0 = USDC
SPOT_INDEX = pair["response"]["data"]
START_PX = 0.01 # opening price in USDC; set it to a real price, not a placeholder
ok(exchange.spot_deploy_register_hyperliquidity(SPOT_INDEX, START_PX, 1, 0, None)) # 0 ordersAhora los holders pueden mover tokens a HyperCore. Aprueban la wallet de depósito para el espejo y llaman a deposit con spot de HyperCore como destino. Con 18 decimales en EVM y 8 en HyperCore, los montos deben ser múltiplos de 10^10 unidades base, y los montos en tokens enteros siempre lo son:
export DEPOSIT_WALLET=<deposit wallet address>
AMOUNT=$(cast to-wei 1000) # 1,000 tokens
cast send "$MIRROR" "approve(address,uint256)" "$DEPOSIT_WALLET" "$AMOUNT" \
--rpc-url "$HYPEREVM_RPC" --account deployer
cast send "$DEPOSIT_WALLET" "deposit(uint256,uint32)" "$AMOUNT" 4294967295 \
--rpc-url "$HYPEREVM_RPC" --account deployer # 4294967295 routes to HyperCore spotHyperCore acredita el saldo en su siguiente bloque. Para volver, se usa una acción sendAsset a la dirección del sistema, que paga el espejo desde el escrow en HyperEVM. Con Hyperliquidity desactivada, el nuevo libro empieza vacío. Tu equipo o un market maker tiene que cotizarlo, usando el ID de activo spot 10000 + SPOT_INDEX para las órdenes.
¿Puede un agente de código hacer esto por ti?
Casi todo el lado EVM se puede automatizar con scripts. Un agente puede desplegar el token, configurar el espejo y pasar suministro por el bridge con Foundry, y luego confirmar cada paso con el Alchemy CLI. Cada comando del CLI acepta --json --no-interactive, así que el agente puede parsear la salida. Si tu agente trabaja con skills o MCP en lugar de una shell, Agent Skills y el Alchemy MCP server cubren las mismas lecturas. Usa -n hyperliquid-mainnet para las lecturas en HyperEVM, y apunta Foundry a tu endpoint de Elysium para todo lo que esté en Elysium.
Deja que una persona firme la ceremonia de HyperCore. Gasta al menos 500 HYPE en la subasta y fija de forma permanente los decimales, el suministro y el vínculo, así que un agente debería preparar esas acciones y una persona debería firmarlas. Un prompt para el lado EVM:
Run `alchemy --json --no-interactive agent-prompt` to load the CLI's command contract, then help me launch a token on Elysium mainnet and mirror it to HyperEVM.
Start by asking me for the token name, symbol, and total supply. Do not invent them. Confirm them back before writing any code.
Then:
- Sign everything with my Foundry keystore account `deployer`. If it doesn't exist, stop and tell me to run `cast wallet import`.
- Get my deployer address with `cast wallet address --account deployer`, then check its HYPE balance on Elysium with `cast balance <deployer-address> --rpc-url <my Alchemy Elysium endpoint>` before each transaction, and stop if it can't cover gas.
- Write a fixed-supply ERC-20 with no owner and no mint function, and deploy it with `forge create --rpc-url <my Alchemy Elysium endpoint>`.
- Run the mirror-bridge setup from Kinetiq's docs, taking every contract address from https://elysium.kinetiq.xyz/docs/contract-addresses. Show me each `cast send` command, with the value in HYPE, before running it.
- Verify the mirror with `alchemy evm contract read <mirror> "totalSupply()(uint256)" -n hyperliquid-mainnet`.
Ask before every transaction that spends HYPE. Do not buy a HyperCore ticker or run any HyperCore deploy action. Stop after the mirror and hand me the addresses.Empieza a construir en Elysium
Crea una app en el dashboard de Alchemy, selecciona Elysium y tendrás un endpoint RPC y WebSocket de mainnet en pocos minutos. Sin contratos, sin lista de espera, sin compromiso mínimo. Los equipos que construyen en Elysium también pueden solicitar créditos a través del programa de créditos de Alchemy para Elysium. Agrega HyperEVM de Hyperliquid a la misma app para el tramo del espejo, y solicita acceso anticipado a HyperCore para hacer streaming del libro de órdenes al que llega tu token.
Resúmenes relacionados
Blockchain6 de noviembre de 2026
Cómo hacer trading en Elysium, la L2 de Hyperliquid
Elysium es la L2 de Hyperliquid de Kinetiq, con bloques de 100 ms y gas en HYPE. Mira cómo se compara con HyperEVM, qué apps se lanzan en ella y cómo empezar a hacer trading.
Técnico20 de octubre de 2026
Órdenes vs. trades vs. fills en Hyperliquid
En Hyperliquid, las órdenes, los trades y los fills son tres registros distintos. Aquí verás cada payload de HyperCore, cómo se unen por oid y tid, y cómo conciliarlos.
Ethereum28 de julio de 2026
Lanza un memecoin en Robinhood Chain
Escribe y despliega un ERC20 de oferta fija en Robinhood Chain mainnet con Foundry y Alchemy RPC, o encárgale todo el lanzamiento a un agente de código con el Alchemy CLI.
Construye magia blockchain
Alchemy combina los productos y herramientas de desarrollo Web3 más potentes con recursos, comunidad y un soporte legendario.